需要必知必会，倒背如流的经典算法和实现

二叉树的遍历算法（递归和迭代）

#include <iostream>
#include <stack>

using namespace std;

template <typename T>
class BinaryTree
{
public:
        BinaryTree(){}
        class TreeNode
        {
        public:
                TreeNode(){ visited = false;}
                TreeNode* left;
                TreeNode* right;
                T value;
                bool visited;
        };
        void Insert(T t);
        void InorderTraverse(TreeNode * begin);
        void PreorderTraverse(TreeNode * begin);
        void PostorderTraverse(TreeNode * begin);
        void InorderTraverse2();
        void PreorderTraverse2();
        void PostorderTraverse2();
private:
        TreeNode *root;
        void Insert(TreeNode* root, T t);

};

template <typename T>
void BinaryTree<T>::InorderTraverse(TreeNode * begin)
{
        if(NULL != begin->left)
                InorderTraverse(begin->left);
        cout<<begin->value;
        if(NULL != begin->right)
                InorderTraverse(begin->right);
}


template <typename T>
void BinaryTree<T>::PreorderTraverse( TreeNode * begin)
{
        cout<<begin->value;
        if(NULL != begin->left)
                PreorderTraverse(begin->left);
        if(NULL != begin->right)
                PreorderTraverse(begin->right);
}

template <typename T>
void BinaryTree<T>::PostorderTraverse(TreeNode * begin)
{
        cout<<begin->value;
        if(NULL != begin->left)
                PostorderTraverse(begin->left);
        if(NULL != begin->right)
                PostorderTraverse(begin->right);
}

template <typename T>
void BinaryTree<T>::InorderTraverse2()
{
        stack<TreeNode *> treestack;
        treestack.push(root);
        TreeNode * tmpNode;
        while(!treestack.empty())
        {
                tmpNode = treestack.top();
                if(NULL == tmpNode->left || tmpNode->left->visited)
                {
                        treestack.pop();
                        tmpNode->visited = true;
                        cout<<tmpNode->value;
                        if(NULL != tmpNode->right)
                        {
                                treestack.push(tmpNode->right);
                        }
                }
                else if(!(tmpNode->left->visited))
                {
                        treestack.push(tmpNode->left);
                }
        }
        cout<<endl;
}


template <typename T>
void BinaryTree<T>::PreorderTraverse2()
{
        stack<TreeNode *> treestack;
        treestack.push(root);
        TreeNode * tmpNode;
        while(!treestack.empty())
        {
                tmpNode = treestack.top();
                treestack.pop();
                cout<<tmpNode->value;
                if(NULL != tmpNode->right)
                        treestack.push(tmpNode->right);
                if(NULL != tmpNode->left )
                {
                        treestack.push(tmpNode->left);
                }
        }
        cout<<endl;
}

template <typename T>
void BinaryTree<T>::PostorderTraverse2()
{
}

template <typename T>
void BinaryTree<T>::Insert(T t)
{
        if(NULL == root)
        {
                root = new TreeNode();
                root->value = t;
        }
        else
        {
                Insert(root,t);
        }
}

template <typename T>
void BinaryTree<T>::Insert(TreeNode *root, T t)
{
        if(t >= root->value)
        {
                if(NULL != root->right)
                        Insert(root->right, t);
                else
                {
                        TreeNode *temp = new TreeNode();
                        temp->value = t;
                        root->right = temp;
                }
        }
        else
        {
                if(NULL != root->left)
                        Insert(root->left, t);
                else
                {
                        TreeNode *temp = new TreeNode();
                        temp->value = t;
                        root->left = temp;
                }
        }
}



int main(int argc, char **argv)
{
        BinaryTree<int> *bitree = new BinaryTree<int> ();
        bitree->Insert(9);
        bitree->Insert(7);
        bitree->Insert(8);
        bitree->Insert(1);
        bitree->Insert(6);
        bitree->Insert(4);
        bitree->Insert(5);
        bitree->Insert(2);
        bitree->Insert(3);
        bitree->Insert(10);
        bitree->Insert(11);
        bitree->InorderTraverse2();
        bitree->PreorderTraverse2();
}

二叉查找

深度优选遍历

DFS需要对每个节点保存一个状态，而这个状态可能是3个值：White(没有发现的)， Gray（被发现，正在遍历的）， Black（以遍历完成的）. 所以DFS需要一个数据空间去存储每个节点的状态。就用2386为例子实现一个吧

 

http://yangjunke111.blog.163.com/blog/static/135279606201041312753102/

广度优先遍历

转载于:https://www.cnblogs.com/whyandinside/archive/2013/02/05/2893078.html