7.12题目总结

目录

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

快排算法实现：注：顺序很重要,必须从右开始走；因为走到左右的碰头处，位置的元素与首元素（选取的基准元素）交换

---

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

第一步：在树A中查找与根节点的值一样的节点，如果发现某一节点的值与树B的头节点值相同，第二步：判断树A中以R为根节点的子树是不是和树B具有相同的结构；使用递归来实现；

    //第一步：在树A中查找与根节点的值一样的节点
    //如果发现某一节点的值与树B的头节点值相同，第二步：
    // 判断树A中以R为根节点的子树是不是和树B具有相同的结构
    public boolean HasSubtree2(Node root1, Node root2) {
        boolean result = false;
        if (root1 != null && root2 != null) {
            if (root1.value == root2.value) {
                result = DoesTree1EqualsTree2(root1, root2);
            }
            if (!result) {
                result = HasSubtree2(root1.left, root2);//不相同，则查找左子树
            }
            if (!result) {
                result = HasSubtree2(root1.right, root2);//不相同，则查找右子树
            }
        }
        return result;
    }

    public boolean DoesTree1EqualsTree2(Node root1, Node root2) {
        if (root2 == null)
            return true;
        if (root1 == null)
            return false;
        if (root1.value != root2.value) {
            return false;
        }
        return DoesTree1EqualsTree2(root1.left, root2.left) &&
                DoesTree1EqualsTree2(root1.right, root2.right);
    }

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。

后序遍历 的序列中，最后一个数字是树的根节点 ，数组中前面的数字可以分为两部分：第一部分是左子树节点 的值，都比根节点的值小；第二部分 是右子树 节点的值，都比 根 节点 的值大，后面用递归分别判断前后两部分 是否 符合以上原则

//    输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。
//    如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
    public boolean VerifySquenceOfBST(int[] sequence) {
        if (sequence == null || sequence.length == 0) {
            return false;//边界判断
        }
        if(sequence.length == 1){
            return true;
        }
        return varify(sequence, 0, sequence.length - 1);
    }

    public boolean varify(int[] sequence, int left, int right) {
        int i = left;
        int j = right;
        while (sequence[i] <= sequence[right]) {
            if (i == sequence.length - 1) {
                return true;
            }
            i++;
        }
        while (sequence[j] >= sequence[right]) {
            if (j == 0) {
                return true;
            }
            j--;
        }
        if ((i - j) != 1) {
            return false;
        }

        varify(sequence, left, i - 1);
        varify(sequence, i, right - 1);
        return true;
    }

    public boolean varify1(int[] sequence, int left, int right) {//一样的思想，代码更加简洁一点
        if(left == right){
            return true;
        }
        int i = left;
        while (sequence[i] <= sequence[right]) {
            if (i == sequence.length - 1) {
                return true;
            }
            i++;
        }
        for(;i<right;i++){
            if(sequence[i] <= sequence[right]){
                return false;
            }
        }
        //前面将判别条件全部罗列完成；对右子树及左子树的判断完全符合上述的逻辑；使用递归
        return varify(sequence, left, i - 1) && varify(sequence, i, right - 1);
        //返回左子树的判断（左半数组），右子树的判断（右半数组）
    }

快排算法实现：

先在数组中选择一个数字a，接下来把数组中的数字分为两部分，比所选数字a小的数字移到数组的左边，比所选数字a大的数字移到数组的右边。

注：顺序很重要,必须从右开始走；

因为走到左右的碰头处，位置的元素与首元素（选取的基准元素）交换

//    快速排序算法的实现
    public void QuickSort(int[] array, int left, int right){
        if(array.length == 0 || array == null || right <= left){
            return;
        }
        int temp = array[left];
        int start = left;
        int end = right;
        while (start < end){
            while (array[end] >= temp && start < end){//顺序很重要,必须从右开始走
                end--;
            }
            while (array[start] <= temp && start < end){
                start++;
            }
            if(start < end){
                int a = array[start];
                array[start] = array[end];
                array[end] = a;
            }
        }

        array[left] = array[start];
        array[start] = temp;

        QuickSort(array, left, start-1);
        QuickSort(array, start+1, right);
    }

推荐上述代码，下述代码也可：

    public void quitSort(int[] a, int low, int high){
        if(low >= high){
            return;
        }
        int i = low;
        int j = high;
        int key = a[i];
        while (i<j){
            while (i<j && a[j]>=key) j--;//顺序很重要,必须从右开始走
            a[i] = a[j];
            while (i<j && a[i] <=key) i++;
            a[j] = a[i];
            a[i] = key;
        }
        quitSort(a, low, i-1);//遍历左边数组
        quitSort(a, i+1, high);//遍历右边数组
    }