二叉树常见问题

二叉树的常见问题有如下几个，如果解决好了，就跟链表一样轻松：唯一不一样的是，二叉树是非线性结构。常见的问题如下：
二叉树的问题
1.二叉树三种周游（traversal）方式：
2.怎样从顶部开始逐层打印二叉树结点数据
3.如何判断一棵二叉树是否是平衡二叉树
4.设计一个算法，找出二叉树上任意两个节点的最近共同父结点，复杂度如果是O(n2)则不得分。
5.如何不用递归实现二叉树的前序/后序/中序遍历？
6.在二叉树中找出和为某一值的所有路径（注意是到叶子节点）
7.怎样编写一个程序，把一个有序整数数组放到二叉树中？
8.判断整数序列是不是二叉搜索树的后序遍历结果
9.求二叉树的镜像
10.一棵排序二叉树（即二叉搜索树BST），令 f=(最大值+最小值)/2，设计一个算法，找出距离f值最近、大于f值的结点。复杂度如果是O(n2)则不得分。
11.把二叉搜索树转变成排序的双向链表
12.打印二叉树中的所有路径（与题目6很相似）
解决思路：
1.二叉树三种周游（traversal）方式：任何一本数据结构的书都有描述，略过；
2.怎样从顶部开始逐层打印二叉树结点数据？
设置一个队列，然后只要队列不为空，将对首元素的左右孩子加入队列（如果左右孩子不为空），然后将队列的首元素出对即可，如下图所示：
二叉树如下图所示：

那么，整个过程如下：

自然，就输出了a,b,c,d,e,f
3.如何判断一个二叉树是否是平衡的？
太简单了，利用递归就可以了：判断根节点的左右子树深度之差是否小于等于1(这里需要用到求深度的方法)，如果是，根节点就是平衡的；然后，在判断根节点的左孩子和右孩子是否是平衡的。如此继续下去，直到遇见叶子节点。一旦不是，立刻返回false;
计一个算法，找出二叉树上任意两个节点的最近共同父结点，复杂度如果是O(n2)则不得分
首先找到这两个点key1和key2，并且记录下找到这两个点的路径Path1和Path2。然后，找到第一个点k满足，key1

//问题2：怎样从顶部开始逐层打印二叉树结点数据  
void PrintAtLevel(BiTNode* root){  
    vector<BiTNode*> vector;  
    vector.push_back(root);  
    while(!vector.empty()){  
        BiTNode* tmp = vector.front();  
        if(tmp->lchild != NULL)  
            vector.push_back(tmp->lchild);  
        if (tmp->rchild != NULL)  
            vector.push_back(tmp->rchild);  
        cout << tmp->data << endl;  
        vector.pop_back();  
    }  
}  
//问题3：如何判断一棵二叉树是否是平衡二叉树  
int isBalencedTree(treeNode* root){  
    if (root == NULL)  
        return 0;  
    int depth1 = getDepth(root->lchild);  
    int depth2 = getDepth(root->rchild);  
    if (depth1 == depth2 || depth1 == depth2 + 1 || depth1 == depth2 - 1)  
        return 1;  
    else  
        return 0;  
    int flag1 = isBalencedTree(root->lchild);  
    int flag2 = isBalencedTree(root->rchild);  
    if (flag1 && flag2)  
        return 1;  
    else  
        return 0;  
}  
//问题4：设计一个算法，找出二叉树上任意两个节点的最近共同父结点，复杂度如果是O(n2)  

则不得分。  
int getPublicAncestors(treeNode* root,int key1,int key2){  
    treeNode* ptr = root;  
    int path1[1000];  
    int pathLen1 = 0;  
    while (ptr != NULL){  
        if (key1 == ptr->data){  
            path1[pathLen1] = ptr->data;  
            pathLen1 ++;  
            printArray(path1,pathLen1);  
            break;  
        }  
        else  
            if (ptr->data > key1){  
                path1[pathLen1] = ptr->data;  
                pathLen1 ++;  
                ptr = ptr->lchild;  
            }  
            else  
                if (ptr->data < key1){  
                    path1[pathLen1] = ptr->data;  
                    pathLen1 ++;  
                    ptr = ptr->rchild;  
                }  
    }  
    ptr = root;  
        int path2[1000];  
        int pathLen2 = 0;  
        while (ptr != NULL){  
            if (key2 == ptr->data){  
                path2[pathLen2] = ptr->data;  
                pathLen2 ++;  
                printArray(path2,pathLen2);  
                break;  
            }  
            else  
                if (ptr->data > key2){  
                    path2[pathLen2] = ptr->data;  
                    pathLen2 ++;  
                    ptr = ptr->lchild;  
                }  
                else  
                    if (ptr->data < key2){  
                        path2[pathLen2] = ptr->data;  
                        pathLen2 ++;  
                        ptr = ptr->rchild;  
                    }  
        }  
    int i = pathLen1 - 1;  
    //key1和key2有序，  
    if (key2 < key1){  
        key2 = key2^key1;  
        key1 = key2^key1;  
        key2 = key2^key1;  
    }  
    for (; i > 0; i --){  
        if (key1 < path1[i] && path1[i]< key2){  
            int result = path1[i];  
            return result;  
        }  
    }  
}  
//问题6：在二叉树中找出和为某一值的所有路径  
void FindPath(treeNode* root, int path[],int pathLen,int expectedSum, int   

currentSum){  
    if (root == NULL)  
        return;  
    currentSum += root->data;  
    path[pathLen] = root->data;  
    pathLen ++;  
    if (currentSum == expectedSum && root->lchild == NULL && root->rchild ==   

NULL){  
        printArray(path,pathLen);  
    }  
    if (root->lchild != NULL){  
        FindPath(root->lchild,path,pathLen,expectedSum,currentSum);  
    }  
    if (root->rchild != NULL){  
            FindPath(root-  

>rchild,path,pathLen,expectedSum,currentSum);  
        }  
    currentSum -= root->data;  
}  

//问题7：怎样编写一个程序，把一个有序整数数组放到二叉树中？  
void createTreeFromArray(int a[], int begin, int end, treeNode** root){  
    if (begin > end)  
        return;  
    else{  
        *root = (treeNode*) malloc(sizeof(treeNode));  
        int mid = (begin + end) / 2;  
        (*root)->data = a[mid];  
        (*root)->rchild = NULL;  
        (*root)->lchild = NULL;  
        createTreeFromArray(a, begin ,mid - 1, &(*root)->lchild);  
        createTreeFromArray(a, mid + 1 ,end, &(*root)->rchild);  
    }  
}  
//问题8：判断整数序列是不是二叉搜索树的后//序遍历结果  
int isPostTraverse(int a[], int begin ,int end){  
    if(begin >= end)  
        return 1;  
    else{  
        int root = a[end];  
        int lroot;  
        int i;  
        int location = begin;  
        for (i = begin; i < end ; i ++){  
            if(a[i] > root){  
                location = i;  
                lroot = a[i];  
                break;  
            }  
        }  
        for (i = location + 1; i < end; i++){  
            if (a[i] < lroot){  
                return 0;  
            }  
        }  
        int flag1 = isPostTraverse(a,begin,location -1);  
        int flag2 = isPostTraverse(a,location,end - 1);  
        if (flag1 && flag2)  
            return 1;  
        else  
            return 0;  
    }  
}  
//问题9：求二叉树的镜像  
void changeMirror(treeNode** root){  
    if ( *root == NULL)  
        return;  
    else{  
        treeNode* temp = (*root)->lchild;  
        (*root)->lchild = (*root)->rchild;  
        (*root)->rchild = temp;  
        changeMirror(&(*root)->lchild);  
        changeMirror(&(*root)->rchild);  
    }  
}  
//问题10：10.一棵排序二叉树（即二叉搜索树BST），令 f=(最大值+最小值)/2，设计一个算  

//法，找出距离f值最近、大于f值的结点。复杂度如果是O(n2)则不得分。  
int findNearMid(treeNode** root){  
    treeNode* ptr = *root;  
    int min, max;  
    while (ptr != NULL){  
        min = ptr->data;  
        ptr = ptr->lchild;  
    }  
    printf("the min is %d\n",min);  
    ptr = *root;  
    while (ptr != NULL){  
        max = ptr->data;  
        ptr = ptr->rchild;  
    }  
    printf("the max is %d\n",max);  
    int half = (min + max) >> 1;  
    printf("half is %d\n",half);  
    ptr = *root;  
    while (1){  
        if (ptr->data < half){  
            ptr = ptr->rchild;  
        }  
        else  
            if (ptr->data > half){  
                int result = ptr->data;  
                return result;  
            }  
            else  
            {  
                return (ptr->rchild)->data;  
            }  
    }  
}  
//问题12：打印二叉树中的所有路径（与题目5很相似）  
void printPathsRecur(treeNode* node, int path[], int pathLen) {  
    if (node == NULL)  
        return;  
    // append this node to the path array  
    path[pathLen] = node->data;  
    pathLen++;  
    // it's a leaf, so print the path that led to here  
    if (node->lchild == NULL && node->rchild == NULL) {  
        printArray(path, pathLen);  
    } else {  
        // otherwise try both subtrees  
        printPathsRecur(node->lchild, path, pathLen);  
        printPathsRecur(node->rchild, path, pathLen);  
    }  
}  

void printPaths(treeNode* node) {  
    int path[1000];  
    printPathsRecur(node, path, 0);  
}  
//用到的辅助函数：  
/** 
 * 求二叉树的深度 
 */  
int getDepth(tNode root) {  
    if (root == NULL)  
        return 0;  
    else  
        return getDepth(root->lchild) > getLeaf(root->rchild) ? 1 +   

getDepth(  
                root->lchild) : 1 + getDepth(root->rchild);  
    //  {  
    //      int depthLchild = 1 + getDepth(root->lchild);  
    //      int depthRchild = 1 + getDepth(root->rchild);  
    //      return depthLchild > depthRchild ? depthLchild:   

depthRchild;  
    //  }  
}  
/** 
 * 打印数组 
 */  
void printArray(int ints[], int len) {  
    int i;  
    for (i = 0; i < len; i++) {  
        printf("%d ", ints[i]);  
    }  
    printf("\n");  
}