最大堆以及堆排序（Java实现）

最新推荐文章于 2024-04-15 00:28:10 发布

Xiao_Wan_Ying

最新推荐文章于 2024-04-15 00:28:10 发布

阅读量585

点赞数 1

CC 4.0 BY-SA版权

文章标签： java 堆排序

本文链接：https://blog.youkuaiyun.com/students__/article/details/96873446

本文介绍了最大堆的概念，即父节点大于孩子节点的完全二叉树，并通过数组实现。详细阐述了最大堆的添加元素方法（元素上浮）和取出元素方法（元素下沉）。文章还展示了Java代码实现，并提供了测试结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

二叉堆是本质是一棵完全二叉树，完全二叉树简单而言就是元素按照顺序一层一层的加入树中，除了最后一层之外，每一层上的节点数均达到最大值，只有在最后一层右下侧缺少若干个节点。

那最大堆的意思就是堆中父节点一定会大于它的孩子节点，相反就是最小堆，其实二叉堆就是元素按照顺序（这里的顺序不是指元素的大小顺序，而是指存放顺序）一层一层的放进树中，所以二叉堆完全可以用数组来表示。如下图：

如上图，如果使用数组实现二叉堆，就要注意父节点与子节点之间的索引关系，是的如果我们知道一个索引，我们能够得到其父节点与左右孩子的节点。

那具体的实现代码是什么样的？首先，我们需要定义一个数组类，当然也可以使用java中自带的数组类，为了阅读体验，我将我自己自定义的数组类放到文章最后，先放出最大堆类MaxHeap，类中一些比较简单的方法就不加注释了，最主要是添加方法和取出方法的说明：

1.添加元素方法实现原理：当我们向二叉树中添加新元素时，可能该元素会比其父节点大，那么此时，就违背了堆的结构特点，所以此时，就需要将该元素进行上浮（sift up），不断的与父节点交换，直到比父节点小，如图

图片只展示了一次交换，实际上还要进行交换，但由于篇幅，则不进行展示

实现代码如下：

2.取出元素方法实现原理：由于每次都取出最大的元素，也就是二叉堆中的根节点，所以对于数组来说，取出的就是索引值为0的元素，非常方便，但取完元素之后，还需要将根节点的左右孩子进行整合，比较麻烦，可以采取另一个方式，就是我们先将树中最后一个元素与根交换，如图

public void add(E e) {
        array.addLast(e);
        siftup(array.getSize()-1);
    }
    private void siftup(int k) {
        while(k>0&&array.get(k).compareTo(array.get(parent(k)))>0) {
            array.swap(k, parent(k));
            k=parent(k);
            
        }    
    }

然后将最后一个节点删除，此时数组的长度减一，但此时堆的结构被破坏，所以要将16往下沉。

首先，就是要找出它的左右孩子节点中最大的元素，然后与其交换

此时，16的下沉还没有完成，但后续步骤同上，就不加赘述。

实现代码如下：

public E findMax() {
        if(array.getSize()==0)
            throw new IllegalArgumentException("Can not findMax when heap is empty.");
        return array.get(0);
    }
    public E extractMax() {
        E res=findMax();
        array.swap( 0,array.getSize()-1);
        array.removeLast();
        siftdown(0);
        
        return res;
    }
    private void siftdown(int k) {
         while(leftChild(k)<array.getSize()) {
             int j=leftChild(k);
             if(j+1<array.getSize()&&array.get(j).compareTo(array.get(j+1))<0)
                 j++;
             if(array.get(k).compareTo(array.get(j))>=0)
                 break;
             array.swap(k, j);
             k=j;            
         }
    }

测试类结果：

到此时，最大堆以及堆排序介绍就到这里，下面贴出完整代码（MaxHeap类，自定义Array类，测试Solution类）

//MaxHeap类中元素需要具备可比性，所以需要继承Comparable类
public class MaxHeap<E extends Comparable<E>>{

     //定义一个数组类，这里我使用了自定义的数组类
    private Array<E> array;
    public MaxHeap() {
         this(10);
    }
    public MaxHeap(int capacity) {
        array=new Array<>(capacity);
    }
    public int getSize() {
        return array.getSize();        
    }

//下面的三个方法的含义是，如果我们知道一个索引，我们能够得到其父节点与左右孩子的节点的索引
    private int parent(int index) {
        return (index-1)/2;
    }
    private int rightChild(int index) {
        return 2*index+2;
    }
    private int leftChild(int index) {
        return 2*index+1;
    }
    public boolean isEmpty() {
       return array.isEmpty();   
    }

//添加方法实现原理比较
    public void add(E e) {
        array.addLast(e);
        siftup(array.getSize()-1);
    }
    private void siftup(int k) {
        while(k>0&&array.get(k).compareTo(array.get(parent(k)))>0) {
            array.swap(k, parent(k));
            k=parent(k);
            
        }    
    }
    public E findMax() {
        if(array.getSize()==0)
            throw new IllegalArgumentException("Can not findMax when heap is empty.");
        return array.get(0);
    }
    public E extractMax() {
        E res=findMax();
        array.swap( 0,array.getSize()-1);
        array.removeLast();
        siftdown(0);
        
        return res;
    }
    private void siftdown(int k) {
         while(leftChild(k)<array.getSize()) {
             int j=leftChild(k);
             if(j+1<array.getSize()&&array.get(j).compareTo(array.get(j+1))<0)
                 j++;
             if(array.get(k).compareTo(array.get(j))>=0)
                 break;
             array.swap(k, j);
             k=j;            
         }
        
    }
    public String toString() {
        return array.toString();
    }
}

//测试类

import java.util.Random;

public class Solution {

    public static void main(String[] args) {
         MaxHeap<Integer> maxheap=new MaxHeap<Integer>();
         int n=10;
         System.out.println("--------实现最大堆--------");
         for(int i=0;i<n;i++) {
             maxheap.add((int) (Math.random()*10));
         }
         System.out.println(maxheap);
         System.out.println("-------堆排序----------");
         int[] arr=new int[n];
            for(int i = 0 ; i < n ; i ++)
                arr[i] = maxheap.extractMax();
           for (int element : arr) {
            System.out.print(element+" ");
        }
           System.out.println();
            System.out.println("Test MaxHeap completed.");
        
 
    }

}


//自定义Array类


public class Array<E> {
    private E[] data;
    private int size;

    // 有参构造
    public Array(int capacity) {
        data = (E[])(new Object[capacity]);
        size = 0;
    }

    // 无参构造，调用有参构造方法，默认最大容量为10
    public Array() {
        this(10);
    }
    public void swap(int i,int j) {
        if(i < 0 || i >= size || j < 0 || j >= size)
            throw new IllegalArgumentException("Index is illegal.");

        E t=data[i];
        data[i]=data[j];
        data[j]=t;
        
        
    }
    // 数组长度
    public int getSize() {
        return size;
    }

    // 数组最大容量
    public int getCapacity() {
        return data.length;
    }

    // 判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    // 向所有数组前面添加元素
    public void addFirst(E e) {
        add(0, e);
    }

    // 向数组末尾当中添加元素
    public void addLast(E e) {
        add(size, e);
    }

    // 向指定位置插入元素
    public void add(int index, E e) {
        if (index < 0 || index > size)
            throw new IllegalArgumentException("index requires >0 and <=size");
        if (size == data.length)
            resize(2*data.length);
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        data[index] = e;
        size++;
    }
    private void resize(int newCapacity) {
        // TODO Auto-generated method stub
        E[] newData=(E[])new Object[newCapacity];
        for(int i=0;i<size;i++)
            newData[i]=data[i];
        data=newData;
        
    }

    //获得数组中的元素
    public E get(int index) {
        if(index<0||index>=size)
            throw new IllegalArgumentException("数组下标错误");
        return data[index];
    }
    //修改数组中某一个元素
    public void set(int index,E e) {
        if(index<0||index>=size)
            throw new IllegalArgumentException("数组下标错误");
        data[index]=e;
    }
    //打印数组
    @Override
    public String toString() {
        StringBuilder res=new StringBuilder();
        res.append( String.format("数组的长度为=%d,数组的最大容量为=%d\n",size,data.length));
        res.append("[");
        
        for(int i=0;i<size;i++)  {
            if(i!=size-1) {
            res.append(data[i]);
            res.append(", ");
            }
            
        }
        res.append(data[size-1]+"]");
        return res.toString();
    }
    //查询是否包含某个元素
    public boolean contains(E e) {
        for(int i=0;i<size;i++)
        {
            if (data[i]==e)
                return true;
        }
        return false;
    }
    //搜索某个元素，并且返回其索引值
    public int find(E e) {
        for(int i=0;i<size;i++)    
            if (data[i]==e)
                return i;
        return -1;
    }
    //删除某个下标为index的元素
    public E remove(int index) {
        if(index<0||index>=size)
            throw new IllegalArgumentException("数组下标错误");
        E res=data[index];
        for(int i=index+1;i<size;i++)
            data[i-1]=data[i];
        size--;    
        data[size]=null;
        if(size==data.length/2)
            resize(data.length/2);
        return res;
    }
    //删除某个元素
    public void removeElement(E e) {
        
            remove(find(e));    
        
    }
    public E removeFirst() {
        return remove(0);
    }
    public E removeLast() {
        return remove(size-1);
    }

}

以上为慕课网《玩转数据结构》自己做的笔记整理，图片来自该课程