【八大排序（二）】选择排序与堆排序

news2024/12/26 0:14:35

❣博主主页: 33的博客❣
▶️文章专栏分类:八大排序◀️
🚚我的代码仓库: 33的代码仓库🚚
🫵🫵🫵关注我带你了解更多排序知识

在这里插入图片描述

1.前言

在上一篇文章种博主已经和大家分享了插入排序的基本思想、时间复杂度、空间复杂度、以及稳定性。这篇文章我们继续来学习选择排序！

2.选择排序

2.1基本思想

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。

在元素集合array[i]–array[n-1]中选择关键码最大(小)的数据元素
若它不是这组元素中的最后一个(第一个)元素，则将它与这组元素中的最后一个（第一个）元素交换
在剩余的array[i]–array[n-2]（array[i+1]–array[n-1]）集合中，重复上述步骤，直到集合剩余1个元素

2.2画图理解

选择排序

2.3单向选择排序代码实现

 public int[] selectOrder(int[] arr){
        for (int i=0;i<arr.length;i++){
            int min=i;//标记最小元素的坐标！！！
            for (int j=i+1;j<arr.length;j++){
                if(arr[j]<arr[min]){
                    min=j;
                }
            }
            swap(i,min,arr);
        }
        return arr;
    }
    private void swap(int i, int j,int[] arr) {
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp;
    }

2.4双向选择排序代码实现

 public int[] selectOrder2(int[] arr){
        int i=0;
        int j=arr.length-1;
        while (i<j){
            int min=i;//标记最小值
            int max=i;//标记最大值
            for (int a=i+1;a<=j;a++){
                if(arr[a]<arr[min]){
                    min=a;
                }
                if(arr[a]>arr[max]){
                    max=a;
                }
            }
            swap(i,min,arr);
            //防止第一个元素就是最大元素
            if (max==i){
                max=min;
            }
            swap(j,max,arr);
            i++;
            j--;
        }
        return arr;
    }

1. 时间复杂度：O( $n^2$ )
2. 空间复杂度：O(1)
3. 稳定性：不稳定

3.堆排序

3.1基本思想

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

3.2画图理解

以升序为例：
在这里插入图片描述

3.3代码实现

public void createHeap(int[] arr){
        for (int parent=(arr.length-1-1)/2;parent>=0;parent--){
            shiftdown(parent,arr.length,arr);
        }
    }
    private void shiftdown(int parent,int size,int[] arr) {
        int child=2*parent+1;
        while (child<size){
            if (child+1<size&&arr[child+1]>arr[child]){
                child=child+1;
            }
            if (arr[child]>arr[parent]){
                swap(child,parent,arr);
                parent=child;
                child=2*parent+1;
            }else break;
        }
    }
    public int[] heapOrder(int[] arr){
        createHeap(arr);
        int end=arr.length-1;
        while (end>0){
            swap(0,end,arr);
            shiftdown(0,end,arr);
            end--;
        }
    return arr;
    }