数据结构——二叉树

二叉树是数据结构的一个重要内容之一，那么对于我们这些学习编程的人来说，掌握二叉树的各种遍历（递归遍历和非递归遍历）是必不可少的，下面我们就分析一下，二叉树的各种遍历方法：

1首先得建立一个二叉树：

1.二叉树节点

struct BinaryTreeNode//二叉树节点 {     BinaryTreeNode* _left;     BinaryTreeNode* _right;     T _data;     BinaryTreeNode(const T data)        :_left(NULL)//二叉树左孩子        ,_right(NULL)//右孩子        ,_data(data)    {    }}; 

2.造二叉树

BinaryTree(const T* a, size_t size, const T& invalid)//二叉树构造函数            :_root(NULL)        {            size_t index=0;            _root=CreatBinaryTree(a,size,index,invalid);        }

Node* CreatBinaryTree(const T* a,size_t size,size_t& index,const T& invalid)//制造二叉树（前序）    {        Node* root=NULL;        if(a[index]!=invalid&&index<size)        {            root=new Node(a[index]);//new一个根节点，先造根节点            root->_left=CreatBinaryTree(a,size,++index,invalid);//再造左节点            root->_right=CreatBinaryTree(a,size,++index,invalid);//再造右节点        }        return root;    }   

3.遍历二叉树（递归）

①前序遍历，前序遍历是1.遍历根节点、2.遍历左节点、3.遍历有节点

void PrevOrder()//前序遍历    {        _PrevOrder(_root);//传根节点        cout<<endl;    }    void _PrevOrder(Node* T)    {        if(T==NULL)            return;        else        {            cout<<T->_data<<" ";//先访问根节点，在这里是直接输出            _PrevOrder(T->_left);//访问左节点            _PrevOrder(T->_right);//访问有节点        }    }

②中序遍历（递归），中序遍历和前序遍历类似，只不过是将访问顺序变为1.左节点、2.根节点、3.有节点

void InOrder()    {        _InOrder(_root);        cout<<endl;    }    void _InOrder(Node* T)    {        if(T==NULL)            return;        else        {            _InOrder(T->_left);            cout<<T->_data<<" ";            _InOrder(T->_right);        }    }    void PostOrder()    {        _PostOrder(_root);        cout<<endl;    }

③后序遍历，也不例外，1.访问左节点、2.访问右节点、3.访问根节点

void PostOrder()    {        _PostOrder(_root);        cout<<endl;    }void _PostOrder(Node* T)    {        if(T==NULL)            return;        else        {            _PostOrder(T->_left);//访问左节点            _PostOrder(T->_right);//访问右节点            cout<<T->_data<<" ";//访问根节点        }    }

4.非递归遍历二叉树

①前序序访问二叉树

前序采用栈来处理，如图所示，先压1，然后出1，压 2,3，这里先压3，后压2，是栈的特点，后进先出所以先出2，压 5、 4；然后出4，压9、 8；出 8，然后出9、出 5、出3；压 7 、6，出7，出6；

得到1,2,4,8,9,5,3,7,6；

void PrevOrder_NonR()    {        Node* T = _root;        stack<Node*> s;        while(T!=NULL||!s.empty())        {            if(T!=NULL)            {                cout<<T->_data<<" ";                s.push(T);                T=T->_left;            }            else            {   T=s.top();                s.pop();                T=T->_right;            }        }        cout<<endl;    }

②中序遍历

中序遍历和前序是一样的采用栈来处理，只不过是先访问左节点，然后根节点、右节点

void InOrder_NonR()    {        Node* T = _root;        stack<Node*> s;        if(T==NULL)            return;        else        {            Node* temp=T;            while(!s.empty()||temp!=NULL)               {                if(temp!=NULL)                {                    s.push(temp);//先将所有的走节点压进去                    temp=temp->_left;                }                else                {                    temp=s.top();//访问节点                    cout<<temp->_data<<" ";//记录                    s.pop();//出栈                    temp=temp->_right;//判断有节点；                }            }            cout<<endl;        }    }

③后序访问

后序访问就比较复杂了，我解决他的办法是采用俩个栈，首先要说明的是：后序和前序是有关系的，来对比一下，前序：1.根节点、2.左节点、3.右节点后续：1.左节点、2、右节点、3.根节点。那么我们可以采用类似的方法：处理先以1.根节点、2.右节点、3.左节点 这种方式遍历并将遍历结果压入output栈中，然后出栈退栈，既得到1.左节点、2.右节点、3.根节点。

void PostOrder_NonR()    {        Node* T = _root;        stack<Node*> s,output;        while(T!=NULL||!s.empty())        {            if(T!=NULL)            {                s.push(T);//先根节点                output.push(T);//入栈                T=T->_right;//右节点            }            else            {                   T=s.top();                s.pop();                T=T->_left;//走左节点            }        }        while(output.size()!=0)        {            Node* temp = output.top();            cout<<temp->_data<<" ";            output.pop();        }        cout<<endl;    }

④层序访问二叉树

#下图是层序访问的结构图

有上述结构图可以看出这种访问方式，与队列是一模一样的，所以我们采用队列的方式解决。1.现将1入队，先记录1 然后出队（访问），通过1来使得2、3入队；然后2，记录后2出队，4 、5入队；然后3，记录后出队，6 、7入队….,就这样一直走下去直到队列为空为止。

void LevelOrder()    {        Node* root = _root;        queue<Node*> q;        if(root)            q.push(root);//先使得第一个节点入队        while(q.size()!=0)        {            Node* temp=q.front();//记录            q.pop();//出队            cout<<temp->_data<<" ";            if(temp->_left!=NULL)//先左                q.push(temp->_left);            if(temp->_right!=NULL)//后右                q.push(temp->_right);        }        cout<<endl;    }