1,前序遍历建立二叉树
2,前序遍历
3,中序遍历
4,后序遍历
5,二叉树的销毁
6,从上至下分层遍历二叉树
7,从上至下分层遍历二叉树 且每一层打印一行
求二叉树的宽度,思路一直。
8,按照之字形上至下分层 打印二叉树
9,求二叉树深度
10,判断是否是平衡二叉树
11,判断是否是平衡二叉树 不允许重复遍历
12,求二叉树第K层的节点数
13,求二叉树第K层叶子节点数
14,比较两个二叉树结构是否相同,不涉及存储的数据
15,求二叉树镜像
16,判断二叉树是否对称
17,查找二叉树中两个节点的最低祖先节点(或最近公共父节点等)
18,求父节点与子节点之间的距离
19,二叉树中任意两个节点之间的距离
20,二叉搜索树的查找
21,二叉搜索树的插入
22,二叉排序树的节点删除
#include <iostream>
#include <vector>
#include <stdlib.h>
#include <queue>
#include <algorithm>
#include <stack>
using namespace std;
typedef struct BTree
{
int value;
struct BTree *pLeft;
struct BTree *pRight;
}BTree;
/*
前序遍历建立二叉树,0代表NULL
{1,2,4,8,0,0,9,0,0,5,0,0,3,6,0,0,9,0,0}
*/
BTree *CreateBTree(BTree * node,int *num,int &index)
{
if (num[index] == 0 )
{
return NULL;
}
else
{
node = new BTree;
node->value = num[index];
node->pLeft = CreateBTree(node->pLeft,num,++index);
node->pRight = CreateBTree(node->pRight,num,++index );
}
return node;
}
void Visit(BTree *node)
{
cout<<node->value<<ends;
}
/*
前序遍历
定义: 先访问根节点,在访问左子树,最后访问右子树;
*/
void PreorderTraverse( BTree *pRoot)
{
if( pRoot == NULL )
return ;
Visit( pRoot);
PreorderTraverse( pRoot->pLeft );
PreorderTraverse( pRoot->pRight);
}
/*
根据前序遍历访问的顺序,优先访问根结点,然后再分别访问左孩子和右孩子。即对于任一结点,其可看做是根结点,
因此可以直接访问,访问完之后,若其左孩子不为空,按相同规则访问它的左子树;当访问其左子树时,再访问它的右子树。因此其处理过程如下:
对于任一结点P:
1)访问结点P,并将结点P入栈;
2)判断结点P的左孩子是否为空,若为空,则取栈顶结点并进行出栈操作,并将栈顶结点的右孩子置为当前的结点P,循环至1);
若不为空,则将P的左孩子置为当前的结点P;
3)直到P为NULL并且栈为空,则遍历结束。
*/
void preOrder2(BTree *root) //非递归前序遍历
{
stack<BTree*> s;
BTree *p=root;
while(p!=NULL||!s.empty())
{
while(p!=NULL)
{
cout<<p->value<<" ";
s.push(p);
p=p->pLeft;
}
if(!s.empty())
{
p=s.top();
s.pop();
p=p->pRight;
}
}
}
/*
中序遍历
定义:首先访问左子树,然后访问根节点,最后访问右子树
*/
void InorderTraverse( BTree *pRoot)
{
if( pRoot == NULL )
return ;
InorderTraverse( pRoot->pLeft );
Visit( pRoot);
InorderTraverse( pRoot->pRight);
}
/*
非递归实现
根据中序遍历的顺序,对于任一结点,优先访问其左孩子,而左孩子结点又可以看做一根结点,然后继续访问其左孩子结点,
直到遇到左孩子结点为空的结点才进行访问,然后按相同的规则访问其右子树。因此其处理过程如下:
对于任一结点P,
1)若其左孩子不为空,则将P入栈并将P的左孩子置为当前的P,然后对当前结点P再进行相同的处理;
2)若其左孩子为空,则取栈顶元素并进行出栈操作,访问该栈顶结点,然后将当前的P置为栈顶结点的右孩子;
3)直到P为NULL并且栈为空则遍历结束
*/
void inOrder2(BTree *root) //非递归中序遍历
{
stack<BTree*> s;
BTree *p=root;
while(p!=NULL||!s.empty())
{
while(p!=NULL)
{
s.push(p);
p=p->pLeft;
}
if(!s.empty())
{
p=s.top();
cout<<p->value<<" ";
s.pop();
p=p->pRight;
}
}
}
/*
后序遍历
定义: 给定根节点,首先遍历左子树,然后遍历右子树,最后遍历根节点
*/
void PostorderTraverse( BTree *pRoot)
{
if( pRoot == NULL )
return ;
PostorderTraverse( pRoot->pLeft );
PostorderTraverse( pRoot->pRight);
Visit( pRoot);
}
/*
要保证根结点在左孩子和右孩子访问之后才能访问,因此对于任一结点P,先将其入栈。如果P不
存在左孩子和右孩子,则可以直接访问它;或者P存在左孩子或者右孩子,但是其左孩子和右孩子
都已被访问过了,则同样可以直接访问该结点。若非上述两种情况,则将P的右孩子和左孩子依次
入栈,这样就保证了每次取栈顶元素的时候,左孩子在右孩子前面被访问,左孩子和右孩子都在
根结点前面被访问。
*/
void postOrder3(BTree *root) //非递归后序遍历
{
stack<BTree*> s;
BTree *cur; //当前结点
BTree *pre=NULL; //前一次访问的结点
s.push(root);
while(!s.empty())
{
cur=s.top();
if((cur->pLeft==NULL&&cur->pRight==NULL)||
(pre!=NULL&&(pre==cur->pLeft||pre==cur->pRight)))
{
cout<<cur->value<<" "; //如果当前结点没有孩子结点或者孩子节点都已被访问过
s.pop();
pre=cur;
}
else
{
if(cur->pRight!=NULL)
s.push(cur->pRight);
if(cur->p