二叉树基础算法总结

以下考察点借鉴了http://blog.csdn.net/randyjiawenjie/article/details/6772145，解法力求原创，若有错误，望指正。
二叉树的三种遍历（递归）

//前序遍历
void preOrder(TreeNode* root){
    if(root == NULL){return;}
    cout<< root->val << endl;
    preOrder(root ->left);
    preOrder(root->right);
}

//中序遍历
void inOrder(TreeNode* root){
    if(root == NULL) return;
    inOrder(root->left);
    cout<<root->val<<endl;
    inOrder(root->right);
}

//后序遍历
void postOrder(TreeNode* root){
    if(root == NULL) return;
    postOrder(root->left);
    postOrder(root->right);
    cout<<root->val<<endl;
}

从顶部开始逐层打印二叉树结点数据

vector<vector<int> > floorTraversal(TreeNode* root){
    vector<vector<int> > result;
    if(root == NULL) return result;
    stack<TreeNode*> current, next;
    current.push(root);
    while(!current.empty()){
        vector<int> tmp;
        while(!current.empty()){
            TreeNode* node = current.top();
            current.pop();
            tmp.push_back(node->val);
            if(node->right) next.push(node->right);
            if(node->left) next.push(node->left);
        }
        result.push_back(tmp);
        swap(current,next);
    }
    return result;
}

如何判断一棵树是否为二叉平衡树

int length(TreeNode* root){
    if(root == NULL) return 0;
    return max(length(root->left), length(root->right)) + 1;
}
bool IsBalanced_Solution(TreeNode* pRoot) {
    if(pRoot == NULL) return true;
    int lenL = length(pRoot->left);
    int lenR = length(pRoot->right);
    if(abs(lenL-lenR) > 1) return false;
    IsBalanced_Solution(pRoot->left);
    IsBalanced_Solution(pRoot->right**;
}

不用递归实现三种遍历

//前序遍历
vector<int> preOrder(TreeNode* root){
    vector<int> result;
    if(root == NULL) return result;
    stack<TreeNode*> myStack;
    myStack.push(root);
    while(!myStack.empty()){
        TreeNode* tmp = myStack.top();
        myStack.pop();
        result.push_back(tmp->val);
        if(tmp->right) myStack.push(tmp->right);
        if(tmp->left) myStack.push(tmp->left);
    }
    return result;
}

//中序遍历
vector<int> inOrder(TreeNode* root){
    vector<int> result;
    if(root == NULL) return result;
    stack<TreeNode*> myStack;
    TreeNode *tmp = root;
    while(!myStack.empty() || tmp){
        if(tmp){
            myStack.push(tmp);
            tmp = tmp->left;
        }else{
            tmp = myStack.top();
            myStack.pop();
            result.push_back(tmp->val);
            tmp = tmp->right;
        }
    }
    return result;
}

在二叉树中找出和为某一值的所有路径

void allPath(TreeNode* root, int expectNumber, vector<vector<int> >& result, vector<int>& tmp){
    if(root == NULL) return;
    tmp.push_back(root->val);
    if(root->left == NULL && root->right == NULL && expectNumber-root->val == 0){
        result.push_back(tmp);
    }else{
        allPath(root->left, expectNumber - root->val, result, tmp);
        allPath(root->right, expectNumber - root->val, result, tmp);
    }
    tmp.pop_back();
}

vector<vector<int> > FindPath(TreeNode* root, int expectNumber) {
    vector<vector<int> > result;
    if(root == NULL) return result;
    vector<int> tmp;
    allPath(root, expectNumber, result, tmp);
    return result;
}

设计算法，找出二叉树上任意两个节点的最近共同父节点，复杂度小于O（n2）
怎样编写一个程序，把一个有序整数数组放到二叉树中
判断整数序列是不是二叉搜索树的后续遍历结果
求二叉树的镜像

void Mirror(TreeNode *pRoot) {
    if(pRoot == NULL){return;}
    TreeNode* tmp = new TreeNode(0);
    tmp = pRoot->left;
    pRoot->left = pRoot->right;
    pRoot->right = tmp;
    if(pRoot->left != NULL){Mirror(pRoot->left);}
    if(pRoot->right != NULL){Mirror(pRoot->right);}
}

一棵排序二叉树（即二叉搜索树），令f=（最大值+最小值）/2，设计一个算法，找出离f值最近、大于f值得结点，复杂度小于O(n2)
判断二叉树是否对称

TreeNode* Mirror(TreeNode* pRoot){
    if(pRoot == NULL) return NULL;
    TreeNode* root = new TreeNode(pRoot->val);
    root->left = Mirror(pRoot->right);
    root->right = Mirror(pRoot->left);
    return root;
}
bool isSame(TreeNode* pRoot, TreeNode* mirror){
    if(pRoot == NULL && mirror == NULL) return true;
    if(pRoot != NULL && mirror != NULL){
        if(pRoot->val == mirror->val){
            return isSame(pRoot->left, mirror->left);
            return isSame(pRoot->right, mirror->right);
        }
        return false;
    }
    return false;
}
bool isSymmetrical(TreeNode* pRoot){
    if(pRoot == NULL || (pRoot->left == NULL && pRoot->right == NULL)) return true;
    TreeNode* mirror = Mirror(pRoot);
    return isSame(pRoot, mirror);
}

把二叉搜索树转变成排序的双向链表

TreeNode* Convert(TreeNode* pRootOfTree)
{
    //中序遍历，left指向前驱，right指向后继
    if(pRootOfTree == NULL) return NULL;
    TreeNode* linkNode = new TreeNode(0);
    TreeNode* lastNode = linkNode;
    stack<TreeNode*> myStack;
    TreeNode* tmp = pRootOfTree;
    while(!myStack.empty() || tmp != NULL){
        if(tmp){
            myStack.push(tmp);
            tmp = tmp->left;
        }else{
            tmp = myStack.top();
            myStack.pop();
            tmp->left = lastNode;
            lastNode->right = tmp;
            lastNode = tmp;
            tmp = tmp->right;
        }
    }
    linkNode = linkNode->right;
    linkNode->left = NULL;
    return linkNode;
}

打印二叉树中的所有路径

void print(vector<int>& myVector){
    for(int i = 0; i < myVector.size(); ++i){
        cout<<myVector[i]<<" ";
    }
    cout<<endl;
}
void allPath(TreeNode* root, vector<int>& myVector){
    if(root == NULL) return;
    myVector.push_back(root->val);
    if(root->left == NULL && root->right == NULL){
        print(myVector);
        myVector.resize(myVector.size()-1);
    }else{
        allPath(root->left, myVector);
        allPath(root->right, myVector);
    }
}