树

树节点

public class Node {
    int data;
    Node left;
    Node right;


    public int getData() {
        return data;
    }


    public void setData(int data) {
        this.data = data;
    }


    public Node getLeft() {
        return left;
    }


    public void setLeft(Node left) {
        this.left = left;
    }


    public Node getRight() {
        return right;
    }


    public void setRight(Node right) {
        this.right = right;
    }
}

树

/**
* 二叉搜索树
*/
public class Binary_Tree {
    Node root;


    public Node getRoot() {
        return root;
    }


    public void setRoot(Node root) {
        this.root = root;
    }
    /*根据插入节点构造二叉树*/
    public void  createTree(List<Integer> dataList){
        System.out.println("创建树开始。。。");
        for( Integer i :dataList){
            insertNode2(i);
        }
        System.out.println("创建树结束。。。");
    }


    /*根据前序遍历和中序遍历构建二叉树*/
    public Node buildTree2(int[]preorder,int begin1,int end1,int[] inorder,int begin2,int end2){
        Node r = new Node();
        r.data= preorder[begin1];




        int RID=0;
        /*在中序辨析的数组中找到根节点的数组下标(这一步可以用HashMap查找出下标，效率大大的提高,见Leetcode 105)*/
        for(int i=begin2;i<=end2;++i){
            if(inorder[i]==r.data){
                RID=i;
                break;
            }
        }
        /*根节点不在中序遍历的第一个表示该根节点有左子树*/
        if(RID!=begin2){
            /*RID-begin2是左子树的个数*/
            r.left = buildTree2(preorder,begin1+1,begin1+RID-begin2,inorder,begin2,RID-1);
        }
        /*根节点不在中序遍历的最后一个表示该根节点有右子树*/
        if(RID!=end2){
            r.right = buildTree2(preorder,begin1+RID-begin2+1,end1,inorder,RID+1,end2);
        }


        return r;
    }


    /*插入节点*/
    public void insertNode(int data){
        Node newNode = new Node();
        newNode.setData(data);


        if (this.root == null){
            this.root = newNode;
        }else {
            Node current = this.root;
            Node parent;
            while (true){
                parent = current;
                if (data<current.getData()){
                    current = current.getLeft();
                    if (current == null){
                        parent.setLeft(newNode);
                        break;
                    }
                }else if (data > current.getData()){
                    current = current.getRight();
                    if (current == null){
                        parent.setRight(newNode);
                        break;
                    }
                }else {
                    /*data与当前节点的值相同*/
                    break;
                }
            }
        }
    }
    public void insertNode2(int data){


        if (this.root==null){
            this.root = new Node();
            this.root.setData(data);
        }else {


              Node newNode = new Node();
              newNode.setData(data);


              Node item = this.root;
              Node parent = null;


              while (item != null){
                  if (item.getData() == data){
                      parent = null;
                      break;
                  }else if (data>item.getData()){
                      parent = item;
                      item = item.getRight();
                  }else {
                      parent = item;
                      item= item.getLeft();
                  }
              }


              /*parent为null表示原来的树里已经存在该节点*/
              if (parent != null){
                  if (data>parent.getData()){
                      parent.setRight(newNode);
                  }else {
                      parent.setLeft(newNode);
                  }
              }
        }
    }


    /*删除节点*/
    public boolean deleteNode(int data){
        if (root ==null){
            return false;
        }
        Node item = root;
        Node parent=null;
        /*要删除的节点是其父节点的左儿子还是右儿子*/
        boolean isLeftChild=true;


        /*找到当前要删除的节点*/
        while (item.getData()!= data){
            parent = item;
            if (data>item.getData()){
                item = item.getRight();
                isLeftChild=false;
            }else{
                item = item.getLeft();
                isLeftChild = true;
            }
            /*删除的值没有找到*/
            if (item==null){
                break;
            }
        }
        /*item为空表示没有找到该节点*/
        if (item==null){
            return false;
        }
        /*第1种情况：要删除的节点左儿子右儿子都为空*/
        if (item.getLeft()==null && item.getRight() ==null){
            if (isLeftChild){
                parent.setLeft(null);
            }else {
                parent.setRight(null);
            }
            /*第2种情况：要删除的节点有1个子节点（右儿子）*/
        }else if (item.getLeft()==null){
            /**/
            if (item ==root){
              root = root.getRight();
            } else if (isLeftChild){
                parent.setLeft(item.getRight());
            }else {
                parent.setRight(item.getRight());
            }
            /*第2种情况：要删除的节点有1个子节点（左儿子*/
        }else if (item.getRight() ==null){
            if (item==root){
                root = root.getLeft();
            }else if (isLeftChild){
                parent.setLeft(item.getLeft());
            }else {
                parent.setRight(item.getLeft());
            }
            /*第3种情况：要删除的节点有两个子节点*/
        }else {


            /*找到要删除节点的中序后继节点*/
            Node Succesor=item.getRight(),SuccesorParent=item;
            while (Succesor.getLeft() != null){
                SuccesorParent =Succesor;
                Succesor = Succesor.getLeft();
            }


            /*将删除节点的值设为后继节点的值*/
            item.setData(Succesor.getData());


            /*如果后继节点是删除节点的右儿子：将后继节点的值赋给删除节点后，删除节点的右儿子设为后继节点的右儿子*/
            if (Succesor == item.getRight()){
                item.setRight(Succesor.getRight());
            }else {
                /*如果后继节点不是删除节点的右儿子：后继节点的父亲节点设置左儿子为后继节点的右儿子*/
                SuccesorParent.setLeft(Succesor.getRight());
            }


        }
        return true;
    }


    /*前序遍历(递归)*/
    public void preorderTravel(Node rootNode){
        if (rootNode != null){
            System.out.println(rootNode.getData());
            preorderTravel(rootNode.getLeft());
            preorderTravel(rootNode.getRight());
        }
    }
    /*前序遍历（推荐：堆栈实现）*/
    public void preorderTravel2(){
        Stack<Node> stack = new Stack<Node>();
        stack.push(root);
        Node item = stack.peek();
        while ( !stack.empty() ){
            System.out.println(item.getData());


            /*记录节点的右儿子*/
            if (item.getRight() != null){
                stack.push(item.getRight());
            }
            if (item.getLeft() != null){
                //只要左儿子不为空就往左走
                item = item.getLeft() ;
            }else {
                // 这时候叶子节点左儿子为空  需要回到栈顶记录的右子树（可能是这个节点的右子树或者这个节点父亲节点的右子树）
                item = stack.peek();
                stack.pop();
            }


        }
    }


    /*中序遍历(递归)*/
    public void inorderTravel(Node rootNode){
        if ( rootNode != null){
            inorderTravel(rootNode.getLeft());
            System.out.println(rootNode.getData());
            inorderTravel(rootNode.getRight());
        }
    }
    /*中序遍历（堆栈实现）*/
    public void inorderTravel2(){
        Stack<Node> stack = new Stack<Node>();
        Node item = this.root;
        while (!stack.empty() || item !=null){


            while (item != null){
                stack.push(item);
                item = item.getLeft();
            }


            if (!stack.empty()){
                item = stack.peek();
                stack.pop();
            }
            System.out.println(item.getData());


            item = item.getRight();


        }




    }


    /*后序遍历(递归)*/
    public void SubsequentTravel(Node rootNode){
        if (rootNode != null){
            SubsequentTravel(rootNode.getLeft());
            SubsequentTravel(rootNode.getRight());
            System.out.println(rootNode.getData());
        }
    }
    /*后序遍历(堆栈)*/
    public void SubsequentTravel2(Node rootNode){
        Stack<Node> stack = new Stack<>();
        Node item = rootNode;


        while (true){
            while (item!=null){
                /*栈中先放右儿子 再放父节点 */
                if (item.right!=null){
                    stack.push(item.right);
                }
                stack.push(item);
                item = item.left;
            }
            item = stack.pop();
            /*弹出栈中最后一个元素，在下面的语句pop可能会异常，所以加上 条件!stack.isEmpty()*/
            if (item.right!=null&&!stack.isEmpty()){
                Node r = stack.pop();
                /*通过判断栈顶元素的右儿子是不是下面的元素从而判断右儿子是否被遍历过*/
                if (item.right == r){
                    /*弹出右儿子后，把父节点放回栈中，item遍历右子树*/
                    stack.push(item);
                    item = r;
                }else {
                    /*栈顶元素的右儿子不在栈中（即栈顶元素的右儿子不是栈顶第二个元素），则可以访问该节点前放回第二个元元素*/
                    /*访问完元素 item置为null 避免进入while循环再将左儿子加入栈，即避免循环while（item）*/
                    stack.push(r);
                    System.out.println(item.data);
                    item = null;
                }


            }else {
                /*栈顶元素右儿子为空则直接访问*/
                System.out.println(item.data);
                item = null;
            }
            if (stack.isEmpty()){
                break;
            }
        }
    }


    /*层次遍历*/
    public void LevelTraversal(){
        System.out.println("层次遍历树开始。。。");
        if (root == null){
            System.out.println("二叉树为空");
        }else {
            Queue<Node> queue = new LinkedList<>();
            queue.add(root);
            while (!queue.isEmpty()){
                /*1、获取当前队列的队首元素*/
                Node item = queue.element();
                System.out.println(item.getData());


                /*2、先判断当前节点的左子树是否为空，不为空则加入队列；然后再判断右节点*/
                if (item.getLeft() != null){
                    queue.add(item.getLeft());
                }
                if (item.getRight() != null){
                    queue.add(item.getRight());
                }
                /*3、从队列中移出当前访问完的节点*/
                queue.remove();
            }
        }
        System.out.println("层次遍历结束。。。");


    }


    /*求树的高度（递归实现）*/
    public int getHeight(Node rootNode){
        if (rootNode == null){
            return 0;
        }
        int leftHeight = getHeight(rootNode.getLeft());
        int rightHeight = getHeight(rootNode.getRight());


        return Math.max(leftHeight,rightHeight)+1;
    }


    /*求树的高度（层次遍历用队列实现）*/
    public int getHeight2(){
        if (root ==null){
            return 0;
        }
        Queue<Node> queue = new LinkedList<>();
        queue.add(root);
        int height=1;
        while ( !queue.isEmpty()){
            Node item = queue.peek();
            if (item.getLeft()==null && item.getRight()==null){
                queue.poll();
            }else {
                if (item.getLeft() != null){
                    queue.add(item.getLeft());
                }
                if (item.getRight() != null){
                    queue.add(item.getRight());
                }
                height+=1;
                queue.poll();
            }
        }
        return height;
    }


    /*判断是否是二叉树*/
    public boolean isValidBST(Node root) {
        /*将中序遍历结果存进数组然后判断数组是否是增长的*/
        /*LeetCode 98*/
        return false;
    }
}

哈夫曼树节点

public class HuffmanNode implements Comparable<HuffmanNode>{


    int weight;
    char code;


    HuffmanNode left;
    HuffmanNode right;
    HuffmanNode parent; //初始化节点排序时当成链表的next，建立哈夫曼树的时候指向父节点


    public HuffmanNode() {
    }




    public HuffmanNode(int weight, char code) {
        this.weight = weight;
        this.code = code;
    }


    @Override
    public int compareTo(HuffmanNode o) {
        return this.weight-o.weight;
    }
}

哈夫曼树和哈夫曼编码

/**
* 哈夫曼树和哈夫曼编码
*/
public class HuffmanTree {


    int numNode;


    List<HuffmanNode> Nodes = new LinkedList<>();


    HuffmanNode root; //存储哈夫曼树的根节点


    HuffmanNode head; //建立哈夫曼树时需要对哈夫曼节点的权重进行排序，采用链表


    /**
     * 用来向链表中插入节点，parent这时先用来当作链表的next作用
     * 在构造哈夫曼树时parent用来说明当前节点的父节点
     * @param newNode
     */
    public void inserNode(HuffmanNode newNode){
        if (head==null){
            head= newNode;
        }else{
            HuffmanNode item =head;
            HuffmanNode pre = item;
            while(item!=null){
                if (newNode.weight>item.weight){
                    pre = item;
                    item = item.parent;
                }else {
                    break;
                }
            }


            //要插入的节点比表头节点还小（即要插在链表头节点前）
            if (item==head){
                newNode.parent = head;
                head = newNode;
            }else {
                HuffmanNode temp = pre.parent;
                pre.parent = newNode;
                newNode.parent = temp;
            }


        }
    }


    /**
     * 创建哈夫曼树
     * @param charList
     * @param weightList
     */
    public void buildHuffmanTree(List<Character> charList,List<Integer> weightList){


        //初始化 哈夫曼节点，所有节点用在链表里按照权重排序好
        for(int i=0;i<charList.size();++i){
            inserNode(new HuffmanNode(weightList.get(i),charList.get(i)));
        }


        /*System.out.println("初始化排序链表");
        HuffmanNode item = head;
        while(item!=null){
            System.out.println(item.weight);
            item = item.parent;
        }*/


        while(head!=null && head.parent!=null){


            //1、选择当前链表的前两个权重最小的节点，并将表头head后退两步
            HuffmanNode minNode1 = head;
            HuffmanNode minNode2 = head.parent;
            head = head.parent.parent;


            //2、两个最小权重的节点构成新节点
            //'0'表示该节点是两个节点的和节点
            HuffmanNode newNode = new HuffmanNode(minNode1.weight+minNode2.weight,'0');
            newNode.left = minNode1;
            newNode.right = minNode2;


            //3、将两个权重最小的节点从有序链表中摘除，并将parent指向其父节点
            minNode1.parent=newNode;
            minNode2.parent=newNode;
            inserNode(newNode);


        }
        //最后链表中只剩一个就是最后的Huffman树根节点
        root = head;




    }






    public void levelTravel(){
        Queue<HuffmanNode> q = new LinkedList<>();
        q.add(root);
        while(!q.isEmpty()){
            int levelSize = q.size();
            for (int i=0;i<levelSize;++i){
                HuffmanNode item = q.remove();
                if (item.left!=null){
                    q.add(item.left);
                }
                if (item.right!=null){
                    q.add(item.right);
                }
                System.out.print(item.code+"  "+item.weight+"  ");
            }
            System.out.println();
        }
    }


    /**
     * 传入某个哈夫曼节点，输出节点编码
     * @param node
     */
    public void Code(HuffmanNode node){
        System.out.print(node.code+":");
        Stack<Character> s = new Stack<>();
        //向其父节点遍历，判断跟父节点的关系，存储0 1 编码到栈中
        while (node.parent!=null){
            if(node.parent.left==node){
                s.push('0');
            }
            if (node.parent.right==node){
                s.push('1');
            }
            node = node.parent;
        }


        while (!s.isEmpty()){
            System.out.print(s.pop());
        }
        System.out.println();
    }
    public void AllCode(){
        Stack<HuffmanNode> s= new Stack<>();
        s.push(root);
        HuffmanNode item = root;
        while(!s.isEmpty() ){
            if (item.code!='0'){
                Code(item);
            }
            if (item.right!=null){
                s.push(item.right);
            }
            if (item.left!=null){
                item=item.left;
            }else {
                item=s.pop();
            }
        }
    }


    /**
     * 哈夫曼译码
     * @param s  编码内容 例如"1101"
     * @return    译码结果 'e'
     */
    public char Decoding(String s){
        HuffmanNode item = root;
        for(int i=0;i<s.length();++i){
            char c = s.charAt(i);
            if (c=='0'){
                item = item.left;
            }
            if (c=='1'){
                item = item.right;
            }
        }
        return item.code;
    }

}