（一）从上往下打印出二叉树的每个节点，同一层的节点按照从左到右的顺序打印。【层次遍历】

从上到下打印二叉树的规律：每一次打印一个节点的时候，如果该节点有子节点，则把该节点的子节点放到一个队列的末尾。接下来到队列的头部取出最早进入队列的节点，重复前面的操作，直至队列中所有的节点都被打印出来为止。

//二叉树的层次遍历
#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 = http://www.mamicode.com/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;
}

二叉树的层次遍历（队列） and 二叉搜索树的后序遍历序列