数据结构---二叉树

1.计算叶子结点带权路径之和：

package com.company;

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

public class Main {
    static int sumWeight=0;
    public static void main(String[] args) {
        //叶子结点的带权路径长度。
        Node head=new Node(1);
        head.lchild=new Node(2);
        head.rchild=new Node(3);
        head.lchild.lchild=new Node(4);
        head.lchild.lchild.rchild=new Node(5);
        head.rchild.lchild=new Node(6);
        head.rchild.rchild=new Node(7);
        Node p=head;
        int wpl=-1;
        calWeight(p,wpl);
        System.out.println(sumWeight);
    }

    public static void calQueueWeight(Node p){
        Queue<Node> queue=new ArrayDeque<>();
        queue.add(p);
        int deep=-1;
        while(p!=null||!queue.isEmpty()){
            p=queue.poll();
            deep++;
            if(p.lchild==null&&p.rchild==null){
                sumWeight+=p.val*deep;
                deep--;
            }
            if(p.lchild!=null){
                queue.add(p.lchild);
            }
            if(p.rchild!=null){
                queue.add(p.rchild);
            }
        }
    }

    public static void calWeight(Node p,int wpl){
        if(p!=null){
            wpl++;
            if(p.rchild==null&&p.lchild==null){
                sumWeight+=wpl*p.val;
            }
            calWeight(p.lchild,wpl);
            calWeight(p.rchild,wpl);
        }
    }
}

class Node{
    int val;
    Node lchild;
    Node rchild;
    public Node(){
        val=0;
        lchild=null;
        rchild=null;
    }
    public Node(int value){
        this.val=value;
        lchild=null;
        rchild=null;
    }
}

2.建立平衡二叉树（插入）：

切记，java跟我们的C++还是有很多不同的，比如说因为没有指针只有引用，而引用这个东西如果两个都没有事先new一个东西给他们的话，他俩之间的赋值没意义。
举个栗子：
Node T=null;
Node p=T;
p=new Node(10);
此时T仍然哪都没指向，这就是不同，但其实指针好也会这样，除非是malloc

package com.company;


public class Main {
    static Node T=null;
    public static void main(String[] args) {
        /*二叉排序树；
        /*
        if(T==null){
            T=new Node(10);
        }
        System.out.println(T.val);
        */
        int []values={1,3,6,4,8,7,-1,10,-6};
        for(int value:values){
            BSInsert(value);
        }
        MidTravel(T);
    }

    public static void MidTravel(Node p){
        if(p!=null){
            MidTravel(p.lchild);
            System.out.print(p.val+" ");
            MidTravel(p.rchild);
        }
    }

    public static void BSInsert(int value){
        Node p=T;
        Node pre=null;
        while(p!=null){
            pre=p;
            if(p.val>value){
                p=p.lchild;
            }
            else if(p.val<value){
                p=p.rchild;
            }
            else{
                return ;
            }
        }
        if(T==null){
            T=new Node(value);
        }
        else if(pre.val>value){
            pre.lchild=new Node(value);
        }
        else{
            pre.rchild=new Node(value);
        }
    }
}

class Node{
    int val;
    Node lchild;
    Node rchild;
    public Node(){
        val=0;
        lchild=null;
        rchild=null;
    }
    public Node(int value){
        this.val=value;
        lchild=null;
        rchild=null;
    }
}

3.平衡二叉树的删除：

==删除的整体思路是：
（1）如果删去的结点q没有左节点右节点那就直接删去就行（切记找的时候记录pre,那么之后会很方便。）。
（2）如果有左节点或者右节点（不可同时有）那就直接pre.（lchild）/(rchild)=pre.（lchild)/(rchild)，在这里判断是pre的哪个指针指向就体现了之前记录pre的好处。
（3）如果其既有左节点又有右节点，那么只需要找出它中序遍历访问的下一个结点f即可，那个节点就是恰好比他大的结点，将f结点的val赋值原要删去的结点q再删去f节点即可。=

package com.company;


public class Main {
    static Node T=null;
    public static void main(String[] args){
        int []values={1,3,6,4,8,7,-1,10,-6};
        for(int value:values){
            BSInsert(value);
        }
        MidTravel(T);
        System.out.println();
        int v=8;
        BSTDelete(6);
        MidTravel(T);
    }

    public static void MidTravel(Node p){
        if(p!=null){
            MidTravel(p.lchild);
            System.out.print(p.val+" ");
            MidTravel(p.rchild);
        }
    }

    public static void BSInsert(int value){
        Node p=T;
        Node pre=null;
        while(p!=null){
            pre=p;
            if(p.val>value){
                p=p.lchild;
            }
            else if(p.val<value){
                p=p.rchild;
            }
            else{
                return ;
            }
        }
        if(T==null){
            T=new Node(value);
        }
        else if(pre.val>value){
            pre.lchild=new Node(value);
        }
        else{
            pre.rchild=new Node(value);
        }
    }

    public static void BSTDelete(int value){
        if(!searchBST(value)){
            return ;
        }
        else{
            Node pre=null;
            Node p=T;
            while(p.val!=value){
                pre=p;
                if(p.val>value){
                    p=p.lchild;
                }
                else{
                    p=p.rchild;
                }
            }
            Node q;
            if(pre.rchild!=null&&pre.rchild.val==value) {
                q = pre.rchild;
                if (q.rchild == null && q.lchild == null) {
                    pre.rchild = null;
                } else if (q.rchild == null) {
                    pre.rchild = q.lchild;
                } else if (q.lchild == null) {
                    pre.rchild = q.rchild;
                } else {
                    Node pre_e = null;
                    Node m = null;
                    Node f = q.rchild;
                    while (f.lchild != null) {
                        pre_e = f;
                        f = f.lchild;
                    }
                    if (pre_e != null) {
                        pre_e.lchild = null;
                        q.val = f.val;
                    } else {
                        q.val = f.val;
                        q.rchild = null;
                    }
                }
            }
            else if(pre.lchild!=null&&pre.lchild.val==value){
                q = pre.lchild;
                if (q.rchild == null && q.lchild == null) {
                    pre.lchild = null;
                } else if (q.rchild == null) {
                    pre.lchild = q.lchild;
                } else if (q.lchild == null) {
                    pre.lchild = q.rchild;
                } else {
                    Node pre_e = null;
                    //Node m = null;
                    Node f = q.rchild;
                    while (f.lchild != null) {
                        pre_e = f;
                        f = f.lchild;
                    }
                    if (pre_e != null) {
                        pre_e.lchild = null;
                        q.val = f.val;

                    } else {
                        q.val = f.val;
                        q.rchild = f.rchild;
                    }
                }
            }
        }
    }

    public static boolean searchBST(int value){
        Node p=T;
        while(p!=null){
            if(p.val==value){
                return true;
            }
            else if(p.val>value){
                p=p.lchild;
            }
            else{
                p=p.rchild;
            }
        }
        return false;
    }
}

class Node{
    int val;
    Node lchild;
    Node rchild;
    public Node(){
        val=0;
        lchild=null;
        rchild=null;
    }
    public Node(int value){
        this.val=value;
        lchild=null;
        rchild=null;
    }
}

4.