第36课 - 遍历二叉树

1. 什么是遍历

单链表的遍历是指从第一个节点开始（下标为0的结点），按照某种次序一次访问每一个结点。

二叉树的遍历是指从根节点开始，按照某种次序一次访问二叉树中的所有结点。

2. 前序遍历

若二叉树为空：空操作返回。

若二叉树不为空：访问根节点中的数据，前序遍历左子树，前序遍历右子树。

结果：1,2,4,8,9,5,10,3,6,7

3. 中序遍历

若二叉树为空：空操作返回。

若二叉树不为空：中序遍历左子树，访问根节点中的数据，中序遍历右子树。

结果：8,4,9,2,10,5,1,6,3,7

4. 后序遍历

若二叉树为空：空操作返回。

若二叉树不为空：后序遍历左子树，后序遍历右子树，访问根节点中的数据。

结果：8,9,4,10,5,2,6,7,3,1

5. 层次遍历

若二叉树为空：空操作返回。

若二叉树不为空：访问根节点中的数据，访问下一层的结点数据......

6. 程序

main.c     

#include <stdio.h>

#include <stdlib.h>

#include "BTree.h"

#include "LinkQueue.h"

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

struct Node

{

BTreeNode header;

char v;

};

void printf_data(BTreeNode* node)

{

if( node != NULL )

{

printf("%c", ((struct Node*)node)->v);

}

}

void pre_order_traversal(BTreeNode* root)

{

if( root != NULL )

{

printf("%c, ", ((struct Node*)root)->v);

pre_order_traversal(root->left);

pre_order_traversal(root->right);

}

}

void middle_order_traversal(BTreeNode* root)

{

if( root != NULL )

{

middle_order_traversal(root->left);

printf("%c, ", ((struct Node*)root)->v);

middle_order_traversal(root->right);

}

}

void post_order_traversal(BTreeNode* root)

{

if( root != NULL )

{

post_order_traversal(root->left);

post_order_traversal(root->right);

printf("%c, ", ((struct Node*)root)->v);

}

}

void level_order_traversal(BTreeNode* root)

{

if( root != NULL )

{

LinkQueue* queue = LinkQueue_Create();

if( queue != NULL )

{

LinkQueue_Append(queue, root);

while( LinkQueue_Length(queue) > 0 )

{

struct Node* node = (struct Node*)LinkQueue_Retrieve(queue);

printf("%c, ", node->v);

LinkQueue_Append(queue, node->header.left);

LinkQueue_Append(queue, node->header.right);

}

}

LinkQueue_Destroy(queue);

}

}

int main(int argc, char *argv[])

{

BTree* tree = BTree_Create();

struct Node n1 = {{NULL, NULL}, 'A'};

struct Node n2 = {{NULL, NULL}, 'B'};

struct Node n3 = {{NULL, NULL}, 'C'};

struct Node n4 = {{NULL, NULL}, 'D'};

struct Node n5 = {{NULL, NULL}, 'E'};

struct Node n6 = {{NULL, NULL}, 'F'};

BTree_Insert(tree, (BTreeNode*)&n1, 0, 0, 0);

BTree_Insert(tree, (BTreeNode*)&n2, 0x00, 1, 0);

BTree_Insert(tree, (BTreeNode*)&n3, 0x01, 1, 0);

BTree_Insert(tree, (BTreeNode*)&n4, 0x00, 2, 0);

BTree_Insert(tree, (BTreeNode*)&n5, 0x02, 2, 0);

BTree_Insert(tree, (BTreeNode*)&n6, 0x02, 3, 0);

printf("Full Tree: \n");

BTree_Display(tree, printf_data, 4, '-');

printf("Pre Order Traversal:\n");

pre_order_traversal(BTree_Root(tree));

printf("\n");

printf("Middle Order Traversal:\n");

middle_order_traversal(BTree_Root(tree));

printf("\n");

printf("Post Order Traversal:\n");

post_order_traversal(BTree_Root(tree));

printf("\n");

printf("Level Order Traversal:\n");

level_order_traversal(BTree_Root(tree));

printf("\n");

BTree_Destroy(tree);

return 0;

}

BTree.h

BTree.c

LinkQueue.h

#ifndef _LINKQUEUE_H_

#define _LINKQUEUE_H_

typedef void LinkQueue;

LinkQueue* LinkQueue_Create();

void LinkQueue_Destroy(LinkQueue* queue);

void LinkQueue_Clear(LinkQueue* queue);

int LinkQueue_Append(LinkQueue* queue, void* item);

void* LinkQueue_Retrieve(LinkQueue* queue);

void* LinkQueue_Header(LinkQueue* queue);

int LinkQueue_Length(LinkQueue* queue);

#endif

LinkQueue.c

#include <malloc.h>

#include <stdio.h>

#include "LinkQueue.h"

typedef struct _tag_LinkQueueNode TLinkQueueNode;

struct _tag_LinkQueueNode

{

TLinkQueueNode* next;

void* item;

};

typedef struct _tag_LinkQueue

{

TLinkQueueNode* front;

TLinkQueueNode* rear;

int length;

} TLinkQueue;

LinkQueue* LinkQueue_Create() // O(1)

{

TLinkQueue* ret = (TLinkQueue*)malloc(sizeof(TLinkQueue));

if( ret != NULL )

{

ret->front = NULL;

ret->rear = NULL;

ret->length = 0;

}

return ret;

}

void LinkQueue_Destroy(LinkQueue* queue) // O(n)

{

LinkQueue_Clear(queue);

free(queue);

}

void LinkQueue_Clear(LinkQueue* queue) // O(n)

{

while( LinkQueue_Length(queue) > 0 )

{

LinkQueue_Retrieve(queue);

}

}

int LinkQueue_Append(LinkQueue* queue, void* item) // O(1)

{

TLinkQueue* sQueue = (TLinkQueue*)queue;

TLinkQueueNode* node = (TLinkQueueNode*)malloc(sizeof(TLinkQueueNode));

int ret = (sQueue != NULL ) && (item != NULL) && (node != NULL);

if( ret )

{

node->item = item;

if( sQueue->length > 0 )

{

sQueue->rear->next = node;

sQueue->rear = node;

node->next = NULL;

}

else

{

sQueue->front = node;

sQueue->rear = node;

node->next = NULL;

}

sQueue->length++;

}

if( !ret )

{

free(node);

}

return ret;

}

void* LinkQueue_Retrieve(LinkQueue* queue) // O(1)

{

TLinkQueue* sQueue = (TLinkQueue*)queue;

TLinkQueueNode* node = NULL;

void* ret = NULL;

if( (sQueue != NULL) && (sQueue->length > 0) )

{

node = sQueue->front;

sQueue->front = node->next;

ret = node->item;

free(node);

sQueue->length--;

if( sQueue->length == 0 )

{

sQueue->front = NULL;

sQueue->rear = NULL;

}

}

return ret;

}

void* LinkQueue_Header(LinkQueue* queue) // O(1)

{

TLinkQueue* sQueue = (TLinkQueue*)queue;

void* ret = NULL;

if( (sQueue != NULL) && (sQueue->length > 0) )

{

ret = sQueue->front->item;

}

return ret;

}

int LinkQueue_Length(LinkQueue* queue) // O(1)

{

TLinkQueue* sQueue = (TLinkQueue*)queue;

int ret = -1;

if( sQueue != NULL )

{

ret = sQueue->length;

}

return ret;

}

小结：

二叉树仅仅比单链表多了一个指针域，但其遍历算法的种类取增加了很多。

递归定义的数据结构采用递归的算法进行遍历往往能达到简单可靠的效果。