（二）数据结构中的树（上）：二叉树存储结构及遍历

二叉树的定义：一个度为2的树，由根结点、左子树和右子树组成的。（子树有左右区分）

二叉树形态：空、只有一个结点、一个结点和左子树、一个结点和右子树、一个结点和左右子树、斜二叉树、完美二叉树（满二叉树）、完全二叉树（从上往下，从左往右按顺序编号，可缺省最后最右右边部分）

二叉树的性质：

一个二叉树第 $i$ 层的最大结点数为： $2^{^{i-1}}$ , $i\geqslant 1$

深度为 $k$ 的二叉树有最大总结点数为： $1+2^{^{1}}+2^{^{2}}+2^{^{3}}+\cdots +2^{k-1}=2^{^{k}}-1$ ， $k\geq 1$

叶结点个数为 $n{_{0}}$ ，只有一个儿子的结点数为 $n{_{1}}$ ，有两个儿子的结点数为 $n{_{2}}$ ，那么这棵树总的结点数为 $n{_{0}}$ + $n{_{1}}$ + $n{_{2}}$ ，

$n{_{0}}$ = $n{_{2}}$ +1

二叉树常用遍历方法有：

void PreOrderTraversal（BinTree BT）：先序遍历，根，左子树，右子树

void InOrderTraversal（BinTree BT）: 中序遍历，左子树，根，右子树

void PostOrderTraversal（BinTree BT）：后序遍历，左子树，右子树，根

void LevelOrderTraversal（BinTree BT）：层次遍历，从上到下、从左到右

递归方法实现二叉树的遍历：

#include <stdio.h>
//二叉树的定义
typedef struct TreeNode *BinTree;
typedef BinTree Position;
typedef int ElementType;
struct TreeNode
{
	ElementType Data;
	BinTree Left;
	BinTree Right;
};

//前序遍历
void PreOrderTraversal(BinTree BT)
{
	if (BT){
		printf("%d", BT->Data);
		PreOrderTraversal(BT->Left);
		PreOrderTraversal(BT->Right);
	}
}

//中序遍历
void InOrderTraversal(BinTree BT)
{
	if (BT){
		InOrderTraversal(BT->Left);
		printf("%d", BT->Data);
		InOrderTraversal(BT->Right);
	}
}

//后续遍历
void PostOrderTraversal(BinTree BT)
{
	if (BT){
		PostOrderTraversal(BT->Left);
		PostOrderTraversal(BT->Right);
		printf("%d", BT->Data);
	}
}

非递归方法实现二叉树的中序遍历：（使用堆栈）

#include "stdio.h"  
#include "stdlib.h"   

typedef struct tree
{
	char data;
	struct tree *lchild;
	struct tree *rchild;
}*Ptree;

typedef Ptree ElementType;


typedef struct SNode *Stack;
struct SNode{
	ElementType Data;
	struct SNode *Next;
};

Ptree createTree()   //树的建立
{
	char ch;
	Ptree t;
	ch = getchar();  //输入二叉树数据
	if (ch == ' ')  //判断二叉树是否为空
		t = NULL;
	else
	{
		t = (Ptree)malloc(sizeof(Ptree));  //二叉树的生成
		t->data = ch;
		t->lchild = createTree();
		t->rchild = createTree();
	}
	return t;
}

//堆栈的建立  
Stack CreateStack(){
	Stack S;
	S = (Stack)malloc(sizeof(struct SNode));
	S->Next = NULL;
	return S;
}
//判断是否空  
int IsEmpty(Stack S){
	return(S->Next == NULL);
}

//Push操作  
void Push(ElementType item, Stack S){
	struct SNode *TmpCell;
	TmpCell = (struct SNode *)malloc(sizeof(struct SNode));
	TmpCell->Data = item;
	TmpCell->Next = S->Next;
	S->Next = TmpCell;
}

//Pop操作
ElementType Pop(Stack S){
	struct SNode *FirstCell;
	ElementType TopElem;
	if (IsEmpty(S)){
		printf("堆栈空\n");
		return NULL;
	}
	else{
		FirstCell = S->Next;
		S->Next = FirstCell->Next;
		TopElem = FirstCell->Data;
		free(FirstCell);
		return TopElem;
	}
}
//利用栈中序遍历
void InOderTraversal(Ptree BT){
	Ptree T = BT;
	Stack S = CreateStack();
	while (T || !IsEmpty(S)){
		while (T){
			Push(T, S);
			T = T->lchild;
		}
		T = Pop(S);
		printf("%c", T->data);
		T = T->rchild;
	}
};

非递归方法实现二叉树的层次遍历：（使用队列）

void LevelorderTraversal ( BinTree BT )
{ 
    Queue Q; 
    BinTree T;
 
    if ( !BT ) return; /* 若是空树则直接返回 */
     
    Q = CreatQueue(); /* 创建空队列Q */
    AddQ( Q, BT );
    while ( !IsEmpty(Q) ) {
        T = DeleteQ( Q );
        printf("%d ", T->Data); /* 访问取出队列的结点 */
        if ( T->Left )   AddQ( Q, T->Left );
        if ( T->Right )  AddQ( Q, T->Right );
    }
}

（二）数据结构中的树（上）：二叉树存储结构及遍历

猜你喜欢