【数据结构——树】二叉树的节点定义与遍历算法

（1）二叉树的节点定义

//普通二叉树的链式存储结点定义
typedef struct BTNode{
	char data;
	struct BTNode *lchild;	//左孩子
	struct BTNode *rchild;	//右孩子
}BTNode;

//线索二叉树的结点定义
typedef struct TBTNode{
	char data;
	int ltag, rtag;
	struct TBTNode *lchild;	//左孩子
	struct TBTNode *rchild;	//右孩子
}TBTNode;

（2）二叉树的遍历算法

//先序遍历（递归）
void preorder(BTNode *p){
	if(p != nullptr){				//一定要记得判空
		printf("%c", p->data);
		preorder(p->lchild);
		preorder(p->rchild);
	}
}

//中序遍历（递归）
void inorder(BTNode *p){
	if(p != nullptr){				//一定要记得判空
		inorder(p->lchild);
		printf("%c", p->data);
		inorder(p->rchild);
	}
}

//后序遍历（递归）
void postorder(BTNode *p){
	if(p != nullptr){				//一定要记得判空
		postorder(p->lchild);
		postorder(p->rchild);
		printf("%c", p->data);
	}
}

//层序遍历
void level(BTNode *p){
	BTNode *que[maxSize];
	BTNode *q = nullptr;
	int front=0, rear=0;					//定义一个循环队列

	if(p != nullptr){
		rear = (rear+1) % maxSize;
		que[rear] = p;						//根节点入队
		while(front != rear){				//只要队不空，则进行循环
			front = (front+1) % maxSize;
			q = que[front];					//队头元素出队
			printf("%d", q->data);			//访问队头元素
			if(q->lchild){					//左子树存在，则左子树根节点入队
				rear = (rear+1) % maxSize;
				que[rear] = q->lchild;
			}
			if(q->rchild){					//右子树存在，则右子树根节点入队
				rear = (rear+1) % maxSize;
				que[rear] = q->rchild;
			}
		}
	}
}

//先序遍历（非递归）
void preorderNonrecursion(BTNode *bt){
	if(bt != nullptr){
		BTNode *Stack[maxSize];
		int top = -1;						//定义人工栈
		Stack[++top] = bt;					//根节点入栈
		BTNode *p;
		while(top != -1){					//判断不空
			p = Stack[top--];				//出栈，并完成一次访问
			printf("%c", p->data);			//Visit(p);
			if(p->rchild != nullptr){		//先序遍历一定是先右孩子，再左孩子
				Stack[++top] = p->rchild;
			}
			if(p->lchild != nullptr){
				Stack[++top] = p->lchild;
			}
		}
	}
}

//中序遍历（非递归）
void inorderNonrecursion(BTNode *bt){
	if(bt != nullptr){
		BTNode *Stack[maxSize];
		int top = -1;						//定义人工栈
		BTNode *p = NULL;
		p = bt;						
		while(top!=-1 || p!=nullptr){
			while(p != nullptr){
				Stack[++top] = p;
				p = p->lchild;
			}
			if(top != -1){
				p = Stack[top--];
				printf("%c\n",p->data);		//Visit(p);
				p = p->rchild;
			}
		}
	}
}

//后序遍历（非递归）
void postorderNonrecursion(BTNode *bt){
	if(bt != nullptr){
		BTNode *Stack1[maxSize];int top1 = -1;
		BTNode *Stack2[maxSize];int top2 = -1;		//定义两个栈
		BTNode *p = NULL;
		Stack1[++top1] = bt;
		while(top != -1){
			p = Stack1[top1--];
			Stack2[++top2] = p;						//注意这里与先序的区别，放入栈2中即可
			if(p->lchild){		
				Stack1[++top1] = p->lchild;
			}
			if(p->rchild){
				Stack1[++top1] = p->rchild;
			}
		}
		//这时候循环结束，则会将逆后序遍历的结果都存放到了栈2中
		//所以对栈2进行输出即可得到后序遍历的结果
		while(top2 != -1){
			p = Stack[top2--];
			printf("%c\n",p->data);					//Visit(p);
		}
	}
}