二叉树遍历（非递归）记录

记录一下 前中后序的递归和非递归算法以及关于树的一些查找的算法

比较重要的还是后序的非递归算法

后序的非递归主要利用了栈和一个判断指针，下次再来填坑

#include <stdio.h>
#include <stdlib.h>
#include <iostream>
using namespace std;

#define maxsize 100

typedef struct BiTNode {
	int Data;
	struct BiTNode* Left ;
	struct BiTNode* Right;
}BiTNode,*BiTree;

//定义一个栈   用于后序遍历查找X的所有祖先
typedef struct {
	BiTree t;
	int tag;
}stack ;




BiTree CreatBinTree();

//序输出函数
void preOrder(BiTree T);
void inOrder(BiTree T);
void postOrder1(BiTree T);
void postOrder2(BiTree T);
void levelOrder(BiTree T);

void preorder1(BiTree T);


//双分支节点个数函数
int DsonNode1(BiTree T);
int DsonNode2(BiTree T);

//交换左右子树
void swap(BiTree T);

//找出先序遍历中第k个节点的值
int preNodeK1(BiTree T, int k);
int preNodeK2(BiTree T, int k);

//
void searchX(BiTree bt, int x);




//建树   前中后序
int main() {
	BiTree T = CreatBinTree();
	
	cout << "前序遍历  递归:  ";    preOrder(T);  cout << endl;
	cout << "前序遍历  非递归:  ";    preorder1(T);  cout << endl;
	cout << "中序遍历  递归:  ";    inOrder(T);  cout << endl;
	cout << "后序的非递归才是重头戏 "  << endl;
	cout << "后序遍历 非递归:  ";    postOrder1(T);  cout << endl;
	cout << "后序遍历  递归:  ";      postOrder2(T);  cout << endl;
	cout << "层序遍历 非递归:  ";      levelOrder(T);  cout << endl;

	//输出双分支节点个数
	cout << "双分支节点个数(课本代码):  " << DsonNode1(T) << endl;//书本
	cout << "双分支节点个数(自己写的代码):  " << DsonNode2(T) << endl;//自己写的

	//交换左右子树  递归
	swap(T);
	cout << "交换左右子树后前序遍历  :    ";    preOrder(T);  cout << endl;
	cout << "交换左右子树后中序遍历  :    ";    inOrder(T);  cout << endl;

	//找出先序遍历中第K个数字   K定为6
	cout << "找出先序遍历中第6个节点的值  书本代码   " << preNodeK1(T,6) << endl;
	//cout << "找出先序遍历中第6个节点的值  自己写的代码   " << preNodeK2(T, 6) <<  endl;
	//以上函数有错误   左子树返回不了  不知道为什么  但是如果改写成递归遍历又能全部走完
	//怀疑是if语句的问题  但是不懂

	//再交换一次左右子树  返回原样
	swap(T);
	cout << endl << "再次交换左右子树" << endl;
	cout << "交换左右子树后前序遍历  :    ";    preOrder(T);  cout << endl;

	//找出值为X的所有祖先  采用非递归的后序遍历的变种
	//首先定义一个stack  用于存放节点以及tag参数
	searchX(T,69);


	


	return 0;
}

//找出值为X的所有祖先
void searchX(BiTree bt, int x) {
	//tag 0表示左子女被访问  1表示右儿子被访问
	stack s[100];
	int top = 0;
	while (bt || top > 0) {
		while (bt && bt->Data != x) {
			s[++top].t = bt;
			s[top].tag = 0;
			bt = bt->Left;
		}
		if ( bt && bt->Data == x) {
			cout << endl << "所查结点 " << x << " 的所有祖先结点的值为";
			for (int i = 1; i <= top; i++) {
				cout << s[i].t->Data << " ";
				
			}
			exit(1); // 这句必须   用于断开
			
		}
		while (top != 0 && s[top].tag == 1) {
			top--;
		}
		if (top != 0) {
			s[top].tag = 1;
			bt = s[top].t->Right;
		}
	}
	cout << "很遗憾没有在树中找到"<< x << endl;
}




//找出先序遍历中第K个数字  
int ptf = 1;//全局变量  只用于以下这个函数  
int preNodeK1(BiTree T, int k) { //课本代码
	if (!T) {
		return '#';
	}
	if (ptf == k) {
		return T->Data;
	}
	ptf++;
	int ch;
	ch = preNodeK1(T->Left, k);
	if (ch != '#') {
		return ch;
	}
	ch = preNodeK1(T->Right, k);
	return ch;
}

int ppt = 0;
int preNodeK2(BiTree T, int k) {
	
	if (T ) {
		cout << ppt << T->Data << k << " ";
		ppt++;
		if (ppt == k) {
			k = -100000;
			return T->Data;
			exit(1);
		}
		
		return preNodeK2(T->Left, k);
		return preNodeK2(T->Right, k);
	}
	
}


//交换左右子树
void swap(BiTree T) {
	if (T) {
		
		swap(T->Left);
		swap(T->Right);
		BiTree temp = T->Left;
		T->Left = T->Right;
		T->Right = temp;
	}
}



/
//双分支节点个数

int DsonNode1(BiTree T) {//课本代码
	if (!T) {
		return NULL;
	}
	else if (T->Left && T->Right) {
		return DsonNode1(T->Left) + DsonNode1(T->Right) + 1;
	}
	else {
		return DsonNode1(T->Left) + DsonNode1(T->Right) ;
	}


}

int DsonNode2(BiTree T) {//自己写的代码
	if (!T) {
		return 0;
	}
	BiTree p;
	BiTree Q[100];//队列数组
	int top = -1;
	Q[++top] = T;
	int cnt = 0;
	while (top != -1) {
		p = Q[top--];
		if (p->Left && p->Right)cnt++;
		if (p->Left) Q[++top] = p->Left;
		if (p->Right) Q[++top] = p->Right;
	}
	return cnt;

}







//
//排序

void postOrder1(BiTree T) {//非递归
	BiTree S[100]; int top = -1;//栈初始化
	BiTree p = T, r = NULL;
	while (p || top != -1) { //p存在或者栈不空
		if (p) {  //走到最左边
			S[++top] = p;
			p = p->Left;
		}
		else {
			p = S[top];
			if (p->Right && p->Right != r) { //如果右儿子存在并且没有被访问过
				p = p->Right;
				S[++top] = p;//入栈push
				p = p->Left;//在新的子树中 再走到最左
			}
			else {
				p = S[top--];//出栈 pop
				cout << p->Data << " ";//访问节点  改动r
				r = p;
				p = NULL;//重置P  下次循环直接取出栈中下个元素
			}
		}



	}


}


void levelOrder(BiTree T) {
	BiTree p;
	BiTree q[50];
	int front = 0, rear = 0;//队列
	if (T) {
		q[rear++] = T;
		while (front != rear) {//当队列不为空
			p = q[front++];
			cout << p->Data << " ";
			if (p->Left) q[rear++] = p->Left;
			if (p->Right) q[rear++] = p->Right;

		}
	}


}


void postOrder2(BiTree T) { // 后序递归
	if (T) {
		postOrder2(T->Left);
		postOrder2(T->Right);
		cout << T->Data << " ";
	}


}

void preOrder(BiTree T) {
	if (T) {
		cout << T->Data << " ";
		preOrder(T->Left);
		preOrder(T->Right);
		
	}
}

//先序非递归
void preorder1(BiTree T) {
	BiTree S[100];
	int top = -1;
	BiTree p = T;
	S[++top] = p;
	while (top != -1) {
		p = S[top--];
		cout << p->Data << " ";
		if (p->Right) S[++top] = p->Right;
		if (p->Left) S[++top] = p->Left;
	}


}

void inOrder(BiTree T) {
	if (T) {
		
		inOrder(T->Left);
		cout << T->Data << " ";
		inOrder(T->Right);

	}
}



BiTree CreatBinTree() {
	BiTree BT[9];
	int i;
	for (i = 0; i < 9; i++) {
		BT[i] = (BiTree)malloc(sizeof(struct BiTNode));
		BT[i]->Data = (65 + i);
	}
	BT[0]->Left = BT[1];
	BT[0]->Right = BT[2];
	BT[1]->Left = BT[3];
	BT[1]->Right = BT[5];
	BT[2]->Left = BT[6];
	BT[2]->Right = BT[8];
	BT[3]->Left = NULL;
	BT[3]->Right = NULL;
	BT[4]->Left = NULL;
	BT[4]->Right = NULL;
	BT[5]->Left = BT[4];
	BT[5]->Right = NULL;
	BT[6]->Left = NULL;
	BT[6]->Right = BT[7];
	BT[7]->Left = NULL;
	BT[7]->Right = NULL;
	BT[8]->Left = NULL;
	BT[8]->Right = NULL;
	return BT[0];
}

运行结果：

前序遍历 递归: 65 66 68 70 69 67 71 72 73
前序遍历 非递归: 65 66 68 70 69 67 71 72 73
中序遍历 递归: 68 66 69 70 65 71 72 67 73
后序的非递归才是重头戏
后序遍历 非递归: 68 69 70 66 72 71 73 67 65
后序遍历 递归: 68 69 70 66 72 71 73 67 65
层序遍历 非递归: 65 66 67 68 70 71 73 69 72
双分支节点个数(课本代码): 3
双分支节点个数(自己写的代码): 3
交换左右子树后前序遍历 : 65 67 73 71 72 66 70 69 68
交换左右子树后中序遍历 : 73 67 72 71 65 70 69 66 68
找出先序遍历中第6个节点的值 书本代码 66

再次交换左右子树
交换左右子树后前序遍历 : 65 66 68 70 69 67 71 72 73