基础算法与数据结构——树结构

最新推荐文章于 2023-03-25 06:15:00 发布

suye233

最新推荐文章于 2023-03-25 06:15:00 发布

阅读量467

点赞数

分类专栏：数据结构/算法

个人博客：suyeq.com 欢迎访问

本文链接：https://blog.csdn.net/hackersuye/article/details/88982997

版权

数据结构/算法专栏收录该内容

9 篇文章 1 订阅

订阅专栏

堆

定义

某个节点的值总是不大于或不小于其父节点的值的一棵完全二叉树。堆本质上是一个数组，利用逻辑关系构成了一棵树。其实现的排序性能达到了O(nlgn)。

应用场景

堆排序、Java中的PriorityQueue

实现

public class Head{

    private static int caculateLeftChildIndex(int index){
        return (index <<1 )+1;
    }

    private static int caculateRightChildIndex(int index){
        return (index <<1 )+2;
    }

    private static int caculateParentIndex(int index){
        return (index -1 )>>1;
    }

    public static void headSort(int []array){
        for(int i=array.length-1 ;i>0;i--){
            swap(array, 0, i);
            downHead(0, array, i);
        }
    }

    public static void buildHead(int []array){
        for(int i=(array.length-1)/2 ;i>=0;i--){
            downHead(i, array, array.length);
        }
    }

    public static void upHead(int index,int []array,int length){
        int parentIndex=caculateParentIndex(index);
        if(parentIndex >= 0 && array[parentIndex] < array[index]){
            swap(array,parentIndex,index);
            index=parentIndex;
            upHead(index, array, length);
        }
    }

    public static void downHead(int index,int []array,int length){
        int leftChildIndex=caculateLeftChildIndex(index);
        int rightChildIndex=caculateRightChildIndex(index);
        int largestIndex=index;
        if(leftChildIndex < length && array[largestIndex] < array[leftChildIndex]){
            largestIndex=leftChildIndex;
        }
        if(rightChildIndex < length && array[largestIndex] < array[rightChildIndex]){
            largestIndex=rightChildIndex;
        }
        if(largestIndex != index){
            swap(array, largestIndex, index);
            downHead(largestIndex, array,length);
        }
    }

    private  static void swap(int []array,int i,int j){
        if(i == j){
            return;
        }
        array[i]=array[i]^array[j];
        array[j]=array[i]^array[j];
        array[i]=array[i]^array[j];
    }

    public String toString(int []array){
        return Arrays.toString(array);
    }


    public static void main(String []args){
        int []array={9,7,6,3,5,2,1,8};
        //upHead(7, array, array.length);
        buildHead(array);
        headSort(array);
        System.out.println(Arrays.toString(array));
    }
}

哈夫曼树

定义

给定n个权值作为n个叶子结点，构造一棵二叉树，若该树的带权路径长度达到最小，称这样的二叉树为最优二叉树，又称哈夫曼树。特点是权值大的离根节点近。

应用场景

文件的压缩

实现

采用自底向上的方式进行构建，每次选取两个权值最小的节点构成一颗新的树，新树的新权值需要参与接下来树的构建，直到所有的节点构建完毕：

public class HuffmanTree {

    private Queue<Node> queue;

    private int[] array;

    private final int DEFALUTSIZE=1<<5;

    private int size;

    private Node first;

    public HuffmanTree(){
        queue=new PriorityQueue<>();
        array=new int[DEFALUTSIZE];
    }

    public void insert(int value){
        this.array[size]=value;
        size++;
    }

    public void preOrder(Node node){
        if (node==null){
            return;
        }
        System.out.print(node.value+" ");
        preOrder(node.leftChild);
        preOrder(node.rightChild);
    }

    public Node createHuffmanTree(){
        for (int i=0;i<size;i++){
            queue.offer(new Node(array[i]));
        }
        while (queue.size()>1){
            Node node1=queue.poll();
            Node node2=queue.poll();
            Node parent=new Node(node1.value+node2.value);
            parent.leftChild=node1;
            parent.rightChild=node2;
            node1.parent=parent;
            node2.parent=parent;
            queue.offer(parent);
        }
        first=queue.poll();
        return first;
    }

    public void enCode(Node root,String encode){
        if (root.rightChild==null && root.leftChild==null){
            System.out.println(root.value+"被编码为："+encode);
        }
        if (root.leftChild!=null){
            encode+="0";
            enCode(root.leftChild,encode);
            int length=encode.length();
            encode=encode.substring(0,length-1);
        }
        if (root.rightChild!=null){
            encode+="1";
            enCode(root.rightChild,encode);
            int length=encode.length();
            encode=encode.substring(0,length-1);
        }
    }

    class Node implements Comparable{
        Node leftChild;
        Node rightChild;
        Node parent;
        int value;

        Node(int value){
            this.value=value;
        }
        @Override
        public int compareTo(Object o) {
            Node node=(Node)o;
            if (node.value>this.value){
                return -1;
            }else if (node.value<this.value){
                return 1;
            }
            return 0;
        }
    }

}

二叉搜索树

定义

所有节点的左孩子比它小，右孩子比它大的一颗二叉树，可以包含等于的情况。一般用作搜索。缺点是如果插入的顺序不当，那么二叉搜索树会退化成线性操作，而平衡树以及红黑树就是为了防止该种情况出现的。

删除

二叉搜索树的删除是找到要被删除的节点的前驱(左孩子里最大的)或者后继(右孩子里最小的)的值来替换它，然后删除原来的前驱或者后继所在的节点，如图：

AVL树

定义

AVL树是一个高度平衡的二叉搜索树，是平衡树的一种，其最短路径与最长路径的绝对值之差不大于1。缺点是为了保持高度的平衡性而造成其插入性能比不上其它局部不平衡而整体平衡的红黑树，但是查找性能是比后者好的。

应用场景

windows对进程地址空间的管理用到了AVL树

实现

左左情况：需要将插入的节点以及其父节点、祖父节点做右旋操作，使其父节点代替祖父节点，祖父节点成为其父节点的右孩子
[外链图片转存失败(img-KhRCeg3s-1566869439724)(http://suyeq.com:8888/CloudNotes/Treeimg/311901354227875.png)]
右右情况：需要将插入的节点以及其父节点、祖父节点做左旋操作，使其父节点代替祖父节点，祖父节点成为其父节点的左孩子
左右情况：先进行左旋操作，再进行右旋操作
右左情况：先进行右旋操作，再进行左旋操作
[外链图片转存失败(img-fgKr25TM-1566869439726)(http://suyeq.com:8888/CloudNotes/Treeimg/312151521573646.png)]