深入遍歷二叉樹的各種操作詳解（非遞歸遍歷）
更新時間：2013年05月24日 17:50:16 作者：
本篇文章是對遍歷二叉樹的各種操作進(jìn)行了詳細(xì)的分析介紹，需要的朋友參考下
先使用先序的方法建立一棵二叉樹，然后分別使用遞歸與非遞歸的方法實現(xiàn)前序、中序、后序遍歷二叉樹，并使用了兩種方法來進(jìn)行層次遍歷二叉樹，一種方法就是使用STL中的queue，另外一種方法就是定義了一個數(shù)組隊列，分別使用了front和rear兩個數(shù)組的下標(biāo)來表示入隊與出隊，還有兩個操作就是求二叉樹的深度、結(jié)點數(shù)。。。
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
//二叉樹結(jié)點的描述
typedef struct BiTNode
{
char data;
struct BiTNode *lchild, *rchild; //左右孩子
}BiTNode,*BiTree;
//按先序遍歷創(chuàng)建二叉樹
//BiTree *CreateBiTree() //返回結(jié)點指針類型
//void CreateBiTree(BiTree &root) //引用類型的參數(shù)
void CreateBiTree(BiTNode **root) //二級指針作為函數(shù)參數(shù)
{
char ch; //要插入的數(shù)據(jù)
scanf("\n%c", &ch);
//cin>>ch;
if(ch=='#')
*root = NULL;
else
{
*root = (BiTNode *)malloc(sizeof(BiTNode));
(*root)->data = ch;
printf("請輸入%c的左孩子：",ch);
CreateBiTree(&((*root)->lchild));
printf("請輸入%c的右孩子：",ch);
CreateBiTree(&((*root)->rchild));
}
}
//前序遍歷的算法程序
void PreOrder(BiTNode *root)
{
if(root==NULL)
return ;
printf("%c ", root->data); //輸出數(shù)據(jù)
PreOrder(root->lchild); //遞歸調(diào)用，前序遍歷左子樹
PreOrder(root->rchild); //遞歸調(diào)用，前序遍歷右子樹
}
//中序遍歷的算法程序
void InOrder(BiTNode *root)
{
if(root==NULL)
return ;
InOrder(root->lchild); //遞歸調(diào)用，前序遍歷左子樹
printf("%c ", root->data); //輸出數(shù)據(jù)
InOrder(root->rchild); //遞歸調(diào)用，前序遍歷右子樹
}
//后序遍歷的算法程序
void PostOrder(BiTNode *root)
{
if(root==NULL)
return ;
PostOrder(root->lchild); //遞歸調(diào)用，前序遍歷左子樹
PostOrder(root->rchild); //遞歸調(diào)用，前序遍歷右子樹
printf("%c ", root->data); //輸出數(shù)據(jù)
}
/*
二叉樹的非遞歸前序遍歷，前序遍歷思想：先讓根進(jìn)棧，只要棧不為空，就可以做彈出操作，
每次彈出一個結(jié)點，記得把它的左右結(jié)點都進(jìn)棧，記得右子樹先進(jìn)棧，這樣可以保證右子樹在棧中總處于左子樹的下面。
*/
void PreOrder_Nonrecursive2(BiTree T) //先序遍歷的非遞歸
{
if(!T)
return ;
stack<BiTree> s;
s.push(T);
while(!s.empty())
{
BiTree temp = s.top();
cout<<temp->data<<" ";
s.pop();
if(temp->rchild)
s.push(temp->rchild);
if(temp->lchild)
s.push(temp->lchild);
}
}
void PreOrder_Nonrecursive(BiTree T) //先序遍歷的非遞歸
{
if(!T)
return ;
stack<BiTree> s;
while(T) // 左子樹上的節(jié)點全部壓入到棧中
{
s.push(T);
cout<<T->data<<" ";
T = T->lchild;
}
while(!s.empty())
{
BiTree temp = s.top()->rchild; // 棧頂元素的右子樹
s.pop(); // 彈出棧頂元素
while(temp) // 棧頂元素存在右子樹，則對右子樹同樣遍歷到最下方
{
cout<<temp->data<<" ";
s.push(temp);
temp = temp->lchild;
}
}
}
void InOrderTraverse(BiTree T) // 中序遍歷的非遞歸
{
if(!T)
return ;
stack<BiTree> S;
BiTree curr = T->lchild; // 指向當(dāng)前要檢查的節(jié)點
S.push(T);
while(curr != NULL || !S.empty())
{
while(curr != NULL) // 一直向左走
{
S.push(curr);
curr = curr->lchild;
}
curr = S.top();
S.pop();
cout<<curr->data<<" ";
curr = curr->rchild;
}
}
void PostOrder_Nonrecursive(BiTree T) // 后序遍歷的非遞歸
{
stack<BiTree> S;
BiTree curr = T ; // 指向當(dāng)前要檢查的節(jié)點
BiTree previsited = NULL; // 指向前一個被訪問的節(jié)點
while(curr != NULL || !S.empty()) // ?？諘r結(jié)束
{
while(curr != NULL) // 一直向左走直到為空
{
S.push(curr);
curr = curr->lchild;
}
curr = S.top();
// 當(dāng)前節(jié)點的右孩子如果為空或者已經(jīng)被訪問，則訪問當(dāng)前節(jié)點
if(curr->rchild == NULL || curr->rchild == previsited)
{
cout<<curr->data<<" ";
previsited = curr;
S.pop();
curr = NULL;
}
else
curr = curr->rchild; // 否則訪問右孩子
}
}
void PostOrder_Nonrecursive(BiTree T) // 后序遍歷的非遞歸 雙棧法
{
stack<BiTree> s1 , s2;
BiTree curr ; // 指向當(dāng)前要檢查的節(jié)點
s1.push(T);
while(!s1.empty()) // ?？諘r結(jié)束
{
curr = s1.top();
s1.pop();
s2.push(curr);
if(curr->lchild)
s1.push(curr->lchild);
if(curr->rchild)
s1.push(curr->rchild);
}
while(!s2.empty())
{
printf("%c ", s2.top()->data);
s2.pop();
}
}
int visit(BiTree T)
{
if(T)
{
printf("%c ",T->data);
return 1;
}
else
return 0;
}
void LeverTraverse(BiTree T) //方法一、非遞歸層次遍歷二叉樹
{
queue <BiTree> Q;
BiTree p;
p = T;
if(visit(p)==1)
Q.push(p);
while(!Q.empty())
{
p = Q.front();
Q.pop();
if(visit(p->lchild) == 1)
Q.push(p->lchild);
if(visit(p->rchild) == 1)
Q.push(p->rchild);
}
}
void LevelOrder(BiTree BT) //方法二、非遞歸層次遍歷二叉樹
{
BiTNode *queue[10];//定義隊列有十個空間
if (BT==NULL)
return;
int front,rear;
front=rear=0;
queue[rear++]=BT;
while(front!=rear)//如果隊尾指針不等于對頭指針時
{
cout<<queue[front]->data<<" "; //輸出遍歷結(jié)果
if(queue[front]->lchild!=NULL) //將隊首結(jié)點的左孩子指針入隊列
{
queue[rear]=queue[front]->lchild;
rear++; //隊尾指針后移一位
}
if(queue[front]->rchild!=NULL)
{
queue[rear]=queue[front]->rchild; //將隊首結(jié)點的右孩子指針入隊列
rear++; //隊尾指針后移一位
}
front++; //對頭指針后移一位
}
}
int depth(BiTNode *T) //樹的深度
{
if(!T)
return 0;
int d1,d2;
d1=depth(T->lchild);
d2=depth(T->rchild);
return (d1>d2?d1:d2)+1;
//return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;
}
int CountNode(BiTNode *T)
{
if(T == NULL)
return 0;
return 1+CountNode(T->lchild)+CountNode(T->rchild);
}
int main(void)
{
BiTNode *root=NULL; //定義一個根結(jié)點
int flag=1,k;
printf(" 本程序?qū)崿F(xiàn)二叉樹的基本操作。\n");
printf("可以進(jìn)行建立二叉樹，遞歸先序、中序、后序遍歷，非遞歸先序、中序遍歷及非遞歸層序遍歷等操作。\n");
while(flag)
{
printf("\n");
printf("|--------------------------------------------------------------|\n");
printf("| 二叉樹的基本操作如下: |\n");
printf("| 0.創(chuàng)建二叉樹 |\n");
printf("| 1.遞歸先序遍歷 |\n");
printf("| 2.遞歸中序遍歷 |\n");
printf("| 3.遞歸后序遍歷 |\n");
printf("| 4.非遞歸先序遍歷 |\n");
printf("| 5.非遞歸中序遍歷 |\n");
printf("| 6.非遞歸后序遍歷 |\n");
printf("| 7.非遞歸層序遍歷 |\n");
printf("| 8.二叉樹的深度 |\n");
printf("| 9.二叉樹的結(jié)點個數(shù) |\n");
printf("| 10.退出程序 |\n");
printf("|--------------------------------------------------------------|\n");
printf(" 請選擇功能：");
scanf("%d",&k);
switch(k)
{
case 0:
printf("請建立二叉樹并輸入二叉樹的根節(jié)點：");
CreateBiTree(&root);
break;
case 1:
if(root)
{
printf("遞歸先序遍歷二叉樹的結(jié)果為：");
PreOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 2:
if(root)
{
printf("遞歸中序遍歷二叉樹的結(jié)果為：");
InOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 3:
if(root)
{
printf("遞歸后序遍歷二叉樹的結(jié)果為：");
PostOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 4:
if(root)
{
printf("非遞歸先序遍歷二叉樹：");
PreOrder_Nonrecursive(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 5:
if(root)
{
printf("非遞歸中序遍歷二叉樹：");
InOrderTraverse(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 6:
if(root)
{
printf("非遞歸后序遍歷二叉樹：");
PostOrder_Nonrecursive(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 7:
if(root)
{
printf("非遞歸層序遍歷二叉樹：");
//LeverTraverse(root);
LevelOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 8:
if(root)
printf("這棵二叉樹的深度為：%d\n",depth(root));
else
printf(" 二叉樹為空！\n");
break;
case 9:
if(root)
printf("這棵二叉樹的結(jié)點個數(shù)為：%d\n",CountNode(root));
else
printf(" 二叉樹為空！\n");
break;
default:
flag=0;
printf("程序運行結(jié)束，按任意鍵退出！\n");
}
}
system("pause");
return 0;
}
運行效果圖如下：
/*
后序遍歷由于遍歷父節(jié)點是在遍歷子節(jié)點之后，而且左節(jié)點和右節(jié)點遍歷后的行為不一樣，
所以需要用變量來記錄前一次訪問的節(jié)點，根據(jù)前一次節(jié)點和現(xiàn)在的節(jié)點的關(guān)系來確定具體執(zhí)行什么操作
*/
void Postorder(BiTree T)
{
if(T == NULL)
return ;
stack<BiTree> s;
BiTree prev = NULL , curr = NULL;
s.push(T);
while(!s.empty())
{
curr = s.top();
if(prev == NULL || prev->lchild == curr || prev->rchild == curr)
{
if(curr->lchild != NULL)
s.push(curr->lchild);
else if(curr->rchild != NULL)
s.push(curr->rchild);
}
else if(curr->lchild == prev)
{
if(curr->rchild != NULL)
s.push(curr->rchild);
}
else
{
cout<<curr->data;
s.pop();
}
prev = curr;
}
}
輸入二叉樹中的兩個節(jié)點，輸出這兩個結(jié)點在數(shù)中最低的共同父節(jié)點。
思路：遍歷二叉樹，找到一條從根節(jié)點開始到目的節(jié)點的路徑，然后在兩條路徑上查找共同的父節(jié)點。
// 得到一條從根節(jié)點開始到目的節(jié)點的路徑
bool GetNodePath(TreeNode *pRoot , TreeNode *pNode , vector<TreeNode *> &path)
{
if(pRoot == NULL)
return false;
if(pRoot == pNode)
return true;
else if(GetNodePath(pRoot->lchild , pNode , path) )
{
path.push_back(pRoot->lchild);
return true;
}
else if(GetNodePath(pRoot->rchild , pNode , path) )
{
path.push_back(pRoot->rchild);
return true;
}
return false;
}
TreeNode *GetLastCommonNode(const vector<TreeNode *> &path1 , const vector<TreeNode *> &path2)
{
vector<TreeNode *>::const_iterator iter1 = path1.begin();
vector<TreeNode *>::const_iterator iter2 = path2.begin();
TreeNode *pLast;
while(iter1 != path1.end() && iter2 != path2.end() )
{
if(*iter1 == *iter2)
pLast = *iter1;
else
break;
iter1++;
iter2++;
}
return pLast;
}
TreeNode *GetLastCommonParent(TreeNode *pRoot , TreeNode *pNode1 , TreeNode *pNode2)
{
if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)
return NULL;
vector<TreeNode *> path1;
GetNodePath(pRoot , pNode1 , path1);
vector<TreeNode *> path2;
GetNodePath(pRoot , pNode2 , path2);
return GetLastCommonNode(path1 , path2);
}
復(fù)制代碼 代碼如下:
#include<iostream>
#include<queue>
#include<stack>
using namespace std;
//二叉樹結(jié)點的描述
typedef struct BiTNode
{
char data;
struct BiTNode *lchild, *rchild; //左右孩子
}BiTNode,*BiTree;
//按先序遍歷創(chuàng)建二叉樹
//BiTree *CreateBiTree() //返回結(jié)點指針類型
//void CreateBiTree(BiTree &root) //引用類型的參數(shù)
void CreateBiTree(BiTNode **root) //二級指針作為函數(shù)參數(shù)
{
char ch; //要插入的數(shù)據(jù)
scanf("\n%c", &ch);
//cin>>ch;
if(ch=='#')
*root = NULL;
else
{
*root = (BiTNode *)malloc(sizeof(BiTNode));
(*root)->data = ch;
printf("請輸入%c的左孩子：",ch);
CreateBiTree(&((*root)->lchild));
printf("請輸入%c的右孩子：",ch);
CreateBiTree(&((*root)->rchild));
}
}
//前序遍歷的算法程序
void PreOrder(BiTNode *root)
{
if(root==NULL)
return ;
printf("%c ", root->data); //輸出數(shù)據(jù)
PreOrder(root->lchild); //遞歸調(diào)用，前序遍歷左子樹
PreOrder(root->rchild); //遞歸調(diào)用，前序遍歷右子樹
}
//中序遍歷的算法程序
void InOrder(BiTNode *root)
{
if(root==NULL)
return ;
InOrder(root->lchild); //遞歸調(diào)用，前序遍歷左子樹
printf("%c ", root->data); //輸出數(shù)據(jù)
InOrder(root->rchild); //遞歸調(diào)用，前序遍歷右子樹
}
//后序遍歷的算法程序
void PostOrder(BiTNode *root)
{
if(root==NULL)
return ;
PostOrder(root->lchild); //遞歸調(diào)用，前序遍歷左子樹
PostOrder(root->rchild); //遞歸調(diào)用，前序遍歷右子樹
printf("%c ", root->data); //輸出數(shù)據(jù)
}
/*
二叉樹的非遞歸前序遍歷，前序遍歷思想：先讓根進(jìn)棧，只要棧不為空，就可以做彈出操作，
每次彈出一個結(jié)點，記得把它的左右結(jié)點都進(jìn)棧，記得右子樹先進(jìn)棧，這樣可以保證右子樹在棧中總處于左子樹的下面。
*/
void PreOrder_Nonrecursive2(BiTree T) //先序遍歷的非遞歸
{
if(!T)
return ;
stack<BiTree> s;
s.push(T);
while(!s.empty())
{
BiTree temp = s.top();
cout<<temp->data<<" ";
s.pop();
if(temp->rchild)
s.push(temp->rchild);
if(temp->lchild)
s.push(temp->lchild);
}
}
void PreOrder_Nonrecursive(BiTree T) //先序遍歷的非遞歸
{
if(!T)
return ;
stack<BiTree> s;
while(T) // 左子樹上的節(jié)點全部壓入到棧中
{
s.push(T);
cout<<T->data<<" ";
T = T->lchild;
}
while(!s.empty())
{
BiTree temp = s.top()->rchild; // 棧頂元素的右子樹
s.pop(); // 彈出棧頂元素
while(temp) // 棧頂元素存在右子樹，則對右子樹同樣遍歷到最下方
{
cout<<temp->data<<" ";
s.push(temp);
temp = temp->lchild;
}
}
}
void InOrderTraverse(BiTree T) // 中序遍歷的非遞歸
{
if(!T)
return ;
stack<BiTree> S;
BiTree curr = T->lchild; // 指向當(dāng)前要檢查的節(jié)點
S.push(T);
while(curr != NULL || !S.empty())
{
while(curr != NULL) // 一直向左走
{
S.push(curr);
curr = curr->lchild;
}
curr = S.top();
S.pop();
cout<<curr->data<<" ";
curr = curr->rchild;
}
}
void PostOrder_Nonrecursive(BiTree T) // 后序遍歷的非遞歸
{
stack<BiTree> S;
BiTree curr = T ; // 指向當(dāng)前要檢查的節(jié)點
BiTree previsited = NULL; // 指向前一個被訪問的節(jié)點
while(curr != NULL || !S.empty()) // ?？諘r結(jié)束
{
while(curr != NULL) // 一直向左走直到為空
{
S.push(curr);
curr = curr->lchild;
}
curr = S.top();
// 當(dāng)前節(jié)點的右孩子如果為空或者已經(jīng)被訪問，則訪問當(dāng)前節(jié)點
if(curr->rchild == NULL || curr->rchild == previsited)
{
cout<<curr->data<<" ";
previsited = curr;
S.pop();
curr = NULL;
}
else
curr = curr->rchild; // 否則訪問右孩子
}
}
void PostOrder_Nonrecursive(BiTree T) // 后序遍歷的非遞歸 雙棧法
{
stack<BiTree> s1 , s2;
BiTree curr ; // 指向當(dāng)前要檢查的節(jié)點
s1.push(T);
while(!s1.empty()) // ?？諘r結(jié)束
{
curr = s1.top();
s1.pop();
s2.push(curr);
if(curr->lchild)
s1.push(curr->lchild);
if(curr->rchild)
s1.push(curr->rchild);
}
while(!s2.empty())
{
printf("%c ", s2.top()->data);
s2.pop();
}
}
int visit(BiTree T)
{
if(T)
{
printf("%c ",T->data);
return 1;
}
else
return 0;
}
void LeverTraverse(BiTree T) //方法一、非遞歸層次遍歷二叉樹
{
queue <BiTree> Q;
BiTree p;
p = T;
if(visit(p)==1)
Q.push(p);
while(!Q.empty())
{
p = Q.front();
Q.pop();
if(visit(p->lchild) == 1)
Q.push(p->lchild);
if(visit(p->rchild) == 1)
Q.push(p->rchild);
}
}
void LevelOrder(BiTree BT) //方法二、非遞歸層次遍歷二叉樹
{
BiTNode *queue[10];//定義隊列有十個空間
if (BT==NULL)
return;
int front,rear;
front=rear=0;
queue[rear++]=BT;
while(front!=rear)//如果隊尾指針不等于對頭指針時
{
cout<<queue[front]->data<<" "; //輸出遍歷結(jié)果
if(queue[front]->lchild!=NULL) //將隊首結(jié)點的左孩子指針入隊列
{
queue[rear]=queue[front]->lchild;
rear++; //隊尾指針后移一位
}
if(queue[front]->rchild!=NULL)
{
queue[rear]=queue[front]->rchild; //將隊首結(jié)點的右孩子指針入隊列
rear++; //隊尾指針后移一位
}
front++; //對頭指針后移一位
}
}
int depth(BiTNode *T) //樹的深度
{
if(!T)
return 0;
int d1,d2;
d1=depth(T->lchild);
d2=depth(T->rchild);
return (d1>d2?d1:d2)+1;
//return (depth(T->lchild)>depth(T->rchild)?depth(T->lchild):depth(T->rchild))+1;
}
int CountNode(BiTNode *T)
{
if(T == NULL)
return 0;
return 1+CountNode(T->lchild)+CountNode(T->rchild);
}
int main(void)
{
BiTNode *root=NULL; //定義一個根結(jié)點
int flag=1,k;
printf(" 本程序?qū)崿F(xiàn)二叉樹的基本操作。\n");
printf("可以進(jìn)行建立二叉樹，遞歸先序、中序、后序遍歷，非遞歸先序、中序遍歷及非遞歸層序遍歷等操作。\n");
while(flag)
{
printf("\n");
printf("|--------------------------------------------------------------|\n");
printf("| 二叉樹的基本操作如下: |\n");
printf("| 0.創(chuàng)建二叉樹 |\n");
printf("| 1.遞歸先序遍歷 |\n");
printf("| 2.遞歸中序遍歷 |\n");
printf("| 3.遞歸后序遍歷 |\n");
printf("| 4.非遞歸先序遍歷 |\n");
printf("| 5.非遞歸中序遍歷 |\n");
printf("| 6.非遞歸后序遍歷 |\n");
printf("| 7.非遞歸層序遍歷 |\n");
printf("| 8.二叉樹的深度 |\n");
printf("| 9.二叉樹的結(jié)點個數(shù) |\n");
printf("| 10.退出程序 |\n");
printf("|--------------------------------------------------------------|\n");
printf(" 請選擇功能：");
scanf("%d",&k);
switch(k)
{
case 0:
printf("請建立二叉樹并輸入二叉樹的根節(jié)點：");
CreateBiTree(&root);
break;
case 1:
if(root)
{
printf("遞歸先序遍歷二叉樹的結(jié)果為：");
PreOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 2:
if(root)
{
printf("遞歸中序遍歷二叉樹的結(jié)果為：");
InOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 3:
if(root)
{
printf("遞歸后序遍歷二叉樹的結(jié)果為：");
PostOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 4:
if(root)
{
printf("非遞歸先序遍歷二叉樹：");
PreOrder_Nonrecursive(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 5:
if(root)
{
printf("非遞歸中序遍歷二叉樹：");
InOrderTraverse(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 6:
if(root)
{
printf("非遞歸后序遍歷二叉樹：");
PostOrder_Nonrecursive(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 7:
if(root)
{
printf("非遞歸層序遍歷二叉樹：");
//LeverTraverse(root);
LevelOrder(root);
printf("\n");
}
else
printf(" 二叉樹為空！\n");
break;
case 8:
if(root)
printf("這棵二叉樹的深度為：%d\n",depth(root));
else
printf(" 二叉樹為空！\n");
break;
case 9:
if(root)
printf("這棵二叉樹的結(jié)點個數(shù)為：%d\n",CountNode(root));
else
printf(" 二叉樹為空！\n");
break;
default:
flag=0;
printf("程序運行結(jié)束，按任意鍵退出！\n");
}
}
system("pause");
return 0;
}
運行效果圖如下：
分別輸入：
1
2
4
#
#
5
#
#
3
6
#
#
7
#
#
就可以構(gòu)造如下圖所示的二叉樹了。。
后序遍歷非遞歸的另外一種寫法：
復(fù)制代碼 代碼如下:
/*
后序遍歷由于遍歷父節(jié)點是在遍歷子節(jié)點之后，而且左節(jié)點和右節(jié)點遍歷后的行為不一樣，
所以需要用變量來記錄前一次訪問的節(jié)點，根據(jù)前一次節(jié)點和現(xiàn)在的節(jié)點的關(guān)系來確定具體執(zhí)行什么操作
*/
void Postorder(BiTree T)
{
if(T == NULL)
return ;
stack<BiTree> s;
BiTree prev = NULL , curr = NULL;
s.push(T);
while(!s.empty())
{
curr = s.top();
if(prev == NULL || prev->lchild == curr || prev->rchild == curr)
{
if(curr->lchild != NULL)
s.push(curr->lchild);
else if(curr->rchild != NULL)
s.push(curr->rchild);
}
else if(curr->lchild == prev)
{
if(curr->rchild != NULL)
s.push(curr->rchild);
}
else
{
cout<<curr->data;
s.pop();
}
prev = curr;
}
}
輸入二叉樹中的兩個節(jié)點，輸出這兩個結(jié)點在數(shù)中最低的共同父節(jié)點。
思路：遍歷二叉樹，找到一條從根節(jié)點開始到目的節(jié)點的路徑，然后在兩條路徑上查找共同的父節(jié)點。
復(fù)制代碼 代碼如下:
// 得到一條從根節(jié)點開始到目的節(jié)點的路徑
bool GetNodePath(TreeNode *pRoot , TreeNode *pNode , vector<TreeNode *> &path)
{
if(pRoot == NULL)
return false;
if(pRoot == pNode)
return true;
else if(GetNodePath(pRoot->lchild , pNode , path) )
{
path.push_back(pRoot->lchild);
return true;
}
else if(GetNodePath(pRoot->rchild , pNode , path) )
{
path.push_back(pRoot->rchild);
return true;
}
return false;
}
TreeNode *GetLastCommonNode(const vector<TreeNode *> &path1 , const vector<TreeNode *> &path2)
{
vector<TreeNode *>::const_iterator iter1 = path1.begin();
vector<TreeNode *>::const_iterator iter2 = path2.begin();
TreeNode *pLast;
while(iter1 != path1.end() && iter2 != path2.end() )
{
if(*iter1 == *iter2)
pLast = *iter1;
else
break;
iter1++;
iter2++;
}
return pLast;
}
TreeNode *GetLastCommonParent(TreeNode *pRoot , TreeNode *pNode1 , TreeNode *pNode2)
{
if(pRoot == NULL || pNode1 == NULL || pNode2 == NULL)
return NULL;
vector<TreeNode *> path1;
GetNodePath(pRoot , pNode1 , path1);
vector<TreeNode *> path2;
GetNodePath(pRoot , pNode2 , path2);
return GetLastCommonNode(path1 , path2);
}
相關(guān)文章
在C++中mutable關(guān)鍵字正如字面意思所示,表示「可變的」之意,一般在以下兩種情況中使用較多,一是修飾類中的變量,用來突破const的限制,二是在Lambda表達(dá)式中使用,用來捕獲修改表達(dá)式之外的變量值,下面我們就針對這兩種使用場景逐個介紹2023-10-10
本篇文章是對使用C++實現(xiàn)一個鏈?zhǔn)綏５拇a進(jìn)行了詳細(xì)的分析介紹，需要的朋友參考下2013-05-05
這篇文章主要為大家詳細(xì)介紹了C++實現(xiàn)Dijkstra(迪杰斯特拉)算法，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2020-05-05
QT中QByteArray與char、int、float之間的互相轉(zhuǎn)化
本文主要介紹了QT中QByteArray與char、int、float之間的互相轉(zhuǎn)化，文中通過示例代碼介紹的非常詳細(xì)，對大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2022-05-05
這篇文章主要為大家詳細(xì)介紹了如何利用Qt實現(xiàn)編寫簡易的視頻播放器，可以支持pbonon/qmediaplayer/ffmpeg/vlc/mpv等多種內(nèi)核，感興趣的可以學(xué)習(xí)一下2022-12-12
基于Qt實現(xiàn)駕校科目考試系統(tǒng)的示例代碼
這篇文章主要為大家詳細(xì)介紹了如何基于Qt實現(xiàn)駕?？颇靠荚囅到y(tǒng)，文中的示例代碼講解詳細(xì)，對我們學(xué)習(xí)Qt有一定幫助，需要的可以參考一下2022-07-07
三子棋是一種民間傳統(tǒng)游戲，又叫九宮棋、圈圈叉叉、一條龍、井字棋等。將正方形對角線連起來，相對兩邊依次擺上三個雙方棋子，只要將自己的三個棋子走成一條線，對方就算輸了，想用c語言做出這個游戲，事實上也是比較簡單的，下面通過c語言進(jìn)行對五子棋的分析2022-05-05
這篇文章主要為大家詳細(xì)介紹了C語言實現(xiàn)掃雷游戲，實現(xiàn)掃雷展開和提醒，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2021-03-03
這篇文章主要介紹了 C++11智能指針之weak_ptr詳解，本文通過實例代碼給大家介紹的非常詳細(xì)，對大家的學(xué)習(xí)或工作具有一定的參考借鑒價值,需要的朋友可以參考下2020-06-06
這篇文章主要為大家詳細(xì)介紹了OpenCV實現(xiàn)馬賽克和毛玻璃濾鏡效果，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價值，感興趣的小伙伴們可以參考一下2018-01-01