一种怪异的节点删除方式 & 分别用递归和非递归方式实现二叉树先序、中序和后序遍历

一种怪异的节点删除方式#

题目：一种怪异的节点删除方式

《程序员代码面试指南》第28题 P86 难度：士★☆☆☆

本题不给定头节点，在只给定要删除的节点node的情况下将其删除。

只能采用将后一个节点的值赋给node，然后再将后一个节点删除的方法。

不过该方法有2个问题，一是如果node为最后一个节点则无法删除，二是这种方法本质上根本就不是删除了node节点，实际中可能会遇到各种问题。

因此，本题就不再赘述，详见书P86-87页。

分别用递归和非递归方式实现二叉树先序、中序和后序遍历#

题目：实现二叉树先序，中序和后序遍历

《程序员代码面试指南》第32题 P93 难度：校★★★☆

递归方式很简单，不再赘述，贴上代码：

先序

public void preOrderRecur(Node head) {
    if (head == null) {
        return;
    }
    System.out.print(head.value + " ");
    preOrderRecur(head.left);
    preOrderRecur(head.right);
}

中序

public void inOrderRecur(Node head) {
    if (head == null) {
        return;
    }
    inOrderRecur(head.left);
    System.out.print(head.value + " ");
    inOrderRecur(head.right);
}

后序

public void posOrderRecur(Node head) {
    if (head == null) {
        return;
    }
    posOrderRecur(head.left);
    posOrderRecur(head.right);
    System.out.print(head.value + " ");
}

无非就是打印输出的位置不一样。

接下来介绍非递归方式。非递归方式就是用自己申请的数据结构来代替函数栈。

先序遍历：

申请一个新的栈，记为stack。然后将头节点head压入stack中。
从stack中弹出栈顶节点，记为cur，然后打印cur节点的值。再将节点cur的右孩子节点（不为空的话）先压入stack中，最后将cur的左孩子节点（不为空的话）压入stack中。
不断重复步骤2，直到stack为空，全部过程结束。

具体例子见书P95，代码如下：

public void preOrderUnRecur(Node head) {
    System.out.print("pre-order: ");
    if (head != null) {
        Stack<Node> stack = new Stack<Node>();
        stack.add(head);
        while (!stack.isEmpty()) {
            head = stack.pop();
            System.out.print(head.value + " ");
            if (head.right != null) {
                stack.push(head.right);
            }
            if (head.left != null) {
                stack.push(head.left);
            }
        }
    }
    System.out.println();
}

中序遍历：

申请一个新的栈，记为stack。初始时，令变量cur=head。
先把cur节点压入栈中，对以cur节点为头节点的整棵子树来说，依次把左边界压入栈中，即不停地令cur=cur.next，然后重复步骤2。
不断重复步骤2，直到发现cur为空，此时从stack中弹出一个节点，记为node。并打印node的值，并且让cur=node.right，然后继续重复步骤2。
当stack为空且cur为空时，整个过程停止。

具体例子见书P95-96，代码如下：

public void inOrderUnRecur(Node head) {
    System.out.print("in-order: ");
    if (head != null) {
        Stack<Node> stack = new Stack<Node>();
        while (!stack.isEmpty() || head != null) {
            if (head != null) {
                stack.push(head);
                head = head.left;
            } else {
                head = stack.pop();
                System.out.print(head.value + " ");
                head = head.right;
            }
        }
    }
    System.out.println();
}

后序遍历：

非递归方式实现二叉树后序遍历较为复杂，书上介绍了2种方法。

第一种方法利用了两个栈来实现：

申请一个栈，记为s1，然后将头节点head压入s1中。
从s1中弹出的节点记为cur，然后依次将cur的左孩子节点和右孩子节点压入s1中。
在整个过程中，每一个从s1中弹出的节点都放进s2中。
不断重复步骤2和步骤3，直到s1为空，过程停止。
从s2中依次弹出节点并打印，打印的顺序就是后序遍历的顺序。

通过如上过程我们知道，每棵子树的头节点都是最先从s1中弹出，然后把该节点的孩子节点按照先左再右的顺序压入s1，那么从s1弹出的顺序就是先右再左，所以从s1中弹出的顺序就是中、右、左。然后，s2重新收集的过程就是把s1的弹出顺序逆序，所以s2从栈顶到栈底的顺序就变成了左、右、中。

例如，对于根节点，先将其放入s1，再弹出到s2的同时将其左、右孩子节点分别放入s1。如果左右孩子都为叶子节点，就是上述过程。如果它们也都有孩子，对于左和右孩子节点，再将它们分别看成一个整体，它们分别为2个新的根节点，对于它们的子树，遍历过程也是如此。到最后全部放入s2后，再依次弹出的顺序就是后序遍历的顺序。

代码如下：

public void posOrderUnRecur1(Node head) {
    System.out.print("pos-order: ");
    if (head != null) {
        Stack<Node> s1 = new Stack<Node>();
        Stack<Node> s2 = new Stack<Node>();
        s1.push(head);
        while (!s1.isEmpty()) {
            head = s1.pop();
            s2.push(head);
            if (head.left != null) {
                s1.push(head.left);
            }
            if (head.right != null) {
                s1.push(head.right);
            }
        }
        while (!s2.isEmpty()) {
            System.out.print(s2.pop().value + " ");
        }
    }
    System.out.println();
}

第二种方法只用一个栈来实现，重点在于记录节点的状态。

申请一个栈，记为stack，将头节点压入stack，同时设置两个变量h和c。在整个流程中，h代表最近一个弹出并打印的节点，c代表stack的栈顶节点，初始时h为头节点。
每次令c等于当前stack的栈顶节点，但是不从stack中弹出，此时分以下三种情况：
1. 如果c的左孩子节点不为null，并且h不等于c的左孩子节点，也不等于c的右孩子节点，则把c的左孩子节点压入stack中。（此时说明c的左孩子节点还未放到stack中过，即其左子树还未遍历）
2. 如果条件i不成立，并且c的右孩子节点不为null，h不等于c的右孩子节点，则把c的右孩子节点压入stack中。（此时说明c的左子树已经遍历完成，但其右子树还未遍历）
3. 如果条件i和条件ii都不成立，说明c的左子树和右子树都已经打印完毕，那么从stack中弹出c并打印，然后令h=c。
一直重复步骤2，直到stack为空，过程停止。

具体例子见书P99，代码如下：

public void posOrderUnRecur2(Node h) {
    System.out.print("pos-order: ");
    if (h != null) {
        Stack<Node> stack = new Stack<Node>();
        stack.push(h);
        Node c = null;
        while (!stack.isEmpty()) {
            c = stack.peek();
            if (c.left != null && h != c.left && h != c.right) {
                stack.push(c.left);
            } else if (c.right != null && h != c.right) {
                stack.push(c.right);
            } else {
                System.out.print(stack.pop().value + " ");
                h = c;
            }
        }
    }
    System.out.println();
}