LeetCode前置课-4-哈希表、树、图

1、哈希表

2、树

public class TreeNode {
    private int no;
    private TreeNode leftNode;
    private TreeNode rightNode;

    public TreeNode(int no) {
        this.no = no;
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public TreeNode getLeftNode() {
        return leftNode;
    }

    public void setLeftNode(TreeNode leftNode) {
        this.leftNode = leftNode;
    }

    public TreeNode getRightNode() {
        return rightNode;
    }

    public void setRightNode(TreeNode rightNode) {
        this.rightNode = rightNode;
    }

    @Override
    public String toString() {
        return "TreeNode{" +
                "no=" + no +
                ", leftNode=" + leftNode +
                ", rightNode=" + rightNode +
                '}';
    }
    //前序遍历
    public void  preOrder(){
        System.out.println(this);
        if(this.leftNode!=null){
            this.leftNode.preOrder();
        }
        if(this.rightNode!=null){
            this.rightNode.preOrder();
        }
    }
    //中序遍历
    public void infixOrder(){
        if(this.leftNode!=null){
            this.leftNode.infixOrder();
        }
        System.out.println(this);
        if(this.rightNode!=null){
            this.rightNode.infixOrder();
        }
    }
    //后序遍历
    public void postOrder(){
        if(this.leftNode!=null){
            this.leftNode.postOrder();
        }
        if(this.rightNode!=null){
            this.rightNode.postOrder();
        }
        System.out.println(this);
        int[] a =  {1,2};
        Arrays.copyOfRange(a, 1, 2);
    }
    //前序遍历查找,num是要查找的结点数据
    public TreeNode preOrderSearch(int num){
        if(this.no==num){
            return this;
        }
        //因为是前序遍历所以先判断左子树
        TreeNode resNode = null;
        if(this.leftNode!=null){
            this.leftNode.preOrderSearch(num);
        }
        if(resNode!=null){//说明找到了
            return resNode;
        }
        if(this.rightNode!=null){
           resNode =  this.rightNode.preOrderSearch(num);
        }
        if(resNode!=null){
            return resNode;
        }
        return resNode;
    }
}

//顺序二叉树（堆排序就会使用顺序存储二叉树）
第n个节点的左子节点是2n+1;第n个节点的右子节点是2n+1，父节点是（n-1）/2，n是数组下标，也表示二叉树的第几个元素


//线索二叉树，二叉树n个节点有n+1个空指针域，利用空指针域存放指向该节点的前驱和后继节点，有前序线索二叉树，中序线索二叉树，和后续线索二叉树。

//堆排序，升序需要用大顶堆，降序需要用小顶堆
    public static  void heapSort(int arr[]){
        int temp =0;
        //构建大顶堆
        for(int i=arr.length/2-1;i>0;i--){
            adjustHeap(arr,i,arr.length);
        }
        for(int j=arr.length-1;j>0;j--){
            //交换
            temp=arr[j];
            arr[j]=arr[0];
            arr[0] = temp;
            adjustHeap(arr,0,j);
        }
    }
    //构建大顶堆,length会逐渐变短，i表示在数组中的索引
    public static  void adjustHeap(int arr[], int i, int length){
        int temp= arr[i];
        for(int k=i*2+1;k<arr.length;k=k*2+1){//i*2+1是i节点的左子节点
            if(k+1<length && arr[k]<arr[k+1]){//说明左子节点小于右子节点
                k++;//k指向右子节点
            }
            if(arr[k]>temp){//子节点当中的最大节点和当前节点比较
                arr[i]=arr[k];
                i=k;//继续循环比较
            }
        }
        //循环结束，将当前值放回给最终交换的位置
        arr[i]=temp;
    }

//赫夫曼树（WPL最小的树就是赫夫曼树，在网络中的应用是赫夫曼编码实现解压缩等）

//二叉排序树BST，任何一个非叶子结点要求左子节点的值比当前节点小，右子节点的值比当前节点大，删除时要判断删除的节点包含几个节点，根据情况不同进行删除

//平衡二叉树（AVL树,二叉搜索树），因为二叉排序树不平衡，可能变成类似列表的情况，查询速度明显降低。
他的左右子树的高度差的绝对值不超过1；实现方法有红黑树、AVL、替罪羊树、Treap、伸展树

public int height(){//计算当前节点树的高度
    return Math.max(leftNode==null?0 : leftNode.height(),rightNode==null?0 : rightNode.height());
}

//左旋

//右旋

3、多叉树：2-3树、B-树（B树）、B+树、B*树

4、图：

/**
 * Created by qililong on 2020/7/6.
 * 图,有邻接矩阵、邻接表
 */
public class Graph {
    //邻接矩阵方式
    //插入节点
    private ArrayList<String> vertexList;//存储顶点集合
    private int[][] edges;//存储图的邻接矩阵

    private boolean[] isVisited; //记录节点是否被访问
    public void insertVertex(String vertex){
        vertexList.add(vertex);
    }
}

深度优先：

                        

广度优先：