五.二叉树

一种数据结构：定义，构建，操作

我们就希望一种数据结构能同时具备数组查找快的优点以及链表插入和删除快的优点，于是 树 诞生了。

一.基本概念：

　　分类：普通二叉树，满二叉树，完全二叉树。二叉查找树(平衡二叉查找树(AVL树)，红黑树)。二叉堆。优先队列

　　　　　　平衡二叉树和平衡二叉查找树得区分一下

1.定义：按定义可分为：空树和非空树

2.术语：根节点，子节点，叶节点，兄弟节点。节点的深度，高度，层数。树的高度　

　　层次，高度，树的深度

　　树的高度：是二叉树中节点的最大层次数。层数=高度，深度=高度-1

3.性质：已知层数(高度)算节点个数，已知节点个数算层数(高度)：总共有l层，则共有n=2^l-1个节点；总共有n个节点，则共有l=log₂n+1层

　　　   （1）总共 i 层的二叉树，最多有2ⁱ-1个节点（高度为h的二叉树中，最多有2^h-1个节点）

　　　   （2）二叉树第i层最多有2^i-1个节点

　　　   （3）一棵具有n个节点的完全二叉树，高度为h=log₂n+1　　（log₂n向下取整）

　　　　　　也就是说：有n个节点的满二叉树或者完全二叉树，其高度或者层数位h=log₂n+1

　　　　（4）父节点序号为p，则左子节点：l=2*p+1，右子节点r=2*p+2。子节点序号为i，父节点：（i-1）/2

 

4.二叉树一般用于实现二叉查找树和二叉堆。所以一般用二叉查找树（BST）或二叉堆

　　二叉查找树是二叉树中最常用的一种类型。顾名思义,二叉查找树是为了实现快速查找而生的。不过,它不仅仅支持快速查找一个数据,还支持快速插入、删除一个数据。

 

5.操作：查找节点，插入节点，删除节点。遍历

 

4.效率

遍历可能不如其他操作快，但是在大型数据库中，遍历是很少使用的操作，它更常用于程序中的辅助算法来解析算术或其它表达式。

 

二.二叉树的遍历

分类：深度优先遍历：前序，中序，后续。广度优先遍历：层序遍历

1.递归遍历：前序，中序，后序

        //前序遍历
    public static void preOrder(TreeNode root) {
        if(root==null)
            return;
        System.out.println(root.data);
        preOrder(root.leftChild);
        preOrder(root.rightChild);
    }
    
    //中序遍历
    public static void inOrder(TreeNode root) {
        if(root==null)
            return;
        inOrder(root.leftChild);
        System.out.println(root.data);
        inOrder(root.rightChild);
    }
    
    //后序遍历
    public static void postOrder(TreeNode root) {
        if(root==null)
            return;
        postOrder(root.leftChild);
        postOrder(root.rightChild);
        System.out.println(root.data);
    }       

2.非递归遍历

    //前序
    public static void preOrderTraversalWithStack(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>();
        TreeNode current=root;
        while(current!=null || !stack.isEmpty()) {
            while(current!=null) {
                System.out.println(current.data);
                stack.push(current);
                current=current.leftChild;
            }
            
            if(!stack.isEmpty()) {
                current=stack.pop();
                current=current.rightChild;
            }
        }
    }
    
    //中序
    public static void inOrder(TreeNode root) {
        Stack<TreeNode> stack=new Stack<>();
        TreeNode current=root;
        while(current!=null || !stack.isEmpty()) {    // ||,不是&&
            while(current!=null) {
                stack.push(current);
                current=current.leftChild;
            }
            
            if(!stack.isEmpty()) {
                current=stack.pop();
                System.out.println(current.data);
                current=current.rightChild;
            }    
        }
    }
    
    //后序
    public static void postOrder(TreeNode root){
        Stack<TreeNode> stack  = new Stack<TreeNode>();
        TreeNode current = root;
        TreeNode lastVisit = root;        //记录最后一个访问的节点，用于检验是不是根节点的右节点
        while(current != null || !stack.empty()){
            while(current != null){
                stack.push(current);
                current=current.leftChild;
            }

            current = stack.peek();
            //两种情况：1.右子节点为空，直接访问 2.右子节点不为空，但已经访问过了，直接访问
            if(current.rightChild == null || current.rightChild== lastVisit){       //current.rightChild== lastVisit
                System.out.println(current.data);                                    //此时说明：右子树已经访问完毕
                stack.pop();
                lastVisit=current;
                current = null;
            }else {
                current=current.rightChild;
            }
        }
    }

3.层序遍历

    public static void levelOrder(TreeNode root) {
        LinkedList<TreeNode> queue=new LinkedList<>();
        queue.addLast(root);
        while(!queue.isEmpty()) {
            TreeNode node=queue.removeFirst();
            System.out.println(node.data);
            if(node.leftChild!=null)
                queue.addLast(node.leftChild);
            if(node.rightChild!=null)
                queue.addLast(node.rightChild);
        }
    }

 

三.二叉查找树(BST)

1.定义

2.BST的删除操作比价复杂

3.操作：查找，插入简单，删除比较复杂

（1）查插

    //查找
    public Node search(int data) {
        Node current=root;
        while(current != null) {
            if(data==current.data)
                return current;
            else if(data<current.data)
                current=current.left;
            else 
                current=current.right;
        }
        return null;    
    }
    
    //插入
    public boolean insert(int data) {
        Node node=new Node(data);
        if(root==null) {            //要区分：空树 和 非空树
            root=node;
            return true;
        }
        
        Node current=root;
        while(current != null) {
            if(data==current.data)
                return false;
            else if(data<current.data) {
                if(current.left==null) {
                    current.left=node;
                    return true;                //插完直接返回
                }
                current=current.left;
            }
            else {
                if(current.right==null) {
                    current.right=node;
                    return true;
                }
                current=current.right;
            }
        }
        return true;                            //恒返回 true
    }

（2）删除

 

3.AVL树：平衡二叉查找树

（1）AVL树是特殊的平衡二叉树，也是特殊的二叉查找树。它是平衡二叉树和二叉查找树的结合

（1）定义：左右子树的高度差不超过1

平衡二叉查找树又称AVL树，它或者是一棵空树，或者是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的深度之差的绝对值不超过1

AVL树是最先发明的自平衡二叉查找树算法。AVL树算法的发明是为了平衡二叉查找树

4.红黑树

（1）红黑树是平衡二叉树的一种。平衡二叉树追求完全平衡，条件比价苛刻。红黑树放弃了追求完全平衡，追求大致平衡

　　　红黑树是一种不严格的平衡二叉树

 

 

 

三.二叉堆

（1）定义：二叉堆本质是一个完全二叉树。分为：最大堆，最小堆

（2）用途：实现优先级队列和堆排序

（2）操作：1.插入节点  2.删除节点  3.构建二叉堆

　　　　这几种操作都依赖于二叉堆的自我调整：“上浮”调整，“下沉”调整

　　　　掌握：“上浮”调整，“下沉”调整，构建堆

（3）二叉堆基于数组实现：父节点索引parent，则左子节点：2*parent+1，右子节点：2*parent+2

（4）“上浮”，“下沉”代码

package com.midiyu.tree;

import java.util.Arrays;

public class BinaryHeap {
    //“上浮”调整
    public static void upAdjust(int[] array) {
        int childIndex=array.length-1;
        int parentIndex=(childIndex-1)/2;
        int temp=array[childIndex];

        while(childIndex>0 && temp<array[parentIndex]) {
            array[childIndex]=array[parentIndex];
            childIndex=parentIndex;
            parentIndex=(parentIndex-1)/2;
        }
        array[childIndex]=temp;
    }

    //“下沉”调整
    public static void downAdjust(int[] array,int parentIndex) {
        int childIndex=2*parentIndex+1;
        int temp=array[parentIndex];
        while(childIndex<array.length) {
            if(childIndex+1<array.length && array[childIndex+1]<array[childIndex])
                childIndex++;
            if(temp<=array[childIndex])
                break;
            array[parentIndex]=array[childIndex];
            parentIndex=childIndex;
            childIndex=2*childIndex+1;
        }
        array[parentIndex]=temp;
    }

    //构建堆
    public static void buildHeap(int[] array) {
        for(int i=(array.length-2)/2;i>=0;i--)    //最后一个非叶子节点的索引：(最后一个叶子节点索引-1)/2
            downAdjust(array, i);
    }

    public static void main(String[] args) {
        int[] array = new int[] {1,3,2,6,5,7,8,9,10,0};
        upAdjust(array);
        System.out.println(Arrays.toString(array));

        array = new int[] {7,1,3,10,5,2,8,9,6};
        buildHeap(array);
        System.out.println(Arrays.toString(array));
    }

}

 

四.优先级队列

二叉堆是实现堆排序和优先级队列的基础

1.还是在队尾入队，队头出队。但先进不一定先出，而是根据优先级出队

　　最小优先级队列：当前最小元素优先出队

　　最大优先级队列：当前最大元素优先出队

2.实现：用最大堆来实现最大优先级队列。每一次入队操作就是堆的插入操作，每一次出队操作就是删除堆顶节点

　　　　入队：“上浮”，出队：“下沉”

3.实现代码

package com.midiyu.tree;

public class PriorithQueue {
    int[] array;
    int size;
    
    public PriorithQueue() {
        this.array=new int[32];
    }
    
    //入队
    public void enQueue(int key) {
//        if(size>=array.length)
//            resize();
        array[size++]=key;
        upAdjust();
    }
    
    //出队
    public int deQueue() throws Exception {
        if(size<=0)
            throw new Exception("队已经空了");
        int head=array[0];
        array[0]=array[--size];
        downAdjust();
        return head;
    }
    
    //“上浮”调整
    public void upAdjust() {
        int childIndex=size-1;
        int parentIndex=(childIndex-1)/2;
        int temp=array[childIndex];
        while(childIndex>0 && array[childIndex]>array[parentIndex]) {
            array[childIndex]=array[parentIndex];
            childIndex=parentIndex;
            parentIndex=(parentIndex-1)/2;
        }
        array[childIndex]=temp;
    }
    
    //“下沉”调整
    public void downAdjust() {
        int parentIndex=0;
        int childIndex=0;
        int temp=array[parentIndex];
        while(childIndex<size) {
            if(childIndex+1<size && array[childIndex+1]>array[childIndex])
                childIndex++;
            if(temp>=array[childIndex])
                break;
            array[parentIndex]=array[childIndex];
            parentIndex=childIndex;
            childIndex=2*childIndex+1;
        }
        array[parentIndex]=temp;
    }
    
    
    
    public static void main(String[] args) throws Exception {
        PriorithQueue priorithQueue=new PriorithQueue();
        priorithQueue.enQueue(3);
        priorithQueue.enQueue(5);
        priorithQueue.enQueue(10);
        priorithQueue.enQueue(2);
        priorithQueue.enQueue(7);
        System.out.println("出队元素："+priorithQueue.deQueue());
        System.out.println("出队元素："+priorithQueue.deQueue());
    }

}