1.把二元查找树转变成排序的双向链表

转载请注明出处：http://www.cnblogs.com/wuzetiandaren/p/4256355.html 

声明：现大部分文章为寻找问题时在网上相互转载，此博是为自己做个记录记录，方便自己也方便有类似问题的朋友，本文的思想也许有所借鉴，但源码均为本人实现，如有侵权，请发邮件表明文章和原出处地址，我一定在文章中注明。谢谢。

题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。要求不能创建任何新的结点，只调整指针的指向。

题目分析：
　　1.二叉树的节点有左右孩子指针，而双向链表的节点有前驱和后继指针。

　　树节点的数据结构：

    //创建一个树节点类
    class Node {
        public int data;
        public Node left;  //指向左孩子的指针    
        public Node right;  //指向右孩子的指针    
        public Node() {
            super();
        }
        public Node(int data, Node left, Node right) {
            super();
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }

　　2.二叉排序树的中序遍历 结果刚好是升序的，改造时按照中序遍历的顺序重新改变节点的指针就行了，使其 左孩子指向前驱，右孩子指向后继。

java实现源码：

package com.interview;

import java.util.LinkedList;

/**
 * 题目：输入一棵二元查找树，将该二元查找树转换成一个排序的双向链表。
 *     要求不能创建任何新的结点，只调整指针的指向。
 * 分析：二叉树的节点有左右孩子指针，而双向链表有前驱和后继，二叉排序树的中序遍历
 * 是升序的结果，改造时按照中序遍历的顺序重新改变节点的指针就行了，使其
 * 左孩子指向前驱，有孩子指向后继
 * @author wjh
 *
 */
public class _1TreeToDList {

    /**
     * @param args
     */
    public static void main(String[] args) {
        _1TreeToDList builder= new _1TreeToDList();
        int[] a = {56,45,47,67,35,76,22,89,91,27,11,21,19,87};
        Node tree = null;    
        LinkedList<Node> nodelist = new LinkedList<Node>();  //保存二叉树的中序遍历结果
        tree = builder.buildTree(tree, a);   //1)建二叉排序树    
        System.out.println("
二叉排序树的中序遍历结果：");
        nodelist = builder.inOrder(tree,nodelist);//2)得到二叉树的中序遍历结果
        Node first = builder.translate(nodelist); //3)将二叉排序树转换成双链表
        builder.printList(first);    //4)打印双链表
    }
    
    //将二叉排序树改造为双向排序链表,左孩子指针指向前去，右孩子指针指向后继
    private Node translate(LinkedList<Node> nodelist){
        int size = nodelist.size();
        if(size==0){
            return null;
        }
        Node first = nodelist.get(0);  //链表的第一个节点，也是链表的入口
        if(size==1){         //只有一个节点的双链表
            first.left = null;   //因为是双链表而非双循环链表,不能first.left=first;
            first.right = null;
        }
        else if(size>1){     //有两个及以上节点的双链表
            first.left = null;
            first.right = nodelist.get(1);
            for(int i=1;i<size-1;i++){
                nodelist.get(i).left = nodelist.get(i-1);
                nodelist.get(i).right = nodelist.get(i+1);
            }
            nodelist.get(size-1).left = nodelist.get(size-2);
            nodelist.get(size-1).right = null;
        }
        return first;
    }
    
    //打印双链表
    private void printList(Node first){
        Node temp = first;   //temp 保存最后一个节点,以方便逆序打印
        System.out.println("

这是正向打印双链表：");
        while(first!=null){
            if(first.right!=null){
                System.out.print(first.data+"<->");
            }
            else{
                System.out.print(first.data);
                temp = first;   //最后一个节点
            }
            first = first.right;
        }
        first = temp;
        System.out.println("

这是逆向打印双链表：");
        while(first!=null){
            if(first.left!=null){
                System.out.print(first.data+"<->");
            }
            else
                System.out.print(first.data);
            first = first.left;
        }
    }
    
    //二叉树的中序遍历
    private LinkedList<Node> inOrder(Node root,LinkedList<Node> nodelist){
        Node temp = root;
        if(root==null){
            return null;            
        }
        else{
            inOrder(root.left,nodelist);
            System.out.print(root.data+" ");
            nodelist.add(root);
            inOrder(root.right,nodelist);
        }
        return nodelist;
    }
    
    //建树
    private Node buildTree(Node root, int[] data) {
        System.out.println("建树过程(a<--b表示想a的左边插入b;a-->b表示想a的右边插入b):");
        for (int i = 0; i < data.length; i++) {
        root=insert(root, data[i]);
        }
        return root;
     }
                
    //一次插入节点
    private Node insert(Node node, int data) {
        if (node == null) {
            node = new Node(data,null,null);
            System.out.println(node.data);
         }else{ 
            if(data <= node.data) {
                System.out.print(node.data+"<--");
                node.left = insert(node.left, data);
             } else {
                System.out.print(node.data+"-->");
                node.right = insert(node.right, data);
             }
         }
         return node;
    }
    
    //创建一个树节点类
    class Node<E> {
        public int data;
        public Node left;  //指向左孩子的指针    
        public Node right;  //指向右孩子的指针    
        public Node() {
            super();
        }
        public Node(int data, Node left, Node right) {
            super();
            this.data = data;
            this.left = left;
            this.right = right;
        }
    }
}

运行结果：

建树过程(a<--b表示想a的左边插入b;a-->b表示想a的右边插入b):
56
56<--45
56<--45-->47
56-->67
56<--45<--35
56-->67-->76
56<--45<--35<--22
56-->67-->76-->89
56-->67-->76-->89-->91
56<--45<--35<--22-->27
56<--45<--35<--22<--11
56<--45<--35<--22<--11-->21
56<--45<--35<--22<--11-->21<--19
56-->67-->76-->89<--87

二叉排序树的中序遍历结果：
11 19 21 22 27 35 45 47 56 67 76 87 89 91

这是正向打印双链表：
11<->19<->21<->22<->27<->35<->45<->47<->56<->67<->76<->87<->89<->91

这是逆向打印双链表：
91<->89<->87<->76<->67<->56<->47<->45<->35<->27<->22<->21<->19<->11