二叉树中序遍历递归+非递归
2016-07-23 10:55
232 查看
二叉树中序遍历的顺序是左、根、右,递归算法的写法和先序遍历,后序遍历的唯一区别就是访问节点的函数放置的位置不同。非递归还是利用栈来实现,算法思想是从根节点开始,如果当前节点非空则压入栈中,然后将当前节点的左子节点作为当前节点;如果当前节点为空则把栈顶元素作为当前节点,并出栈,然后立即访问当前节点,再将当前节点的右子节点作为当前结点。重复上述步骤,直到栈为空且当前节点为NULL。代码如下:
1.递归方式
#include "stdafx.h"
#include<iostream>
#include <stack>
#include <vector>
using namespace std;
typedef struct binary_tree_node
{
struct binary_tree_node* left;
struct binary_tree_node* right;
int data;
}Binary_Tree_Node;
void visit(Binary_Tree_Node* pNode)
{
if (pNode!=NULL)
{
cout<<pNode->data<<" ";
}
}
Binary_Tree_Node* create_tree(vector<int> dataVec);
void insert_node(Binary_Tree_Node* root,int data);
void in_order(Binary_Tree_Node* root);
void free_node(Binary_Tree_Node* root);
int _tmain(int argc, _TCHAR* argv[])
{
int tmpArray[]={1,2,3,4,5,6,7};
vector<int> input(tmpArray,tmpArray+7);
Binary_Tree_Node *root=create_tree(input);
in_order(root);
free_node(root);
return 0;
}
Binary_Tree_Node* create_tree(vector<int> dataVec)
{
if (dataVec.size()==0)
{
return nullptr;
}
Binary_Tree_Node *root=new Binary_Tree_Node();
root->left=NULL;
root->right=NULL;
root->data=dataVec[0];
for (int i=1;i<dataVec.size();++i)
{
insert_node(root,dataVec[i]);
}
return root;
}
void insert_node(Binary_Tree_Node* root,int data)
{
if (root->left==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->left=leftChild;
return;
}
if (root->right==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->right=leftChild;
return;
}
insert_node(root->left,data);
}
void in_order(Binary_Tree_Node* root)
{
if (root==NULL)
{
return;
}
if (root->left!=NULL)
{
in_order(root->left);
}
visit(root);
if (root->right!=NULL)
{
in_order(root->right);
}
}
void free_node(Binary_Tree_Node* root)
{
if (root->left!=NULL)
{
free_node(root->left);
}
if (root->right!=NULL)
{
free_node(root->right);
}
delete root;
root=NULL;
}
2.非递归方式
#include "stdafx.h"
#include<iostream>
#include <stack>
#include <vector>
using namespace std;
typedef struct binary_tree_node
{
struct binary_tree_node* left;
struct binary_tree_node* right;
int data;
}Binary_Tree_Node;
void visit(Binary_Tree_Node* pNode)
{
if (pNode!=NULL)
{
cout<<pNode->data<<" ";
}
}
Binary_Tree_Node* create_tree(vector<int> dataVec);
void insert_node(Binary_Tree_Node* root,int data);
void in_order(Binary_Tree_Node* root);
void free_node(Binary_Tree_Node* root);
int _tmain(int argc, _TCHAR* argv[])
{
int tmpArray[]={1,2,3,4,5,6,7};
vector<int> input(tmpArray,tmpArray+7);
Binary_Tree_Node *root=create_tree(input);
in_order(root);
free_node(root);
return 0;
}
Binary_Tree_Node* create_tree(vector<int> dataVec)
{
if (dataVec.size()==0)
{
return nullptr;
}
Binary_Tree_Node *root=new Binary_Tree_Node();
root->left=NULL;
root->right=NULL;
root->data=dataVec[0];
for (int i=1;i<dataVec.size();++i)
{
insert_node(root,dataVec[i]);
}
return root;
}
void insert_node(Binary_Tree_Node* root,int data)
{
if (root->left==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->left=leftChild;
return;
}
if (root->right==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->right=leftChild;
return;
}
insert_node(root->left,data);
}
void in_order(Binary_Tree_Node* root)
{
if (root==NULL)
{
return;
}
stack<Binary_Tree_Node*> pStack;
Binary_Tree_Node *curNode=root;
while(!pStack.empty() || curNode!=NULL)
{
if (curNode!=NULL)
{
pStack.push(curNode);
curNode=curNode->left;
}
else
{
Binary_Tree_Node *tmpNode=pStack.top();
pStack.pop();
visit(tmpNode);
curNode=tmpNode->right;
}
}
}
void free_node(Binary_Tree_Node* root)
{
if (root->left!=NULL)
{
free_node(root->left);
}
if (root->right!=NULL)
{
free_node(root->right);
}
delete root;
root=NULL;
}上述程序生成的二叉树如下图:
中序遍历程序结果如下:
1.递归方式
#include "stdafx.h"
#include<iostream>
#include <stack>
#include <vector>
using namespace std;
typedef struct binary_tree_node
{
struct binary_tree_node* left;
struct binary_tree_node* right;
int data;
}Binary_Tree_Node;
void visit(Binary_Tree_Node* pNode)
{
if (pNode!=NULL)
{
cout<<pNode->data<<" ";
}
}
Binary_Tree_Node* create_tree(vector<int> dataVec);
void insert_node(Binary_Tree_Node* root,int data);
void in_order(Binary_Tree_Node* root);
void free_node(Binary_Tree_Node* root);
int _tmain(int argc, _TCHAR* argv[])
{
int tmpArray[]={1,2,3,4,5,6,7};
vector<int> input(tmpArray,tmpArray+7);
Binary_Tree_Node *root=create_tree(input);
in_order(root);
free_node(root);
return 0;
}
Binary_Tree_Node* create_tree(vector<int> dataVec)
{
if (dataVec.size()==0)
{
return nullptr;
}
Binary_Tree_Node *root=new Binary_Tree_Node();
root->left=NULL;
root->right=NULL;
root->data=dataVec[0];
for (int i=1;i<dataVec.size();++i)
{
insert_node(root,dataVec[i]);
}
return root;
}
void insert_node(Binary_Tree_Node* root,int data)
{
if (root->left==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->left=leftChild;
return;
}
if (root->right==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->right=leftChild;
return;
}
insert_node(root->left,data);
}
void in_order(Binary_Tree_Node* root)
{
if (root==NULL)
{
return;
}
if (root->left!=NULL)
{
in_order(root->left);
}
visit(root);
if (root->right!=NULL)
{
in_order(root->right);
}
}
void free_node(Binary_Tree_Node* root)
{
if (root->left!=NULL)
{
free_node(root->left);
}
if (root->right!=NULL)
{
free_node(root->right);
}
delete root;
root=NULL;
}
2.非递归方式
#include "stdafx.h"
#include<iostream>
#include <stack>
#include <vector>
using namespace std;
typedef struct binary_tree_node
{
struct binary_tree_node* left;
struct binary_tree_node* right;
int data;
}Binary_Tree_Node;
void visit(Binary_Tree_Node* pNode)
{
if (pNode!=NULL)
{
cout<<pNode->data<<" ";
}
}
Binary_Tree_Node* create_tree(vector<int> dataVec);
void insert_node(Binary_Tree_Node* root,int data);
void in_order(Binary_Tree_Node* root);
void free_node(Binary_Tree_Node* root);
int _tmain(int argc, _TCHAR* argv[])
{
int tmpArray[]={1,2,3,4,5,6,7};
vector<int> input(tmpArray,tmpArray+7);
Binary_Tree_Node *root=create_tree(input);
in_order(root);
free_node(root);
return 0;
}
Binary_Tree_Node* create_tree(vector<int> dataVec)
{
if (dataVec.size()==0)
{
return nullptr;
}
Binary_Tree_Node *root=new Binary_Tree_Node();
root->left=NULL;
root->right=NULL;
root->data=dataVec[0];
for (int i=1;i<dataVec.size();++i)
{
insert_node(root,dataVec[i]);
}
return root;
}
void insert_node(Binary_Tree_Node* root,int data)
{
if (root->left==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->left=leftChild;
return;
}
if (root->right==NULL)
{
Binary_Tree_Node* leftChild=new Binary_Tree_Node();
leftChild->left=NULL;
leftChild->right=NULL;
leftChild->data=data;
root->right=leftChild;
return;
}
insert_node(root->left,data);
}
void in_order(Binary_Tree_Node* root)
{
if (root==NULL)
{
return;
}
stack<Binary_Tree_Node*> pStack;
Binary_Tree_Node *curNode=root;
while(!pStack.empty() || curNode!=NULL)
{
if (curNode!=NULL)
{
pStack.push(curNode);
curNode=curNode->left;
}
else
{
Binary_Tree_Node *tmpNode=pStack.top();
pStack.pop();
visit(tmpNode);
curNode=tmpNode->right;
}
}
}
void free_node(Binary_Tree_Node* root)
{
if (root->left!=NULL)
{
free_node(root->left);
}
if (root->right!=NULL)
{
free_node(root->right);
}
delete root;
root=NULL;
}上述程序生成的二叉树如下图:
中序遍历程序结果如下:
相关文章推荐
- 二叉树先根(先序)遍历的改进
- 二叉树遍历 非递归 C++实现代码
- c++二叉树的几种遍历算法
- 二叉树先序遍历的非递归算法具体实现
- JS中的二叉树遍历详解
- JS中的二叉树遍历详解
- 三种树遍历顺序的迭代版
- 二叉树遍历的6种遍历方法
- java二叉树的遍历算法
- 与众不同的二叉树遍历实现
- 二叉树先序遍历递归+非递归
- 二叉树遍历
- 先序遍历 中序遍历 后序遍历
- 二叉树的创建及遍历
- 前序/中序/后序遍历二叉树的非递归算法
- 二叉树先序中序后序遍历递归和非递归算法
- 二叉树各种遍历的实现(递归、非递归、层次、高度和节点数目)
- 1020. Tree Traversals (25)
- 文章标题
- 数据结构复习——二叉树的表示及遍历