面试算法代码知识梳理系列
- 插入排序
- 希尔排序
- 选择排序
- 冒泡排序
- 计数排序
- 基数排序
- 归并排序
- 快速排序
- 双向扫描的快速排序
- 堆排序
- 替换字符串中的空格
- 输入一个字符串，打印出该字符串的所有排列
- 第一个只出现一次的字符
- 翻转句子
- 计算字符串之间的最短距离
- 查找字符串中的最长重复子串
- 求长度为
N的字符串的最长回文子串 - 将字符串中的
*移到前部，并且不改变非*的顺序 - 不开辟用于交换的空间，完成字符串的逆序
C++ - 最短摘要生成
- 最长公共子序列
- 二维数组的整数查找
- 旋转数组中的最小数字（旋转数组中的最大数字）
- 调整数组使奇数位于偶数之前
- 找出数组中出现次数超过一半的数字
- 找到最小的
k个数 - 连续子数组的最大和
- 连续子数组的最大和（二维）
- 求数组当中的逆序对
- 在递增排序的数组中，查找指定数字出现的个数
- 查找数组中只出现一次的两个数字
- 在递增排序的数组中，查找和为
s的两个数 - 输入一个正数
s，打印出所有和为s的连续正数序列 - 数组当中的最大最小值
- 求数组当中的最长递增子序列（求数组当中的最长递减子序列）
- 区间重合判断
- 一个整数数组，长度为
n，将其分为m份，使各份的和相等，求m的最大值
- 普通二分查找
- 查找关键字第一次出现的位置
- 查找关键字最后一次出现的位置
- 查找小于关键字的最大数字出现的位置
- 查找大于关键字的最小数字出现的位置
- 新建链表
- 反转链表（递归和非递归实现）
- 获得链表倒数第
k个结点 - 获得链表的中间结点
- 删除链表结点
- 交换链表结点
- 建立二叉查找树
- 删除二叉查找树中指定元素
- 非递归遍历二叉查找树（先序遍历、中序遍历、后序遍历）
- 递归遍历二叉树（先序遍历、中序遍历、后序遍历）
- 分层打印二叉树
- 打印二叉树的第
n层 - 统计二叉树叶结点的个数
- 统计二叉树的高度
- 获得二叉树的镜像
- 判断元素是否存在于二叉树中
- 打印二叉树中和为
s的路径 - 获得二叉树的最大距离
- 判断二叉树是否是平衡树
- 将二叉树转换成为链表
- 判断数组是否为二叉树的后序遍历
- 判断某树是否是另一棵树的子树
- 根据前序和中序序列重建二叉树
一、概述
- 将二叉树转换成为链表
- 判断数组是否为二叉树的后序遍历
- 判断某树是否是另一棵树的子树
- 根据前序和中序序列重建二叉树
二、代码实现
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 知识梳理系列：
- Android 知识梳理目录：http://www.jianshu.com/p/fd82d18994ce
- Android 面试文档分享：http://www.jianshu.com/p/8456fe6b27c4
