数据结构 二叉树的存储表示以及二叉树的遍历

二叉树的顺序存储

#define maxSize 127
typedef char DataType;
typedef struct {
	DataType data[maxSize];
	int n;                 //当前结点个数
}SqBTree;

二叉树的顺序存储对于一般的二叉树不适用，一般的二叉树采用链式存储结构。

二叉树的链式存储结构

二叉树的二叉链表存储表示

typedef char DataType;   //结点数据类型
typedef struct Node{     //二叉树的二叉链表结构类型定义
	DataType data;     //结点数据
	struct Node* lchild, * rchild;    //结点的左右子树指针
}BiTNode,*BiTree;   //二叉树的二叉链表存储表示

二叉树的三叉链表存储表示 

typedef char DataType;   //结点数据类型
typedef struct Node{     //二叉树的二叉链表结构类型定义
	DataType data;     //结点数据
	struct Node* lchild, * rchild;    //结点的左右子树指针
    struct Node* parent;     //双亲指针
}BiTNode,*BiTree;   //二叉树的二叉链表存储表示

二叉树遍历的递归算法

先（根）序的遍历算法：

若二叉树为空树，则空操作；否则， （1）访问根结点； （2）先序遍历左子树； （3）先序遍历右子树。

    二叉树的先序遍历算法

//二叉树的先序遍历算法
void PreOrder(BiTree root) {   
	if (root != NULL) {     //空树是递归结束的条件
		printf("%c ", root->data);   //访问根节点
		PreOrder(root->lchild);      //先序遍历根的左子树
		PreOrder(root->rchild);      //先序遍历根的右子树
	}
}

中（根）序的遍历算法：

若二叉树为空树，则空操作；否则， （1）中序遍历左子树； （2）访问根结点； （3）中序遍历右子树。

    二叉树的中序遍历算法 

//二叉树的中序遍历算法
void InOrder(BiTree root) {   
	if (root != NULL) {
		InOrder(root->lchild);    //中序遍历根的左子树
		printf("%c ", root->data);  //访问根节点
		InOrder(root->rchild);    //中序遍历根的右子树
	}
}

后（根）序的遍历算法：

若二叉树为空树，则空操作；否则， （1）后序遍历左子树； （2）后序遍历右子树； （3）访问根结点。   

二叉树的后序遍历算法 

//二叉树的后序遍历算法
void PostOrder(BiTree root) {   
	if (root != NULL) {
		PostOrder(root->lchild);   //后序遍历根的左子树
		PostOrder(root->rchild);   //后序遍历根的右子树
		printf("%c ", root->data); //访问根节点
	}
}

二叉树的非递归遍历算法 

    中序遍历的非递归算法

//中序遍历的非递归算法
#define stackSize 20         //预定栈的大小，相当于树高
void InOrder1(BiTree BT) {
	BiTNode* S[stackSize]; int top = -1;  
	BiTNode* p = BT;                     //p是遍历指针
	do {
		while(p!=NULL)                  //遍历左子女结点
		{
			S[++top] = p; p = p->lchild;
		}                          //一直到左子女节结为空时停止
		if (top > -1) {
			p = S[top--];
			printf("%c ", p->data);    //退栈，从最底层向上退栈，访问
			p = p->rchild;           //遍历指针到右子女结点
		}
	} while (p != NULL || top > -1);
}

    后序遍历的非递归算法 

//后序遍历的非递归算法
#define stackSize 20         //预定栈的大小，相当于树高
void PostOrder1(BiTree BT) {
	BiTNode* S[stackSize]; int top = -1;
	BiTNode* p = BT, * pre = NULL;        //p是遍历指针，pre是前趋指针
	do {
		while (p != NULL) {                  //左子树进栈
			S[++top] = p; p = p->lchild;     //向最左下结点走去
		}
		if (top > -1) {
			p = S[top];
			if (p->rchild != NULL && p->rchild != pre)
				p = p->rchild;
			else {
				printf("%c ", p->data);
				pre = p; p = NULL;
				top--;
			}
		}
	} while (p != NULL || top != -1); 
}

    二叉树的层次遍历算法 

//二叉树的层次遍历算法
#define queueSize 20
void LevelOrder(BiTree BT) {
	BiTNode* Q[queueSize]; int rear, front;
	rear = 0; front = 0;               //队列初始化
	BiTNode* p = BT; Q[rear++] = p;    //p为遍历指针
	while (rear != front) {
		p = Q[front]; front = (front + 1) % queueSize;
		printf("%c ", p->data);         //访问
		if (p->lchild != NULL) {
			Q[rear] = p->lchild; rear = (rear + 1) % queueSize;   //有左子女，进队
		}
		if (p->rchild != NULL) {
			Q[rear] = p->rchild; rear = (rear + 1) % queueSize;   //有右子女，进队
		}
	}

}

 

 

例题

 

#include <stdio.h>
#include <malloc.h>
#include <cstdlib>
#include <string>
using namespace std;

#define maxSize 127
typedef char DataType;   //结点数据类型
typedef struct Node{     //二叉树的二叉链表结构类型定义
	DataType data;     //结点数据
	struct Node* lchild, * rchild;    //结点的左右子树指针
}BiTNode,*BiTree;   //二叉树的二叉链表存储表示

int CreateBiTree(BiTree& T) {
	char ch;
	ch = getchar();
	if (ch == '.') T = NULL;
	else {
		if (!(T = new Node))   //给T分配新的空间
			exit(0);
		T->data = ch;   //生成根节点
		CreateBiTree(T->lchild);  //构造左子树
		CreateBiTree(T->rchild);  //构造右子树
	}
	return 1;
}


//二叉树的先序遍历算法
void PreOrder(BiTree root) {   
	if (root != NULL) {     //空树是递归结束的条件
		printf("%c ", root->data);   //访问根节点
		PreOrder(root->lchild);      //先序遍历根的左子树
		PreOrder(root->rchild);      //先序遍历根的右子树
	}
}


//二叉树的中序遍历算法
void InOrder(BiTree root) {   
	if (root != NULL) {
		InOrder(root->lchild);    //中序遍历根的左子树
		printf("%c ", root->data);  //访问根节点
		InOrder(root->rchild);    //中序遍历根的右子树
	}
}


//二叉树的后序遍历算法
void PostOrder(BiTree root) {   
	if (root != NULL) {
		PostOrder(root->lchild);   //后序遍历根的左子树
		PostOrder(root->rchild);   //后序遍历根的右子树
		printf("%c ", root->data); //访问根节点
	}
}


//中序遍历的非递归算法
#define stackSize 20         //预定栈的大小，相当于树高
void InOrder1(BiTree BT) {
	BiTNode* S[stackSize]; int top = -1;  
	BiTNode* p = BT;                     //p是遍历指针
	do {
		while(p!=NULL)                  //遍历左子女结点
		{
			S[++top] = p; p = p->lchild;
		}                          //一直到左子女节结为空时停止
		if (top > -1) {
			p = S[top--];
			printf("%c ", p->data);    //退栈，从最底层向上退栈，访问
			p = p->rchild;           //遍历指针到右子女结点
		}
	} while (p != NULL || top > -1);
}


//后序遍历的非递归算法
#define stackSize 20         //预定栈的大小，相当于树高
void PostOrder1(BiTree BT) {
	BiTNode* S[stackSize]; int top = -1;
	BiTNode* p = BT, * pre = NULL;        //p是遍历指针，pre是前趋指针
	do {
		while (p != NULL) {                  //左子树进栈
			S[++top] = p; p = p->lchild;     //向最左下结点走去
		}
		if (top > -1) {
			p = S[top];
			if (p->rchild != NULL && p->rchild != pre)
				p = p->rchild;
			else {
				printf("%c ", p->data);
				pre = p; p = NULL;
				top--;
			}
		}
	} while (p != NULL || top != -1); 
}

//二叉树的层次遍历算法
#define queueSize 20
void LevelOrder(BiTree BT) {
	BiTNode* Q[queueSize]; int rear, front;
	rear = 0; front = 0;               //队列初始化
	BiTNode* p = BT; Q[rear++] = p;    //p为遍历指针
	while (rear != front) {
		p = Q[front]; front = (front + 1) % queueSize;
		printf("%c ", p->data);         //访问
		if (p->lchild != NULL) {
			Q[rear] = p->lchild; rear = (rear + 1) % queueSize;   //有左子女，进队
		}
		if (p->rchild != NULL) {
			Q[rear] = p->rchild; rear = (rear + 1) % queueSize;   //有右子女，进队
		}
	}

}

int main() {
	BiTree T;
	CreateBiTree(T);
	PreOrder(T);
	printf("\n");
	InOrder(T);
	printf("\n");
	PostOrder(T);
	printf("\n");
	InOrder1(T);
	printf("\n");
	PostOrder1(T);
	printf("\n");
	LevelOrder(T);
}

输入AB.CD...E.FGH..K

 

 

输出结果