二叉樹的層次遍歷（隊列） and 二叉搜索樹的後序遍歷序列

（一）從上往下打印出二叉樹的每一個節點，同一層的節點按照從左到右的順序打印。【層次遍歷】

從上到下打印二叉樹的規律：每一次打印一個節點的時候，若是該節點有子節點，則把該節點的子節點放到一個隊列的末尾。接下來到隊列的頭部取出最先進入隊列的節點，重複前面的操做，直至隊列中全部的節點都被打印出來爲止。

//二叉樹的層次遍歷
#include<iostream>
#include<queue>
using namespace std;

typedef int ElemType;
typedef struct TNode
{
 ElemType data;
 struct TNode *LeftChild;
 struct TNode *RightChild;
}TreeNode, *BinaryTree;

TreeNode* BinaryTreeNode(ElemType e)
{
 TreeNode *T = NULL;
 T = new TNode();
 T->data = e;
 T->LeftChild = NULL;
 T->RightChild = NULL;
 return T;
}

void ConnectTreeNode(TreeNode *pParent, TreeNode *pLeft, TreeNode *pRight)
{
 if(pParent == NULL)
  return;
 pParent->LeftChild = pLeft;
 pParent->RightChild = pRight;
}

void PrintFromTopToBottom(BinaryTree T)
{
 if(T == NULL)
  return;
 queue<TreeNode*> queueTreeNode;
 queueTreeNode.push(T);
 while(!queueTreeNode.empty())
 {
  TreeNode *pNode = queueTreeNode.front();
  cout << pNode->data << " ";
  queueTreeNode.pop();
  if(pNode->LeftChild != NULL)
   queueTreeNode.push(pNode->LeftChild);
  if(pNode->RightChild != NULL)
   queueTreeNode.push(pNode->RightChild);
 }
}

int main()
{
 TreeNode *pNode1 = BinaryTreeNode(8);
 TreeNode *pNode2 = BinaryTreeNode(6);
 TreeNode *pNode3 = BinaryTreeNode(10);
 TreeNode *pNode4 = BinaryTreeNode(5);
 TreeNode *pNode5 = BinaryTreeNode(7);
 TreeNode *pNode6 = BinaryTreeNode(9);
 TreeNode *pNode7 = BinaryTreeNode(11);

 ConnectTreeNode(pNode1, pNode2, pNode3);
 ConnectTreeNode(pNode2, pNode4, pNode5);
 ConnectTreeNode(pNode3, pNode6, pNode7);

 PrintFromTopToBottom(pNode1);
 cout << endl;

 system("pause");
 return 0;
}

不管是廣度優先遍歷一個有向圖仍是一棵樹，都要用到隊列。第一步把起始節點（對樹而言是根節點）放入到隊列中。接下來每一次從隊列的頭部取出一個節點，遍歷這個節點以後把從它可以到達的節點（對樹而言是子節點）都一次放入到隊列中，重複這個遍歷過程，直到隊列中的節點所有被遍歷爲止。

（二）二叉搜索樹的後序遍歷序列

例如，輸入數組{5, 7， 6， 9， 11， 10， 8} ，則返回 true。

    在後序遍歷獲得的子序列中，最後一個數字是樹的根節點的值。數組中前面的數字能夠分爲兩部分，第一部分是左子樹節點的值，它們都比根節點的值小；第二部分是右子樹節點的值，它們都比根節點的值大。

//輸入一個序列，判斷其是否爲二叉搜索樹的後序遍歷
#include<iostream>
using namespace std;

bool VerifySequenceOfBST(int sequence[], int length)
{
 if(sequence == NULL || length < 0)
  return false;
 int root = sequence[length - 1];  //後序遍歷的最後一個元素爲根節點的值

 int i = 0;
 for(; i < length - 1; ++i)  //小於根節點的值的爲左子樹
 {
  if(sequence[i] > root)
   break;
 }
 int j = i;
 for(; j < length - 1; ++j )    //大於根節點的值的爲右子樹
 {
  if(sequence[j] < root)
   return false;
 }
 bool Left = true;
 if(i > 0)
  Left = VerifySequenceOfBST(sequence, i);

 bool Right = true;
 if(i < length - 1)
  Right = VerifySequenceOfBST(sequence + i, length - i - 1);
 return(Left && Right);
}

int main()
{
 int sequence1[7] = {7, 4, 6, 9, 11, 10, 8};
 int sequence2[7] = {5, 7, 6, 9, 11, 10, 8};

 cout << VerifySequenceOfBST(sequence1, 7) << endl;
 cout << VerifySequenceOfBST(sequence2, 7) << endl;

 system("pause"); return 0;}