二叉树(1)

二叉树节点的结构

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为二叉树的层数。