从零开始学数据结构系列之第三章《二叉树链式结构及实现5》

---

遍历代码详细

/*NLR：前序遍历(Preorder Traversal 亦称先序遍历)——访问根结点的操作发生在遍历其左右子树之前。*/
void preOrder(TreeNode* T) 
{
	if(T == NULL)
		return;
	else
	{
		printf("%c->",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}

/*LNR：中序遍历(Inorder Traversal)——访问根结点的操作发生在遍历其左右子树之中（间）。 */
void inOrder(TreeNode* T) 
{
   	if(T == NULL)
		return;
	else
	{
		inOrder(T->lchild);
		printf("%c->",T->data);
		inOrder(T->rchild);
	}
}
/*LRN：后序遍历(Postorder Traversal)——访问根结点的操作发生在遍历其左右子树之后。*/
void postOrder(TreeNode* T) 
{
   	if(T == NULL)
		return;
	else
	{
		postOrder(T->lchild);
		postOrder(T->rchild);
		printf("%c->",T->data);
	}
}

层序遍历

从二叉树的根结点开始，从上至下逐层遍历，在同一层中，则按从左到右的顺序对结点逐个访问

遍历二叉树，简单点来说呢，就是将其数据一层一层的进行遍历打印。也就是对其进行层序遍历。

我们看到这个图，是不是感觉非常符合先进先出，后进后出的形式

​ 所以我们的层序变量则可以用我们前面学的，“队列”

但是这个队列，与我们之前学的队列有什么不同呢

首先就是初始化，我们之前的初始化是

int data;

而这里面就是我们所存储的数据，这里我们所要存储的是“树”，所以我们要使用相同类型的数据来进行指向

typedef struct Node 
{
	TreeNode *data;
	struct Node *next;
}Node;

这里要提一下的就是我们的出队顺序

/*
我们先将根节点放入，之后在判断后面是否有数据，如果不先将根节点放入，则直接跳过循环
*/

void levelTraverse(Node* Q, TreeNode* T) 
{
    enQueue(T, Q);
    while (!isEmpty(Q)) 
	{
        Node* node = deQueue(Q);
        printf("%c->", node->data->data);
        if (node->data->lchild) 
		{
            enQueue(node->data->lchild, Q);
        }
        if (node->data->rchild) 
		{
            enQueue(node->data->rchild, Q);
        }
    }
}

层次遍历总代码

/*可以输入
ABD##E##CF##G##
来进行验证
*/

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define size 20

typedef struct TreeNode 
{
	char data;
	struct TreeNode *lchild;
	struct TreeNode *rchild;
}TreeNode;

typedef struct Node 
{
	TreeNode *data;
	struct Node *next;
}Node;


void createTree(TreeNode** T,char* temp,int* index)
{
	char ch;
	
	ch = temp[*index];
	(*index)++;

	if( ch == '#') *T = NULL;
	else
	{
		 *T =(TreeNode*)malloc(sizeof(TreeNode));
		 (*T)->data = ch;
		createTree(&(*T)->lchild,temp,index);
		createTree(&(*T)->rchild,temp,index);		
	}
}

void preOrder(TreeNode* T) 
{
	if(T==NULL)
		return;
	else
	{
		printf("%c->",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}


Node* initQueue() 
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = NULL;
	node->next =NULL;
	return node;
}

void enQueue(TreeNode* data, Node* list) 
{
	Node* node = (Node*)malloc(sizeof(Node));
	node->data = data;
	
	while(list->next)list=list->next;
	node->next = list->next;
	list->next=node;
}


int isEmpty(Node* Q) 
{
	if(Q->next == NULL)
		return 1;
	else
		return 0;
}

Node* deQueue(Node* Q)
{
 if (isEmpty(Q)) 
     return NULL;
 else 
 {
	Node *node = Q->next;
	Q ->next = node->next;
    return node;
 }
}

void levelTraverse(Node* Q, TreeNode* T) 
{
    enQueue(T, Q);
    while (!isEmpty(Q)) 
	{
        Node* node = deQueue(Q);
        printf("%c->", node->data->data);
        if (node->data->lchild) 
		{
            enQueue(node->data->lchild, Q);
        }
        if (node->data->rchild) 
		{
            enQueue(node->data->rchild, Q);
        }
    }
}



int main(int argc, char* argv[]) 
{
	TreeNode *T;
	int i=0;
	char *temp=NULL;
	Node* Q = initQueue();

	temp=(char*)malloc(sizeof(char) * (size+1));
	gets(temp);
	createTree(&T,temp,&i);
	preOrder(T);       
    printf("\n");
    levelTraverse(Q, T);
    printf("\n");

    return 0;
}

满二叉树创建+遍历总代码

#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#define size 20

typedef struct TreeNode 
{
    char data;
    struct TreeNode* lchild;
    struct TreeNode* rchild;
}TreeNode;

void createTree(TreeNode** T,char* temp,int* index)
{
	char ch;
	ch = temp[*index];
	(*index)++;

	if(ch == '#')
		*T=NULL;
	else
	{
		*T = (TreeNode*)malloc(sizeof(TreeNode));
		(*T)->data = ch;
		createTree(&(*T)->lchild,temp,index);
		createTree(&(*T)->rchild,temp,index);
	}

}

void preOrder(TreeNode* T) 
{
	if(T == NULL)
		return;
	else
	{
		printf("%c->",T->data);
		preOrder(T->lchild);
		preOrder(T->rchild);
	}
}


void inOrder(TreeNode* T) 
{
   	if(T == NULL)
		return;
	else
	{
		inOrder(T->lchild);
		printf("%c->",T->data);
		inOrder(T->rchild);
	}
}

void postOrder(TreeNode* T) 
{
   	if(T == NULL)
		return;
	else
	{
		postOrder(T->lchild);
		postOrder(T->rchild);
		printf("%c->",T->data);
	}
}


int main(int argc, char* argv[]) 
{
	TreeNode *T;
	char *temp=NULL;
	int index = 0;
	temp = (char*)malloc( sizeof(char)* size);
	gets(temp);

	createTree(&T,temp,&index);
	preOrder(T);
	printf("\r\n");
	inOrder(T);
	printf("\r\n");
	postOrder(T);
    return 0;
}

往期回顾

1.【第一章】《线性表与顺序表》
2.【第一章】《单链表》
3.【第一章】《单链表的介绍》
4.【第一章】《单链表的基本操作》
5.【第一章】《单链表循环》
6.【第一章】《双链表》
7.【第一章】《双链表循环》
8.【第二章】《栈》
9.【第二章】《队》
10.【第二章】《字符串暴力匹配》
11.【第二章】《字符串kmp匹配》
12.【第三章】《树的基础概念》
13.【第三章】《二叉树的存储结构》
14.【第三章】《二叉树链式结构及实现1》
15.【第三章】《二叉树链式结构及实现2》
16.【第三章】《二叉树链式结构及实现3》
17.【第三章】《二叉树链式结构及实现4》