编码技巧之数据结构【笔记】

编码技巧之数据结构【笔记】

数据结构回顾

列表中的数组，链表，队列，栈

树中的二叉树，搜索树，堆/优先队列

图中的无向图，有向图，有向无环图

图的算法中的深度优先遍历，广度优先遍历，拓扑排序和最短路径/最小生成树

树的遍历

二叉树的遍历方法：

前序遍历

先遍历树根，然后前序遍历左子树，然后再前序遍历右子树

中序遍历

先中序遍历左子树，然后遍历树根，然后再中序遍历右子树

后序遍历

先后序遍历左子树，然后后序遍历右子树，然后遍历树根

层次遍历

一层一层的遍历下去，自左向右，自上而下

树的基础代码：

package interview.tree;

public class TreeNode {
private final char value;
private TreeNode left;
private TreeNode right;
private TreeNode parent;

public TreeNode(char value) {
this.value = value;
this.left = null;
this.right = null;
this.parent = null;
}

public char getValue() {
return value;
}

public TreeNode getLeft() {
return left;
}

public void setLeft(TreeNode left) {
this.left = left;
if (this.left != null) {
this.left.setParent(this);
}
}

public TreeNode getRight() {
return right;
}

public void setRight(TreeNode right) {
this.right = right;
if (this.right != null) {
this.right.setParent(this);
}
}

public TreeNode getParent() {
return parent;
}

private void setParent(TreeNode parent) {
this.parent = parent;
}
}

例题一：根据前序中序构造二叉树

我们可以发现左子树前序为BDEG，左子树中序为DBGE

具体代码如下：

package interview.tree;

public class TreeCreator {
public TreeNode createSampleTree() {
TreeNode root = new TreeNode('A');
root.setLeft(new TreeNode('B'));
root.getLeft().setLeft(new TreeNode('D'));
root.getLeft().setRight(new TreeNode('E'));
root.getLeft().getRight().setLeft(new TreeNode('G'));
root.setRight(new TreeNode('C'));
root.getRight().setRight(new TreeNode('F'));
return root;
}

public TreeNode createTree(String preOrder, String inOrder) {
if (preOrder.isEmpty()) {
return null;
}

char rootValue = preOrder.charAt(0);
int rootIndex = inOrder.indexOf(rootValue);

TreeNode root = new TreeNode(rootValue);
root.setLeft(
createTree(
preOrder.substring(1, 1 + rootIndex),
inOrder.substring(0, rootIndex)));
root.setRight(
createTree(
preOrder.substring(1 + rootIndex),
inOrder.substring(1 + rootIndex)));

return root;
}
}

TreeTraversal.java

package interview.tree;

public class TreeTraversal {

public void preOrder(TreeNode root) {
if (root == null) {
return;
}
System.out.print(root.getValue());
preOrder(root.getLeft());
preOrder(root.getRight());
}

public void inOrder(TreeNode root) {
if (root == null) {
return;
}
inOrder(root.getLeft());
System.out.print(root.getValue());
inOrder(root.getRight());
}

public void postOrder(TreeNode root) {
if (root == null) {
return;
}
postOrder(root.getLeft());
postOrder(root.getRight());
System.out.print(root.getValue());
}

public String postOrder(String preOrder, String inOrder) {
if (preOrder.isEmpty()) {
return "";
}

char rootValue = preOrder.charAt(0);
int rootIndex = inOrder.indexOf(rootValue);

return
postOrder(
preOrder.substring(1, 1 + rootIndex),
inOrder.substring(0, rootIndex)) +
postOrder(
preOrder.substring(1 + rootIndex),
inOrder.substring(1 + rootIndex)) +
rootValue;
}

public static void main(String[] args) {
TreeCreator creator = new TreeCreator();
TreeTraversal traversal = new TreeTraversal();

System.out.println("Sample tree traversal");
System.out.println("=====");
TreeNode sampleTree = creator.createSampleTree();
traversal.preOrder(sampleTree);
System.out.println();
traversal.inOrder(sampleTree);
System.out.println();
traversal.postOrder(sampleTree);
System.out.println();

System.out.println("=");
System.out.println("Creating tree from preOrder and inOrder");
System.out.println("=");
TreeNode tree = creator.createTree("ABDEGCF", "DBGEACF");
traversal.postOrder(tree);
System.out.println();
traversal.postOrder(creator.createTree("", ""));
System.out.println();
traversal.postOrder(creator.createTree("A", "A"));
System.out.println();
traversal.postOrder(creator.createTree("AB", "BA"));
System.out.println();

System.out.println("=");
System.out.println("Generating postOrder directly");
System.out.println("=");
System.out.println(
traversal.postOrder("ABDEGCF", "DBGEACF"));
System.out.println(
traversal.postOrder("", ""));
System.out.println(
traversal.postOrder("A", "A"));
System.out.println(
traversal.postOrder("AB", "BA"));
}
}

总结：

在思考算法的时候，只要减小问题的规模即可

对于初始值的确定，需要严格地根据递归函数的定义

例题二：寻找中序遍历的时候的下一个结点

具体代码如下：

package interview.tree;

public class InOrder {

public TreeNode next(TreeNode node) {
if (node == null) {
return null;
}

if (node.getRight() != null) {
return first(node.getRight());
} else {
while(node.getParent() != null
&& node.getParent().getRight() == node) {
node = node.getParent();
}
// now we have:
// node.getParent() == null
// || node is left child of its parent
return node.getParent();
}
}

public TreeNode first(TreeNode root) {
if (root == null) {
return null;
}

TreeNode curNode = root;
while(curNode.getLeft() != null) {
curNode = curNode.getLeft();
}
return curNode;
}

public void traverse(TreeNode root) {
for (TreeNode node = first(root);
node != null;
node = next(node)) {
System.out.print(node.getValue());
}
System.out.println();
}

public static void main(String[] args) {
TreeCreator creator = new TreeCreator();
InOrder inOrder = new InOrder();

TreeNode sampleTree = creator.createSampleTree();
inOrder.traverse(sampleTree);

inOrder.traverse(creator.createTree("", ""));
inOrder.traverse(creator.createTree("A", "A"));
inOrder.traverse(creator.createTree("AB", "BA"));
inOrder.traverse(creator.createTree("ABCD", "DCBA"));
inOrder.traverse(creator.createTree("ABCD", "ABCD"));
}
}

总结：

需要注意的是分情况讨论

注意null指针

使用private函数来维护复杂数据结构