二叉树转换为双向链表

二叉树转换为双向链表

通过随机创建二叉排序树测试二叉树转换为双向链表是否正确

import java.util.Random;

/*
 * shsheng
 */
public class BinTreeToDoubleLinkedList {
    public static void main(String[] args) {
        try {
            testBinTreeToDoubleLinkedList(100, 100);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    static class Node {
        int value;
        Node left;
        Node right;

        public Node(int val) {
            value = val;
            left = null;
            right = null;
        }
    }

    // 递归求解，先递归求出左子树的双向链表，再递归求出右子树的双向链表，
    // 最后将左右子树递归求解的双向链表和当前节点合并成一个最终的双向链表。
    public static Node binTreeToDoubleLinkedList(Node tree) {
        if (tree == null)
            return null;
        Node leftTree = binTreeToDoubleLinkedList(tree.left);
        Node rightTree = binTreeToDoubleLinkedList(tree.right);
        if (leftTree != null) {
            leftTree.left.right = tree;
            tree.left = leftTree.left;
            leftTree.left = tree;
            tree.right = leftTree;
            tree = leftTree;
        } else {
            tree.left = tree;
            tree.right = tree;
        }
        if (rightTree != null) {
            tree.left.right = rightTree;
            tree.left = rightTree.left;
            rightTree.left.right = tree;
            rightTree.left = tree.left;
        }
        return tree;
    }

    // 根据二维数组创建二叉排序树
    // 当前节点的值如果大于等于插入数值，则插入左子树，否则插入到右子树，
    // 只有待比较的左右子树为空时才可以插入该节点，否则继续寻找。
    public static Node createBinSortedTree(int[] array) {
        if (array == null || array.length == 0)
            return null;
        Node tree = new Node(array[0]);
        for (int i = 1; i < array.length; i++) {
            Node node = tree;
            Node parent = null;
            while (node != null) {
                parent = node;
                if (node.value >= array[i]) {
                    node = node.left;
                } else {
                    node = node.right;
                }
            }
            if (parent.value >= array[i]) {
                parent.left = new Node(array[i]);
            } else {
                parent.right = new Node(array[i]);
            }
        }
        return tree;
    }

    public static void visit(Node node) {
        System.out.print(node.value + " ");
    }

    public static void testBinTreeToDoubleLinkedList(int n, int size)
            throws Exception {
        Random random = new Random();
        int[] array;
        for (int i = 0; i < n; i++) {
            System.out.println("Num\t" + i);
            int length = random.nextInt(size);
            array = new int[length];
            for (int j = 0; j < length; j++)
                array[j] = random.nextInt(100);
            Node tree = createBinSortedTree(array);
            Node doubleLinkedList = binTreeToDoubleLinkedList(tree);
            Node node = doubleLinkedList;
            if (node == null)
                continue;
            int tmp = Integer.MIN_VALUE;
            int index = 0;
            do {
                index++;
                visit(node);
                if (node.value < tmp) {
                    throw new Exception("Array not increased!");
                }
                tmp = node.value;
                node = node.right;
            } while (node != doubleLinkedList && index < length + 1);
            System.out.println();
        }
    }

}

下载地址：

http://download.csdn.net/detail/ssuchange/6731171