微软算法100题01 二叉搜索树转为双向链表

提高编程能力的最佳途径就是多写代码, 就让我们从现在开始吧!

1. 输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
       10
      /    |
   6     14
 /   |     /  |
4   8   12  16
 转换成双向链表
4=6=8=10=12=14=16。

二叉查找树的特点：任意节点的左子树都要小于当前节点；右子树都要大于当前节点。
特点：查询某个值，需要的时间复杂度为O(lgN)

网上的解决方案大部分都是C的, 我给出一个JAVA的吧

我的思路:  如果要把一颗二叉树转换为已排序的双向链表，则在双向链表中，根节点的左子树必然在根节点的前面，根节点的右子树必然在根节点的后面，根节点的直接前缀节点必然为左子树中最大的节点，根节点的直接后缀节点必然为右子树中最小的节点，

1. 找到根节点的左子树，找到其最大节点，作为根节点的前缀节点

2. 找到根节点的右子树，找到其最小节点，作为根节点的后缀节点

3.如果左子树不是叶子节点，则用1和2 的逻辑递归处理该左子树

4.如果右子树不是叶子节点，则用1和2 的逻辑递归处理该右子树

package com.rui.microsoft;

/**
 * 
 * 
 * 把二元查找树转变成排序的双向链表
题目：
输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
要求不能创建任何新的结点，只调整指针的指向。
10
/ 
5  15
/  / 
3 6 13 16
转换成双向链表
3=5=6=10=13=15=16
 */
public class Test01 {

    public static void main(String[] args) {
        Test01 test = new Test01();
        Node root = test.initTree();
        Node head = test.convertToDoubleLink(root);
        while(null != head){
            System.out.print(" " + head.getValue());
            head = head.getRight();
        }
    }
    
    private boolean isLeaf(Node node){
        if(null == node.getLeft() && null == node.getRight()) return true;
        else return false;
    }
    
    private Node findMin(Node node){
        if(null == node) return null;
        if(null == node.getLeft()) return node;
        return findMin(node.getLeft());
    }
    
    private Node findMax(Node node){
        if(null == node) return null;
        if(null == node.getRight()) return node;
        return findMin(node.getRight());
    }
    
    public Node convertToDoubleLink(Node node){
        if(null == node) return null;
        
        Node head = findMin(node);
        
        //Find the node directly before current node in the double link
        Node leftNode = findMax(node.getLeft());
        
        //Find the node directly after current node in the double link
        Node rightNode = findMin(node.getRight());
        
        //Process left
        if(null != node.getLeft()){
            processLeftTree(node.getLeft(), node);
        }
        
        //Process right
        if(null != node.getRight()){
            processRightTree(node.getRight(), node);
        }
        
        //Relocate leftNode according to double link to the left side of current node
        if(null != leftNode){
            leftNode.setRight(node);
            node.setLeft(leftNode);
        }
        
        //Relocate rightNode according to double link to the right side of current node
        if(null != rightNode){
            rightNode.setLeft(node);
            node.setRight(rightNode);
        }
        
        return head;
    }

    private void processRightTree(Node right, Node node) {
        if(isLeaf(right)){
            right.setLeft(node);
            return;
        }
        convertToDoubleLink(right);
    }

    private void processLeftTree(Node left, Node node) {
        if(isLeaf(left)){
            left.setRight(node);
            return;
        }
        convertToDoubleLink(left);
    }
    
    private Node initTree(){
        Node root = new Node();
        root.setValue(10);
        
        Node node01 = new Node();
        node01.setValue(5);
        
        Node node011 = new Node();
        node011.setValue(3);
        
        Node node012 = new Node();
        node012.setValue(6);
        
        node01.setLeft(node011);
        node01.setRight(node012);
        
        root.setLeft(node01);

        Node node02 = new Node();
        node02.setValue(15);
        
        Node node021 = new Node();
        node021.setValue(13);
        
        Node node022 = new Node();
        node022.setValue(16);
        
        node02.setLeft(node021);
        node02.setRight(node022);
        
        root.setRight(node02);
        return root;
    }
    
    
    class Node {
        
        private int value;
        private Node left;
        private Node right;
        
        /**
         * @return the value
         */
        public int getValue() {
            return value;
        }
        /**
         * @param value the value to set
         */
        public void setValue(int value) {
            this.value = value;
        }
        /**
         * @return the left
         */
        public Node getLeft() {
            return left;
        }
        /**
         * @param left the left to set
         */
        public void setLeft(Node left) {
            this.left = left;
        }
        /**
         * @return the right
         */
        public Node getRight() {
            return right;
        }
        /**
         * @param right the right to set
         */
        public void setRight(Node right) {
            this.right = right;
        }
    }
}