【原创】Java与数据结构(中篇：树)

 1. 二叉树 遍历算法

package tree;

import java.util.ArrayDeque;
import java.util.Queue;

/**
 * 二叉树的四种遍历方式<br>
 * 先序，中序，后序，广度优先遍历
 * 
 * @author yinger
 */
public class IteratorAlgorithm {

    public static void main(String[] args) {
        TreeNode root = new TreeNode("0");
        TreeNode node1 = new TreeNode("1");
        TreeNode node2 = new TreeNode("2");
        root.left = node1;
        root.right = node2;
        TreeNode node3 = new TreeNode("3");
        TreeNode node4 = new TreeNode("4");
        node1.left = node3;
        node1.right = node4;
        TreeNode node5 = new TreeNode("5");
        TreeNode node6 = new TreeNode("6");
        node2.left = node5;
        node2.right = node6;
        TreeNode node7 = new TreeNode("7");
        TreeNode node8 = new TreeNode("8");
        node3.left = node7;
        node4.right = node8;

        System.out.print("PreIterator: ");
        root.preIterator();// PreIterator: 0 1 3 7 4 8 2 5 6
        System.out.println();
        System.out.print("InIterator: ");
        root.inIterator();// InIterator: 7 3 1 4 8 0 5 2 6
        System.out.println();
        System.out.print("PostIterator: ");
        root.postIterator();// PostIterator: 7 3 8 4 1 5 6 2 0
        System.out.println();
        System.out.print("WideIterator: ");
        root.wideIterator();// WideIterator: 0 1 2 3 4 5 6 7 8
    }

}

class TreeNode {
    Object data;
    TreeNode left;
    TreeNode right;

    public TreeNode(Object data) {
        this.data = data;
    }

    // preIterator
    public void preIterator() {
        visit(this);
        if (left != null) {
            left.preIterator();
        }
        if (right != null) {
            right.preIterator();
        }
    }

    // inIterator
    public void inIterator() {
        if (left != null) {
            left.inIterator();
        }
        visit(this);
        if (right != null) {
            right.inIterator();
        }
    }

    // postIterator
    public void postIterator() {
        if (left != null) {
            left.postIterator();
        }
        if (right != null) {
            right.postIterator();
        }
        visit(this);
    }

    // wideIterator
    public void wideIterator() {
        // ArrayDeque:faster than stack (when used as a stack) and linkedlist(when used as a queue)
        Queue<TreeNode> deque = new ArrayDeque<TreeNode>();
        deque.add(this);
        TreeNode node;
        while ((node = deque.poll()) != null) {
            visit(node);
            if (node.left != null) {
                deque.add(node.left);
            }
            if (node.right != null) {
                deque.add(node.right);
            }
        }
    }

    // visit function
    private void visit(TreeNode treeNode) {
        if (treeNode != null) {
            System.out.print(treeNode.data + "  ");
        }
    }

}

2. 哈夫曼树 这次我用的是插入排序，两次删除一次插入，以前用的是和最小堆结合，原理差不多，其实也可以使用快排

package tree;

import java.util.ArrayDeque;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

/**
 * 哈夫曼树
 * 
 * @author yinger
 */
public class HuffmanTree {

    public static void main(String[] args) {
        HuffmanTreeNode root = new HuffmanTreeNode("root", 0.5);
        HuffmanTreeNode node1 = new HuffmanTreeNode("node1", 1.0);
        HuffmanTreeNode node2 = new HuffmanTreeNode("node2", 2.0);
        HuffmanTreeNode node3 = new HuffmanTreeNode("node3", 3.0);
        HuffmanTreeNode node4 = new HuffmanTreeNode("node4", 3.5);
        LinkedList<HuffmanTreeNode> nodes = new LinkedList<HuffmanTreeNode>();
        Collections.addAll(nodes, root, node1, node2, node3, node4);
        HuffmanTree huffmanTree = new HuffmanTree();
        HuffmanTreeNode treeRoot = huffmanTree.createHuffmanTree(nodes);
        treeRoot.wideIterator();
    }

    public HuffmanTreeNode createHuffmanTree(LinkedList<HuffmanTreeNode> nodes) {// create huffmantree
        insertSort(nodes, 0, nodes.size() - 1);// sort nodes using insrt sort
        while (nodes.size() > 1) {
            HuffmanTreeNode left = nodes.pollFirst();// remove the two smallest
            HuffmanTreeNode right = nodes.pollFirst();
            HuffmanTreeNode parent = new HuffmanTreeNode(left.data + "+" + right.data, left.weight + right.weight);
            parent.left = left;
            parent.right = right;
            insertNode(nodes, parent);
        }// end while,nodes.size = 1 --> the root node
        return nodes.peek();
    }

    // insert new node into nodes,and make it sorted!
    private void insertNode(LinkedList<HuffmanTreeNode> nodes, HuffmanTreeNode parent) {
        nodes.addLast(parent);// first add it,make size++,then sort it!
//        System.out.println("Befor: insert new node:");
//        for (HuffmanTreeNode huffmanTreeNode : nodes) {
//            System.out.print(huffmanTreeNode.weight + "  ");
//        }
//        System.out.println();
        int j, low, high, mid, size = nodes.size();
        low = 0;
        high = size - 2;// attention:the last node is not included!
        while (low <= high) {// final position is low
            mid = (low + high) / 2;
            if (nodes.get(mid).weight > parent.weight) {
                high = mid - 1;
            } else {
                low = mid + 1;
            }
        }
        for (j = size - 1; j > low; j--) {// move back some elements
            nodes.set(j, nodes.get(j - 1));
        }
        nodes.set(low, parent);
//        System.out.println("After: insert new node:" + "  low=" + low);
//        for (HuffmanTreeNode huffmanTreeNode : nodes) {
//            System.out.print(huffmanTreeNode.weight + "  ");
//        }
//        System.out.println();
    }

    private void insertSort(List<HuffmanTreeNode> nodes, int start, int end) {// half find insert sort
        int i, j, size = nodes.size();
        int low, high, mid;
        HuffmanTreeNode tempNode;
        for (i = 1; i < size; i++) {// 0 - (i-1) has been sorted,now insert i
            low = 0;
            high = i - 1;
            tempNode = nodes.get(i);
            while (low <= high) {// final right position is low
                mid = (low + high) / 2;
                if (nodes.get(mid).weight > tempNode.weight) {
                    high = mid - 1;
                } else {
                    low = mid + 1;
                }
            }
            for (j = i; j > low; j--) {// move back some elements
                nodes.set(j, nodes.get(j - 1));
            }
            nodes.set(low, tempNode);
        }
//        System.out.println("After insertsort:");
//        for (HuffmanTreeNode huffmanTreeNode : nodes) {
//            System.out.print(huffmanTreeNode.weight + "  ");
//        }
//        System.out.println();
    }

}

class HuffmanTreeNode {

    String data;// define data is string
    double weight;// weight of the node
    HuffmanTreeNode left;
    HuffmanTreeNode right;

    public HuffmanTreeNode(String data, double weight) {
        this.data = data;
        this.weight = weight;
    }

    // wideIterator
    public void wideIterator() {
        // ArrayDeque:faster than stack (when used as a stack) and linkedlist(when used as a queue)
        Queue<HuffmanTreeNode> deque = new ArrayDeque<HuffmanTreeNode>();
        deque.add(this);
        HuffmanTreeNode node;
        while ((node = deque.poll()) != null) {
            visit(node);
            if (node.left != null) {
                deque.add(node.left);
            }
            if (node.right != null) {
                deque.add(node.right);
            }
        }
    }

    // visit function
    private void visit(HuffmanTreeNode node) {
        if (node != null) {
            System.out.println(node.data + "  " + node.weight + "  ");
        }
    }

}

其他数据结构内容请看下篇。 谢谢阅读，如果发现错误，请及时回复我！