(源码,具体的细节请查阅相关资料)哈弗曼树的构造以及非递归遍历树

 

---

写了一点haffman树的创建和二叉树的非递归遍历.

• 如果编写代码的时候出现了,思维断点,可以借鉴一下, 避免浪费一些不必要的时间.

我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占 位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我 是占位符我是占位符我是占位符我是占位符我是占位符我是 占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符

卧室占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符 我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符 我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符我是占位符

---

　　

package cc.algorithms;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

public class HaffManTree<E> {
    private Node<E> root ;
    public static class Node<E> {
        E data ;
        double weight ;
        Node<E> left, right;
        Node<E> parent ;

        public Node() {
            this.left = this.right = this.parent = null ;
        }
        public Node(E data, double weight) {
            this.data = data ;
            this.weight = weight ;
        }

        @Override
        public String toString() {
            if (data == null) {
                return "[data=null, weight=" + this.weight + "]" ;
            }
            else
                return "[data=" + this.data + ", weight=" + this.weight + "]";
        }
    }

    public static void main(String[] args) {
        List<Node<String>> nodes = new ArrayList<>() ;
        nodes.add(new Node("A", 99)) ;
        nodes.add(new Node("B", 21)) ;
        nodes.add(new Node("C", 211)) ;
        nodes.add(new Node("D", 26)) ;
        nodes.add(new Node("E", 24)) ;
        nodes.add(new Node("F", 23)) ;

        HaffManTree<String> hf = new HaffManTree() ;
        hf.create(nodes) ;
        System.out.println("前序:") ;
        hf.prefByStack(); ;
        System.out.println("中序");
        hf.inByStack() ;
        System.out.println("后序:");
        hf.hostByStack() ;
        System.out.println("层序");
        hf.floorByQueen() ;
    }


    /**
     * 创建haffman树
     */
    public void create(List<Node<E>> nodes) {
        //只要列表中有2个以上的节点
        while(nodes.size() > 1) {
            shellSort(nodes);

            Node<E> min1 = nodes.get(nodes.size() - 1) ;
            Node<E> min2 = nodes.get(nodes.size() - 2) ;

            //生成父节点
            Node<E> parent = new Node(null, min1.weight + min2.weight) ;

            parent.left = min1 ;
            parent.right = min2 ;
            min1.parent = parent;
            min2.parent = parent ;
            //从列表中删除两个最小节点
            nodes.remove(nodes.size() - 1) ;
            nodes.remove(nodes.size() - 1);

            nodes.add(parent) ;
        }
        this.root =  nodes.get(0) ;
    }

    /**
     * 希尔排序--从大到小排序
     */
    public void shellSort(List<Node<E>> nodes) {
        int N = nodes.size() ;
        int h = 1 ;
        while(h < N / 3) h = 3 * h + 1 ;
        while(h >= 1) {
            for(int i = h ; i < N ; ++i) {
                for(int j = i ;
                    j >= h && nodes.get(j).weight > nodes.get(j - h).weight ;
                    j -= h) {
                    Node temp = nodes.get(j) ;
                    nodes.set(j, nodes.get(j - h)) ;
                    nodes.set(j - h, temp) ;
                }
            }
            h /= 3 ;
        }
        for(Node<E> x : nodes) {
            System.out.println(x);
        }
        System.out.println("*********************************") ;
    }
    /**
     * 前序遍历 --------- 递归
     */
    public void pre() {
        System.out.println(this.root) ;
        prefOrder(this.root);
    }
    private void prefOrder(Node<E> node) {
        if(node != null) {
            System.out.println(node) ;
            prefOrder(node.left);
            prefOrder(node.right);
        }
    }
    public void prefByStack() {
        ArrayList<Node<E>> st = new ArrayList<>() ;
        Node<E> p = this.root ;

        while(p != null || !st.isEmpty()) {
            while(p != null) {
                System.out.println(p) ;
                st.add(p) ;
                p = p.left ;
            }
            if(!st.isEmpty()) {
                p = st.remove(st.size() - 1) ;
                p = p.right ;
            }
        }
    }
    public void inByStack() {
        ArrayList<Node<E>> st = new ArrayList<>() ;
        Node<E> p = this.root ;

        while(p != null || !st.isEmpty()) {        //站不空,或者当前节点不空
            while(p != null) {
                st.add(p) ;
                p = p.left ;
            }
            if(!st.isEmpty()) {                //pop,并访问,然后换右子树
                p = st.remove(st.size() - 1) ;
                System.out.println(p) ;
                p = p.right ;
            }
        }
    }
    //需要判断右子树是否访问过
    public void hostByStack() {
        ArrayList<Node<E>> st = new ArrayList<>() ;
        Node<E> p = this.root ;
        Node<E> pre = null ;

        while(p != null || !st.isEmpty()) {
            while(p != null) {
                st.add(p) ;
                p = p.left ;
            }
            if(!st.isEmpty()) {
                //查看栈顶元素,判断右子树是否访问过<br>
                //访问过,就访问当前节点<br>
                //否则,访问右子树
                p = st.get(st.size() - 1) ;
                if(p.right == null || p.right == pre) {
                    p = st.remove(st.size() - 1) ;
                    System.out.println(p) ;
                    //更新
                    pre = p ;
                    p = null ;
                } else {
                    p = p.right ;
                }
            }
        }
    }

    /**
     * 总结:
     *  1.前序,第一次碰到节点的时候访问<br>
     *  2.中序,第二次碰到节点的时候访问,<br>
     *  3.后序,第三次碰到节点的时候访问<br>
     */


    //层次遍历---即广度优先遍历
    public void floorByQueen() {
        LinkedList<Node<E>> queue = new LinkedList<>() ;
        Node<E> p = this.root ;
        //将根入队
        if(p != null) {
            queue.addLast(p); ;
            while(!queue.isEmpty()) {
                p = queue.removeFirst() ;
                System.out.println(p) ;
                //将左右子树加入队列中
                if(p.left != null) {
                    queue.addLast(p.left);
                }
                if(p.right != null) {
                    queue.addLast(p.right) ;
                }
            }
        }
    }
}

---