【算法题day2】二叉树

typedef struct BiTNode
{
	char data;
	struct BTNode *lchild;
	struct BTNode *rchild;
}BiTNode,BiTree*;

1. 二叉树先序遍历(递归以及非递归)

void preOrder(BTNode *p)
{// 根--左--右
	if(p != NULL)
	{
		Visit(p); //假设访问函数Visit()已经定义过，包含对结点p的各种访问操作
		preOrder(p->lchild); //先序遍历左子树
		preOrder(p->rchild); //先序遍历右子树
	}
}
void preOrderNonRecursion(BTNode *bt)
{
	if(bt != NULL)
	{
		BTNode * Stack[maxSize]; //定义一个栈
		int top = -1; //初始化栈
		BTNode *p;
		Stack[++top] = bt;
		while(top != -1)
		{
			p = Stack[top--]; //出栈并输出栈顶结点
			Visit(p);
			//先右后左
			if(p->rchild != NULL) //栈顶结点的右孩子存在，则右孩子入栈
				Stack[++top] = p->rchild;
			if(p->lchild != NULL) //栈顶结点的左孩子存在，则左孩子入栈
				Stack[++top] = p->lchild;
		}
	}
}

2. 二叉树中序遍历(递归以及非递归)

void inOrder(BTNode *p)
{// 左--根--右
	if(p != NULL)
	{
		inOrder(p->lchild);
		Visit(p);
		inOrder(p->rchild);
	}
}
void inOrderNonRecursion(BTNode *bt)
{ //循环执行如下操作：如果栈顶结点左孩子存在，则左孩子入栈；
  //如果栈顶结点左孩子不存在，则出栈并输出栈顶结点，
  //然后检查其右孩子是否存在，如果存在，则右孩子入栈
 	if(bt != NULL)
 	{
 		BTNode *Stack[maxSize];
 		int top = -1;
 		BTNode *p;
 		p = bt;
 		while(top != NULL || p!= NULL)
 		{
 			while(p != NULL) //左孩子存在，则左孩子入栈
 			{
 				Stack[++top] = p;
 				p = p->lchild;
 			}
 			if(top != -1) //在栈不空的情况下出栈并输出栈结点
 			{
 				p = Stack[top--];
 				Visit(p);
 				p = p->rchild;
 			}
 		}
 	}	
}

3. 二叉树后序遍历(递归以及非递归)

void postOrder(BTNode *p)
{ //左--右--根
	if(p != NULL)
	{
		postOrder(p->lchild);
		postOrder(p->rchild);
		Visit(p);
	}
}
void postOrderNonRecursion(BTNode *bt)
{
	if(bt != NULL)
	{
		//定义两个栈
		BTNode *Stack1[maxSize];
		int top1 = -1;
		BTNode *Stack2[maxSize];
		int top2 = -1;
		BTNode *p = NULL;
		Stack1[++top1] = bt;
		while(top1 != -1)
		{
			p = Stack1[top1--];
			Stack2[++top2] = p; //注意这里与先序遍历区别，输出改为入Stack2
			//先左后右
			if(p->lchild != NULL)
				Stack1[++top1] = p->lchild;
			if(p->rchild != NULL)
				Stack1[++top1] = p->rchild;
		}
		while(top2 != -1)
		{
			//出栈序列即为后序遍历序列
			p = Stack2[top2--];
			Visit(p);
		}
	}
}

4. 二叉树层次遍历

void level(BTNode *p)
{
	int front,rear;
	BTNode *que[maxSize]; //定义一个循环队列，用来记录将要访问的层次上的结点
	front = rear = 0;
	BTNode *q;
	if(p != NULL)
	{
		rear = (rear+1)%maxSize;
		que[rear] = p; //根节点入队
		while(front != rear) //当循环队列不空的时候进行循环
		{
			front = (front+1)%maxSize;
			q = que[front]; //队头结点出队
			Visit(q); //访问队头结点
			if(q->lchild != NULL) //如果左子树不空，则左子树的根结点入队
			{
				rear = (rear+1)%maxSize;
				que[rear] = q->lchild;
			}
			if(q->rchild != NULL) //如果右子树不空，则右子树的根结点入队
			{
				rear = (rear+1)%maxSize;
				que[rear] = q->rchild;
			}
		}
	}
}