面试算法知识梳理(13) - 二叉树算法第三部分

96
泽毛
2017.12.22 22:57* 字数 1540

面试算法代码知识梳理系列

面试算法知识梳理(1) - 排序算法

  • 插入排序
  • 希尔排序
  • 选择排序
  • 冒泡排序
  • 计数排序
  • 基数排序
  • 归并排序
  • 快速排序
  • 双向扫描的快速排序
  • 堆排序

面试算法知识梳理(2) - 字符串算法第一部分

  • 替换字符串中的空格
  • 输入一个字符串,打印出该字符串的所有排列
  • 第一个只出现一次的字符
  • 翻转句子
  • 计算字符串之间的最短距离

面试算法知识梳理(3) - 字符串算法第二部分

  • 查找字符串中的最长重复子串
  • 求长度为N的字符串的最长回文子串
  • 将字符串中的*移到前部,并且不改变非*的顺序
  • 不开辟用于交换的空间,完成字符串的逆序C++
  • 最短摘要生成
  • 最长公共子序列

面试算法知识梳理(4) - 数组第一部分

  • 二维数组的整数查找
  • 旋转数组中的最小数字(旋转数组中的最大数字)
  • 调整数组使奇数位于偶数之前
  • 找出数组中出现次数超过一半的数字

面试算法知识梳理(5) - 数组第二部分

  • 找到最小的k个数
  • 连续子数组的最大和
  • 连续子数组的最大和(二维)
  • 求数组当中的逆序对

面试算法知识梳理(6) - 数组第三部分

  • 在递增排序的数组中,查找指定数字出现的个数
  • 查找数组中只出现一次的两个数字
  • 在递增排序的数组中,查找和为s的两个数
  • 输入一个正数s,打印出所有和为s的连续正数序列
  • 数组当中的最大最小值

面试算法知识梳理(7) - 数组第四部分

  • 求数组当中的最长递增子序列(求数组当中的最长递减子序列)
  • 区间重合判断
  • 一个整数数组,长度为n,将其分为m份,使各份的和相等,求m的最大值

面试算法知识梳理(8) - 二分查找算法及其变型

  • 普通二分查找
  • 查找关键字第一次出现的位置
  • 查找关键字最后一次出现的位置
  • 查找小于关键字的最大数字出现的位置
  • 查找大于关键字的最小数字出现的位置

面试算法知识梳理(9) - 链表算法第一部分

  • 新建链表
  • 反转链表(递归和非递归实现)
  • 获得链表倒数第k个结点
  • 获得链表的中间结点
  • 删除链表结点
  • 交换链表结点

面试算法知识梳理(10) - 二叉查找树

  • 建立二叉查找树
  • 删除二叉查找树中指定元素
  • 非递归遍历二叉查找树(先序遍历、中序遍历、后序遍历)

面试算法知识梳理(11) - 二叉树相关算法第一部分

  • 递归遍历二叉树(先序遍历、中序遍历、后序遍历)
  • 分层打印二叉树
  • 打印二叉树的第n
  • 统计二叉树叶结点的个数
  • 统计二叉树的高度

面试算法知识梳理(12) - 二叉树算法第二部分

  • 获得二叉树的镜像
  • 判断元素是否存在于二叉树中
  • 打印二叉树中和为s的路径
  • 获得二叉树的最大距离
  • 判断二叉树是否是平衡树

面试算法知识梳理(13) - 二叉树算法第三部分

  • 将二叉树转换成为链表
  • 判断数组是否为二叉树的后序遍历
  • 判断某树是否是另一棵树的子树
  • 根据前序和中序序列重建二叉树

一、概述

  • 将二叉树转换成为链表
  • 判断数组是否为二叉树的后序遍历
  • 判断某树是否是另一棵树的子树
  • 根据前序和中序序列重建二叉树

二、代码实现

2.1 将二叉树转换成为链表

解决思路

采用后序遍历的思路,先将左右子树转换成链表,再将左右子树的链表通过中间结点连接起来。

代码实现

public class Untitled {

    static class Tree {
        int size;
        Node root;
    }

    static class Node {
        Node parent;
        Node left;
        Node right;
        int value;
    }

    static class ListValue {
        Node header;
        Node tail;
    }

    static void insertNode(Tree tree, int value) {
        if (tree == null) {
            return;
        }
        Node tNode = tree.root;
        //待插入结点的父结点,如果遍历完为空,说明此时是一个空树。
        Node pNode = null;
        //新的结点。
        Node nNode = new Node();
        nNode.value = value;
        while (tNode != null) {
            pNode = tNode;
            if (tNode.value > value) {
                tNode = tNode.left;
            } else {
                tNode = tNode.right;
            }
        }
        nNode.parent = pNode;
        if (pNode == null) {
            tree.root = nNode;
        } else if (pNode.value > value) {
            pNode.left = nNode;
        } else {
            pNode.right = nNode;
        }
        tree.size++;
    }

    static Tree createBinTree(int p[], int len) {
        Tree tree = new Tree();
        for (int i = 0; i < len; i++) {
            int value = p[i];
            insertNode(tree, value);
        }
        return tree;
    }

    //采用后序遍历的方式转换成链表。
    static ListValue treeToList(Node p) {
        if (p == null) {
            return null;
        }
        ListValue value = new ListValue();
        value.header = p;
        value.tail = p;
        //左子树部分的链表。
        ListValue leftNode = treeToList(p.left);
        //右子树部分的链表。
        ListValue rightNode = treeToList(p.right);
        //左子树部分的尾结点作为p的前驱节点,右子树部分的头结点作为p的后继结点。
        if (leftNode != null) {
            leftNode.tail.right = p;
            p.left = leftNode.tail;
            value.header = leftNode.header;
        }
        if (rightNode != null) {
            rightNode.header.left = p;
            p.right = rightNode.header;
            value.tail = rightNode.tail;
        }
        return value;
    }

    static void printTreeList(ListValue value) {
        Node node = value.tail;
        while (node != null && node.left != null) {
            System.out.println(node.value);
            node = node.left;
        }
    }

    public static void main(String[] args) {
        int p[] = {3, 5, 6, 1, 2, 4, -1, -3};
        Tree tree = createBinTree(p, p.length);
        ListValue value = treeToList(tree.root);
        printTreeList(value);
    }
}

运行结果

6
5
4
3
2
1
-1

2.2 判断数组是否为二叉查找树的后序遍历

问题描述

输入一个整数数组,判断该数组是不是某二叉查找树的后序遍历的结果,假设输入的数组的任意两个数字都互不相同。

解决思路

依据题目的描述我们可以得到关键信息:

  • 这棵树为二叉查找树,因此对于任意结点,它的左子树小于该结点,右子树大于该结点,并且左右子树都是二叉查找树。
  • 如果是后序遍历,那么对于任意子树,它的根结点是该部分数组的最后一个元素。

代码实现

public class Untitled {

    static boolean isPostOrderOfTree(int p[], int startIndex, int endIndex) {
        if (startIndex == endIndex) {
            return true;
        }
        int root = p[endIndex];
        int middle = startIndex;
        //通过根结点将左右子树分开。
        while (p[middle] < root && middle < endIndex) {
            middle++;
        }
        //验证右子树是否都比根结点要大。
        for (int i = middle; i < endIndex; i++) {
            if (!(p[i] > root)) {
                return false;
            }
        }
        //说明该结点没有左子树。
        if (middle == startIndex || middle == endIndex) {
            return isPostOrderOfTree(p, startIndex, endIndex - 1);
        } else {
            //先验证左边的数组是否是后序遍历。
            boolean left = isPostOrderOfTree(p, startIndex, middle - 1);
            if (left) {
                //再验证右边的数组是否是后序遍历。
                return isPostOrderOfTree(p, middle, endIndex - 1);
            } else {
                return false;
            }
        }
    }

    public static void main(String[] args) {
        int p1[] = {5, 7, 6, 9, 11, 10, 8};
        System.out.println("p1 是二叉查找树的后序遍历=" + isPostOrderOfTree(p1, 0, p1.length - 1));
        int p2[] = {7, 10, 8, 9};
        System.out.println("p2 是二叉查找树的后序遍历=" + isPostOrderOfTree(p2, 0, p2.length - 1));
    }
}

运行结果

>> p1 是二叉查找树的后序遍历=true
>> p2 是二叉查找树的后序遍历=false

2.3 判断某树是否是另一棵树的子树

解决思路

先判断父树和子树的根结点是否相等,如果相等,再比较两棵树是否完全相同,如果根结点不相等,那么再递归比较父树的左子树和子树,以及父树的右子树和子树。

代码实现

public class Untitled {

    static class Tree {
        int size;
        Node root;
    }

    static class Node {
        Node parent;
        Node left;
        Node right;
        int value;
    }

    static void insertNode(Tree tree, int value) {
        if (tree == null) {
            return;
        }
        Node tNode = tree.root;
        //待插入结点的父结点,如果遍历完为空,说明此时是一个空树。
        Node pNode = null;
        //新的结点。
        Node nNode = new Node();
        nNode.value = value;
        while (tNode != null) {
            pNode = tNode;
            if (tNode.value > value) {
                tNode = tNode.left;
            } else {
                tNode = tNode.right;
            }
        }
        nNode.parent = pNode;
        if (pNode == null) {
            tree.root = nNode;
        } else if (pNode.value > value) {
            pNode.left = nNode;
        } else {
            pNode.right = nNode;
        }
        tree.size++;
    }

    static Tree createBinTree(int p[], int len) {
        Tree tree = new Tree();
        for (int i = 0; i < len; i++) {
            int value = p[i];
            insertNode(tree, value);
        }
        return tree;
    }

    static boolean isSubTree(Node node, Node subNode) {
        if (node == null || subNode == null) {
            return false;
        }
        boolean result = false;
        if (node.value == subNode.value) {
            //如果结点相等,那么比较树是否相等。
            result = isTreeEquals(node, subNode);
        }
        if (!result && node.left != null) {
            //是否是左子树的子树。
            result = isSubTree(node.left, subNode);
        }
        if (!result && node.right != null) {
            //是否是左子树的子树。
            result = isSubTree(node.right, subNode);
        }
        return result;
    }

    static boolean isTreeEquals(Node node1, Node node2) {
        if (node1 == null && node2 == null) {
            return true;
        }
        if (node1 == null) {
            return false;
        }
        if (node2 == null) {
            return false;
        }
        if (node1.value != node2.value) {
            return false;
        }
        return isTreeEquals(node1.left, node2.left) && isTreeEquals(node1.right, node2.right);
    }

    public static void main(String[] args) {
        int p1[] = {3, 5, 6, 1, 2, 4, -1, -3};
        Tree tree = createBinTree(p1, p1.length);
        int p2[] = {1, 2, -1, -3};
        Tree subTree = createBinTree(p2, p2.length);
        int p3[] = {1, 2, -1, -3, -5};
        Tree subTree2 = createBinTree(p3, p3.length);
        System.out.println("p2 是 p1 的子树=" + isSubTree(tree.root, subTree.root));
        System.out.println("p3 是 p1 的子树=" + isSubTree(tree.root, subTree2.root));
    }
}

运行结果

>> p2 是 p1 的子树=true
>> p3 是 p1 的子树=false

2.4 根据先序遍历和中序遍历重建二叉树

解决思路

根据先序遍历的特点,其第一个元素为树的根结点,然后在中序遍历的结点中找到该根结点,分为左右两个子树部分,递归进行求解。

代码实现

public class Untitled {

    static class Tree {
        int size;
        Node root;
    }

    static class Node {
        Node parent;
        Node left;
        Node right;
        int value;
    }

    static Node createTree(int preOrder[], int preStart, int preEnd, int inOrder[], int inStart, int inEnd) {
        Node node = new Node();
        int root = preOrder[preStart];
        node.value = root;
        //如果只有一个元素,那么直接返回即可。
        if (preStart == preEnd) {
            return node;
        }
        int rootIndex = inStart;
        while (rootIndex < inEnd && inOrder[rootIndex] != root) {
            rootIndex++;
        }
        int leftPreOrderEnd = preStart + (rootIndex - inStart);
        if (rootIndex != inStart) {
            node.left = createTree(preOrder, preStart + 1, leftPreOrderEnd, inOrder, inStart, rootIndex - 1);
        }
        if (rootIndex != inEnd) {
            node.right = createTree(preOrder, leftPreOrderEnd + 1, preEnd, inOrder, rootIndex + 1, inEnd);
        }
        return node;
    }

    static void printPreOrder(Node node) {
        if (node == null) {
            return;
        }
        System.out.println(node.value);
        printPreOrder(node.left);
        printPreOrder(node.right);
    }

    static void printInOrder(Node node) {
        if (node == null) {
            return;
        }
        printInOrder(node.left);
        System.out.println(node.value);
        printInOrder(node.right);
    }

    public static void main(String[] args) {
        int p1[] = {1, 2, 4, 7, 3, 5, 6, 8};
        int p2[] = {4, 7, 2, 1, 5, 3, 8, 6};
        Node root = createTree(p1, 0, p1.length - 1, p2, 0, p2.length - 1);
        System.out.println("- 先序遍历 -");
        printPreOrder(root);
        System.out.println("- 中序遍历 -");
        printInOrder(root);
    }
}

运行结果

- 先序遍历 -
1
2
4
7
3
5
6
8
- 中序遍历 -
4
7
2
1
5
3
8
6

更多文章,欢迎访问我的 Android 知识梳理系列:

面试算法
Web note ad 2