二叉树节点的结构
class Node{
int value;
Node left;
Node right;
Node(int data){
this.valve=data;
}
}
要求掌握内容
1.能结合队列、栈、链表、字符串等很多数据结构。
2.需掌握图的遍历方式,比如BFS和DFS。
3.需掌握递归函数的使用,并自己设计出递归过程。
先序、中序和后序遍历
先序遍历:中、左、右
中序遍历:左、中、右
后序遍历:左、右、中
1
23
4567
先序:1 2 4 5 3 6 7
中序:4 2 5 1 6 3 7
后序:4 5 2 6 7 3 1
递归方式实现先序遍历
public void preOrderRecur(Node head){
if(head==null){
return;
}
System.out.print(head.valve + " ");
preOrdeRecur(head.left);
preOrdeRecur(head.right);
}
思想:若树为空,返回。若不为空,先打印当前头结点的值,然后遍历左子树,最后遍历右子树。
非递归方式实现先序遍历
具体过程:
1.先申请一个新的栈,记为stack。
2.然后将头结点head压入stack中。
3.每次从stack中弹出栈顶节点,记为cur,然后打印cur节点的值。若cur右孩子不为空的话,将cur的右孩子先压入stack中。最后如果cur的左孩子不为空的话,将cur的左孩子压入stack中。
4.不断重复步骤3,直到stack为空,全部过程结束。
递归方式实现中序遍历
public void preOrderRecur(Node head){
if(head==null){
return;
}
preOrdeRecur(head.left);
System.out.print(head.valve + " ");
preOrdeRecur(head.right);
}
非递归方式实现中序遍历
具体过程:
1.先申请一个新的栈,记为stack,申请一个变量cur,初始时令cur等于头节点。
2.先把cur节点压入栈中,对以cur节点为头的整棵子树来说,依次把整棵树的左边界压入栈中,即不断令cur=cur.left,然后重复步骤2。
3.不断重复步骤2,直到发现cur为空,此时从stack中弹出一个节点,记为node。打印node的值,并让cur=node.right,然后重复步骤2。
4.当stack为空并且cur为空时,整个过程结束。
递归方式实现后序遍历
public void preOrderRecur(Node head){
if(head==null){
return;
}
preOrdeRecur(head.left);
preOrdeRecur(head.right);
System.out.print(head.valve + " ");
}
非递归方式实现后序遍历
方法一:使用两个栈实现
具体过程:
1.先申请一个新的栈,记为s1,然后将头结点压入s1中。
2.从s1中弹出的节点记为cur,然后先把cur的左孩子压入s1中,然后把cur1的右孩子压入s1中。
3.在整个过程中,每一个从s1中弹出的节点都放进第二个栈s2中。
4.不断重复步骤2和步骤3,直到s1为空,过程停止。
5.从s2中以此弹出节点并打印,打印的顺序就是后序遍历的顺序了。
方法二:使用一个栈实现
具体过程:
1.先申请一个新的栈,记为stack。将头节点压入stack,同时设置两个变量h和c。在整个流程中,h代表最近一次弹出并打印的节点,c代表当前stack的栈顶节点,初始时令h为头节点,c为null。
2.每次令c等于当前stack的栈顶节点,但是不从stack中弹出节点,此时分以下三种情况。
(1)如果c的左孩子不为空,并且h不等于c的左孩子,也不等于c的右孩子,则把c的左孩子压入stack中。
(2)如果情况1不成立,并且c的右孩子不为空,并且h不等于c的右孩子,则把c的右孩子压入stack中。
(3)如果情况1和情况2都不成立,那么从stack中弹出c并打印,然后令h等于c。
3.不断重复步骤2,直到stack为空,全部过程结束。
递归方式实现深度遍历
#include<iostream>
#include<string>
using namespace std;
class BinaryTreeNode
{
public:
char data;
BinaryTreeNode *Left;
BinaryTreeNode *Right;
};
//创建二叉树,顺序依次为中间节点->左子树->右子树
void createBiTree(BinaryTreeNode* &T) //这里加上&意思是传递的参数为指针的引用,括号里面等价于 BiTreeNode* &T
{ //这样的意义在于在函数执行过后,传递进来的指针会发生改变(引用的作用),不可以去掉&
char c;
cin >> c;
if('#' == c) //当遇到#时,令树的根节点为NULL,从而结束该分支的递归
T = NULL;
else
{
T = new BinaryTreeNode;
T->data=c;
createBiTree(T->Left);
createBiTree(T->Right);
}
}
void preorder(BinaryTreeNode* &T){
if(T){
cout<<T->data<<" ";
preorder(T->Left);
preorder(T->Right);
}
}
void midorder(BinaryTreeNode* &T){
if(T){
midorder(T->Left);
cout<<T->data<<" ";
midorder(T->Right);
}
}
void postorder(BinaryTreeNode* &T){
if(T){
postorder(T->Left);
postorder(T->Right);
cout<<T->data<<" ";
}
}
int main(){
BinaryTreeNode* T; //声明一个指向二叉树根节点的指针
createBiTree(T);
cout<<"二叉树创建完成!"<<endl;
cout<<"前序遍历二叉树:"<<endl;
preorder(T);
cout<<endl;
cout<<"中序遍历二叉树:"<<endl;
midorder(T);
cout<<endl;
cout<<"后序遍历二叉树:"<<endl;
postorder(T);
return 0;
}
非递归方式实现深度遍历
#include<iostream>
#include<string>
#include<stack>
using namespace std;
class BinaryTreeNode
{
public:
char data;
BinaryTreeNode *Left;
BinaryTreeNode *Right;
};
//创建二叉树,顺序依次为中间节点->左子树->右子树
void createBiTree(BinaryTreeNode* &T) //这里加上&意思是传递的参数为指针的引用,括号里面等价于 BiTreeNode* &T
{ //这样的意义在于在函数执行过后,传递进来的指针会发生改变(引用的作用),不可以去掉&
char c;
cin >> c;
if('#' == c) //当遇到#时,令树的根节点为NULL,从而结束该分支的递归
T = NULL;
else
{
T = new BinaryTreeNode;
T->data=c;
createBiTree(T->Left);
createBiTree(T->Right);
}
}
void preorder(BinaryTreeNode* &T){
stack<BinaryTreeNode*> s;
s.push(T);
while(!s.empty()){
BinaryTreeNode* cur=s.top();
s.pop();
cout<<cur->data;
if(cur->Right!=NULL){
s.push(cur->Right);
}
if(cur->Left!=NULL){
s.push(cur->Left);
}
}
}
void midorder(BinaryTreeNode* &T){
stack<BinaryTreeNode*> s;
BinaryTreeNode* cur=T;
while(cur!=NULL||!s.empty()){
while(cur!=NULL){
s.push(cur);
cur=cur->Left;
}
BinaryTreeNode* node=s.top();
s.pop();
cout<<node->data;
cur=node->Right;
}
}
void postorder(BinaryTreeNode* &T){
stack<BinaryTreeNode*> s1;
stack<BinaryTreeNode*> s2;
s1.push(T);
while(!s1.empty()){
BinaryTreeNode* cur=s1.top();
s1.pop();
s2.push(cur);
if(cur->Left!=NULL){
s1.push(cur->Left);
}
if(cur->Right!=NULL){
s1.push(cur->Right);
}
}
while(!s2.empty()){
BinaryTreeNode* node=s2.top();
s2.pop();
cout<<node->data;
}
}
int main(){
BinaryTreeNode* T; //声明一个指向二叉树根节点的指针
createBiTree(T); //abd###ce##fg###
cout<<"二叉树创建完成!"<<endl;
cout<<"前序遍历二叉树:"<<endl;
preorder(T);
cout<<endl;
cout<<"中序遍历二叉树:"<<endl;
midorder(T);
cout<<endl;
cout<<"后序遍历二叉树:"<<endl;
postorder(T);
cout<<endl;
return 0;
}
总结
不管是递归方法还是非递归方法,遍历整棵树的时间复杂度都是O(N),N为二叉树节点数,额外空间复杂度为O(L),L为二叉树的层数。