#include <iostream>
#include <vector>
#include <list>
using namespace std;
// 节点结构体
typedef struct node
{
int data;
node* leftChild;
node* rightChild;
bool leftVisited;
bool rightVisited;
node()
{
int data = -1;
leftChild = NULL;
rightChild = NULL;
leftVisited = false;
rightVisited = false;
}
}Node, *pNode;
//******************************************************************************
// Name: CreateChild
// Desc: 创建子树
//******************************************************************************
void CreateChild(Node* &root, vector<int>::iterator &beginIter,
vector<int>::iterator &endIter)
{
if(beginIter != endIter)
{
int tempData = *beginIter++;
if(tempData != -1)
{
root = new Node;
root->data = tempData;
CreateChild(root->leftChild, beginIter, endIter); // 创建左子树
CreateChild(root->rightChild, beginIter, endIter); // 创建右子树
}
else
{
root = NULL;
}
}
else
{
root = NULL;
}
}
//******************************************************************************
// Name: CreateTree
// Desc: 先序扩展序列创建一棵树(先序遍历,空节点用-1标识)
//******************************************************************************
Node* CreateTree(Node* root, vector<int> &dataVec)
{
if(dataVec.size() < 1) return NULL;
vector<int>::iterator beginIter = dataVec.begin();
vector<int>::iterator endIter = dataVec.end();
root = NULL;
CreateChild(root, beginIter, endIter);
return root;
}
//******************************************************************************
// Name: DisplayTree
// Desc: 二叉显示
//******************************************************************************
void DisplayTree(Node* root)
{
if(root != NULL)
{
cout<<"node:"<<root->data<<" ";
if(root->leftChild != NULL)
{
cout<<"leftChild:"<<root->leftChild->data<<" ";
}
if(root->rightChild != NULL)
{
cout<<"rightChild:"<<root->rightChild->data<<" ";
}
cout<<endl;
DisplayTree(root->leftChild);
DisplayTree(root->rightChild);
}
}
//******************************************************************************
// Name: FirstVisite
// Desc: 先根遍历(递归)
//******************************************************************************
void FirstVisite(Node* root)
{
if(root != NULL)
{
cout<<root->data<<" ";
FirstVisite(root->leftChild);
FirstVisite(root->rightChild);
}
}
//******************************************************************************
// Name: CenterVisite
// Desc: 中根遍历(递归)
//******************************************************************************
void CenterVisite(Node* root)
{
if(root != NULL)
{
CenterVisite(root->leftChild);
cout<<root->data<<" ";
CenterVisite(root->rightChild);
}
}
//******************************************************************************
// Name: AfterVisite
// Desc: 后根遍历(递归)
//******************************************************************************
void AfterVisite(Node* root)
{
if(root != NULL)
{
AfterVisite(root->leftChild);
AfterVisite(root->rightChild);
cout<<root->data<<" ";
}
}
//******************************************************************************
// Name: ResetTree
// Desc: 重置二叉树,方便一次遍历
//******************************************************************************
void ResetTree(Node* root)
{
if(root != NULL)
{
root->leftVisited = false;
root->rightVisited = false;
ResetTree(root->leftChild);
ResetTree(root->rightChild);
}
}
//******************************************************************************
// Name: _FirstVisite
// Desc: 先根遍历(非递归)
//******************************************************************************
void _FirstVisite(Node* tree)
{
ResetTree(tree);
typedef vector<Node*> NodeStack;
NodeStack stack;
stack.push_back(tree); // 初始化栈
while (stack.size() > 0)
{
Node* topNode = stack.back();
if (!topNode->leftVisited && !topNode->rightVisited)
{
cout<<topNode->data<<" ";
}
if (topNode->leftChild != NULL && !topNode->leftVisited)
{
stack.push_back(topNode->leftChild);
topNode->leftVisited = true;
}
else if (topNode->rightChild != NULL && !topNode->rightVisited)
{
stack.push_back(topNode->rightChild);
topNode->rightVisited = true;
}
else
{
stack.pop_back();
}
}
}
//******************************************************************************
// Name: __FirstVisite
// Desc: 非递归先根遍历思路二
//******************************************************************************
void __FirstVisite(Node* tree)
{
typedef vector<Node*> NodeStack;
NodeStack stack;
Node *curNode = tree;
while(!stack.empty() || curNode != NULL)
{
while(curNode != NULL)
{
cout<<curNode->data<<" ";
stack.push_back(curNode);
curNode = curNode->leftChild;
}
if(!stack.empty())
{
curNode = stack.back();
curNode = curNode->rightChild;
stack.pop_back();
}
}
}
//******************************************************************************
// Name: _CenterVisit
// Desc: 中根遍历(非递归)
//******************************************************************************
void _CenterVisite(Node* tree)
{
ResetTree(tree);
typedef vector<Node*> NodeStack;
NodeStack stack;
stack.push_back(tree); // 初始化
while (stack.size() > 0)
{
Node* topNode = stack.back();
if (topNode->leftVisited && !topNode->rightVisited)
{
cout<<topNode->data<<" ";
}
if (topNode->leftChild != NULL && !topNode->leftVisited)
{
stack.push_back(topNode->leftChild);
topNode->leftVisited = true;
}
else
{
if (topNode->rightChild != NULL && !topNode->rightVisited)
{
if (topNode->leftChild == NULL && topNode->rightChild != NULL)
{
cout<<topNode->data<<" "; // 单边只有右子节点
}
stack.push_back(topNode->rightChild);
topNode->rightVisited = true;
}
else
{
if (topNode->leftChild == NULL && topNode->rightChild == NULL)
{
cout<<topNode->data<<" ";
}
stack.pop_back();
}
}
}
}
//******************************************************************************
// Name: __CenterVisite
// Desc: 非递归中根遍历思路二
//******************************************************************************
void __CenterVisite(Node* tree)
{
typedef vector<Node*> NodeStack;
NodeStack stack;
Node* curNode = tree;
while(!stack.empty() || curNode != NULL)
{
while(curNode != NULL)
{
stack.push_back(curNode);
curNode = curNode->leftChild;
}
if(!stack.empty())
{
curNode = stack.back();
cout<<curNode->data<<" ";
curNode = curNode->rightChild;
stack.pop_back();
}
}
}
//******************************************************************************
// Name: _AfterVisite
// Desc: 后序遍历(非递归)
//******************************************************************************
void _AfterVisite(Node* tree)
{
ResetTree(tree);
typedef vector<Node*> NodeStack;
NodeStack stack;
stack.push_back(tree); // 初始化
while (stack.size())
{
Node* topNode = stack.back();
if (topNode->leftVisited && topNode->rightVisited)
{
cout<<topNode->data<<" ";
}
if (topNode->leftChild != NULL && !topNode->leftVisited)
{
stack.push_back(topNode->leftChild);
topNode->leftVisited = true;
}
else if (topNode->rightChild != NULL && !topNode->rightVisited)
{
stack.push_back(topNode->rightChild);
topNode->rightVisited = true;
}
else
{
// 针对叶子节点或者单边子节点的情况
if (topNode->leftChild == NULL || topNode->rightChild == NULL)
{
cout<<topNode->data<<" ";
}
stack.pop_back();
}
}
}
//******************************************************************************
// Name: __AfterVisite
// Desc: 非递归后根遍历思路二
//******************************************************************************
void __AfterVisite(Node* tree)
{
typedef vector<Node*> StackNode;
StackNode stack;
Node *curNode; // 当前结点
Node *preNode = NULL; // 前一次访问的结点
stack.push_back(tree);
while(!stack.empty())
{
curNode = stack.back();
if((curNode->leftChild == NULL && curNode->rightChild == NULL) ||
(preNode != NULL && (preNode == curNode->leftChild || preNode == curNode->rightChild)))
{
cout<<curNode->data<<" "; // 如果当前结点没有孩子结点或者孩子节点都已被访问过
stack.pop_back();
preNode = curNode;
}
else
{
if(curNode->rightChild != NULL)
{
stack.push_back(curNode->rightChild);
}
if(curNode->leftChild != NULL)
{
stack.push_back(curNode->leftChild);
}
}
}
}
//******************************************************************************
// Name: LevelVisite
// Desc: 层次遍历
//******************************************************************************
void LevelVisite(Node* tree)
{
typedef list<Node*> QueueNode;
QueueNode queue;
queue.push_back(tree);
while (queue.size() > 0) //由上至下,由左至右
{
Node* curNode = queue.front();
queue.pop_front();
cout<<curNode->data<<" ";
if (curNode->leftChild != NULL)
{
queue.push_back(curNode->leftChild);
}
if (curNode->rightChild != NULL)
{
queue.push_back(curNode->rightChild);
}
}
}
//******************************************************************************
// Name: CaculateLeafNum
// Desc: 统计叶子节点的数量
//******************************************************************************
int CaculateLeafNum(Node* tree)
{
if (tree == NULL)
{
return 0;
}
if (tree->leftChild == NULL && tree->rightChild == NULL) //孤立点
{
return 1;
}
//递归计算
int sum = 0;
sum += CaculateLeafNum(tree->leftChild);
sum += CaculateLeafNum(tree->rightChild);
return sum;
}
//******************************************************************************
// Name: CaculateAllNodeNum
// Desc: 统计所有节点数量
//******************************************************************************
int CaculateAllNodeNum(Node* tree)
{
/*static int sum = 0;
if(tree != NULL)
{
sum += 1;
CaculateAllNodeNum(tree->leftChild);
CaculateAllNodeNum(tree->rightChild);
}*/
int sum = 0;
if (tree != NULL)
{
sum = 1;
sum += CaculateAllNodeNum(tree->leftChild);
sum += CaculateAllNodeNum(tree->rightChild);
}
return sum;
}
//******************************************************************************
// Name: CaculateDepth
// Desc: 计算二叉树的深度
//******************************************************************************
int CaculateDepth(Node* tree)
{
int leftDepth = 0;
int rightDepth = 0;
if(tree != NULL)
{
leftDepth = 1;
leftDepth += CaculateDepth(tree->leftChild);
rightDepth = 1;
rightDepth += CaculateDepth(tree->rightChild);
}
return leftDepth > rightDepth ? leftDepth : rightDepth;
}
//******************************************************************************
// Name: CaculateWidth
// Desc: 计算二叉树的宽度
//******************************************************************************
int CaculateWidth(Node* tree)
{
if (tree == NULL)
{
return 0;
}
typedef list<Node*> QueueNode;
QueueNode queue;
unsigned int width = 0;
queue.push_back(tree);
while (queue.size() > 0)
{
unsigned int size = queue.size();
for (unsigned int i = 0; i < size; ++i) // 上一层的节点全部出列,并压入下一层节点
{
Node* curNode = queue.front();
queue.pop_front();
if (curNode->leftChild != NULL)
{
queue.push_back(curNode->leftChild);
}
if (curNode->rightChild != NULL)
{
queue.push_back(curNode->rightChild);
}
}
width = max(width, size); // 与每一个size比较,取最大者
}
return width;
}
//******************************************************************************
// Name: Release
// Desc: 释放资源
//******************************************************************************
void Release(Node* tree)
{
if(tree != NULL)
{
Release(tree->leftChild);
Release(tree->rightChild);
delete tree;
tree = NULL;
}
}
int main()
{
// 数据输入
vector<int> dataVec;
int tempValue;
cout<<"请输入二叉树的先序扩展序列(-1为空):"<<endl;
while(cin>>tempValue)
{
dataVec.push_back(tempValue);
}
// 二叉树的创建
Node* root = NULL;
root = CreateTree(root, dataVec);
// 二叉显示
DisplayTree(root);
// 递归先根遍历
FirstVisite(root);
cout<<endl;
// 递归中根遍历
CenterVisite(root);
cout<<endl;
// 递归后根遍历
AfterVisite(root);
cout<<endl;
cout<<"----------------------------"<<endl;
// 非递归先根遍历
_FirstVisite(root);
cout<<endl;
// 非递归先根遍历二
__FirstVisite(root);
cout<<endl;
// 非递归中根遍历
_CenterVisite(root);
cout<<endl;
// 非递归中根遍历思路二
__CenterVisite(root);
cout<<endl;
// 非递归后根遍历
_AfterVisite(root);
cout<<endl;
// 非递归后根遍历思路二
__AfterVisite(root);
cout<<endl;
// 层次遍历
LevelVisite(root);
cout<<endl;
// 计算叶子节点数量
cout<<CaculateLeafNum(root)<<endl;
// 计算所有节点数量
cout<<CaculateAllNodeNum(root)<<endl;
// 计算二叉树深度
cout<<CaculateDepth(root)<<endl;
// 计算二叉树宽度
cout<<CaculateWidth(root)<<endl;
// 释放资源
Release(root);
system("pause");
return 0;
}
其他操作:
Node* midLastToTree(const string& midIn, const string& lastIn)// 已知二叉树中序遍历和
{ //后序遍历序列,求二叉树的二叉链表结构
if (midIn.empty() || lastIn.empty())
{
return 0;
}
char rootC = *(lastIn.end() - 1); // 找出根结点
// 把字符串midIn分成两部分
string::size_type rootIndex = midIn.find_first_of(rootC);
string leftMidIn = midIn.substr(0, rootIndex);
string rightMidIn = midIn.substr(rootIndex+1);
// 把字符串lastIn也分成两部分
string leftLastIn;
string rightLastIn;
string::const_iterator curIter = lastIn.begin();
string::const_iterator endIter = lastIn.end();
for (; curIter!=endIter; ++curIter)
{
char c = *curIter;
if (leftMidIn.find_first_of(c)!=string::npos)
{
leftLastIn.push_back(c);
} else if (rightMidIn.find_first_of(c)!=string::npos)
{
rightLastIn.push_back(c);
}
}
Node* tree = new Node;
tree->c = rootC;
// 递归
tree->left = midLastToTree(leftMidIn, leftLastIn);
tree->right = midLastToTree(rightMidIn, rightLastIn);
return tree;
}
Node* firstMidToTree(const string& midIn, const string firstIn)// 已知二叉树中序遍历和
{ //先序遍历序列,求二叉树的二叉链表结构
if (midIn.empty() || firstIn.empty())
{
return 0;
}
char rootC = *firstIn.begin();
// 把字符串midIn分成两部分
string::size_type rootIndex = midIn.find_first_of(rootC);
string leftMidIn = midIn.substr(0, rootIndex);
string rightMidIn = midIn.substr(rootIndex+1);
// 把字符串firstIn分成两部分
string leftFirstIn, rightFirstIn;
string::const_iterator curIter = firstIn.begin();
string::const_iterator endIter = firstIn.end();
while (curIter != endIter)
{
char c = *curIter++;
if (leftMidIn.find_first_of(c)!=string::npos)
{
leftFirstIn.push_back(c);
} else if (rightMidIn.find_first_of(c)!=string::npos)
{
rightFirstIn.push_back(c);
}
}
Node* tree = new Node;
tree->c = rootC;
// 递归
tree->left = firstMidToTree(leftMidIn, leftFirstIn);
tree->right = firstMidToTree(rightMidIn, rightFirstIn);
return tree;
}
void postOrder2(BinTree *root) //非递归后序遍历
{
stack<BTNode*> s;
BinTree *p=root;
BTNode *temp;
while(p!=NULL||!s.empty())
{
while(p!=NULL) //沿左子树一直往下搜索,直至出现没有左子树的结点
{
BTNode *btn=(BTNode *)malloc(sizeof(BTNode));
btn->btnode=p;
btn->isFirst=true;
s.push(btn);
p=p->lchild;
}
if(!s.empty())
{
temp=s.top();
s.pop();
if(temp->isFirst==true) //表示是第一次出现在栈顶
{
temp->isFirst=false;
s.push(temp);
p=temp->btnode->rchild;
}
else //第二次出现在栈顶
{
cout<<temp->btnode->data<<" ";
p=NULL;
}
}
}
}