八大经典排序算法(Java)

最新推荐文章于 2024-04-24 23:48:42 发布

frimiku

最新推荐文章于 2024-04-24 23:48:42 发布

阅读量985

点赞数 24

文章标签：排序算法 java 算法

本文链接：https://blog.csdn.net/qq_73339471/article/details/135298937

版权

1.冒泡排序

冒泡排序的思路

重复地遍历要排序的列表，一次比较两个元素，并根据大小交换它们的位置，直到整个列表按照升序或降序排列。下面是冒泡排序的基本步骤：

比较相邻元素：从列表的第一个元素开始，比较相邻的两个元素。
交换位置：如果顺序不符合要求（升序或降序），则交换这两个元素的位置。
移动到下一对相邻元素：继续比较和交换列表中的下一对相邻元素，直到达到列表的末尾。
重复遍历：重复以上步骤，每一次遍历都会使列表中最大（或最小）的元素沉到列表的最后。
减少遍历范围：每完成一轮遍历，可以缩小待排序部分的范围，因为最大（或最小）的元素已经确定其位置，不再参与后续的比较。

这个过程就像是冒泡一样，较大（或较小）的元素会像气泡一样逐渐上浮到正确的位置。

冒泡排序代码

public class Sort {
    //1.冒泡排序
    public static int[] bubblingSort(int... ns){
        for(int i=0;i<ns.length-1;i++){
            for(int j=0;j<ns.length-1-i;j++){
                if(ns[j]>ns[j+1]){
                    int t=ns[j];
                    ns[j]=ns[j+1];
                    ns[j+1]=t;
                }
            }
        }
        return ns;
    }

    public static void main(String[] args) {
        int[] a={1,3,4,2,8,6,7};
        System.out.println(Arrays.toString(bubblingSort(a)));
    }
}

结果展示

2.选择排序

选择排序的思路

基本思路步骤：

遍历数组： 从数组的起始位置开始，将第一个元素视为当前最小（或最大）的元素。
找到最小（或最大）元素： 遍历未排序的部分，找到比当前最小（或最大）元素更小（或更大）的元素。
交换位置： 将找到的最小（或最大）元素与当前位置的元素交换位置。
移动到下一个位置： 将当前位置移动到下一个未排序的位置，继续从步骤 1 开始。
重复直到排序完成： 重复以上步骤，每次找到未排序部分的最小（或最大）元素并将其放到已排序部分的末尾，直到整个数组都有序。

选择排序的核心思想是每次从未排序部分选择一个最小（或最大）的元素，然后将其放到已排序部分的末尾。这个过程保证在每一轮中，已排序部分都会增加一个元素，最终达到整个数组的有序状态。

选择排序代码

public class Sort {
    //2.选择排序
    public static int[] selectSort(int... array){
        for(int i=0,maxPox,maxValuePos;i<array.length;i++){
            maxPox=array.length-1-i;
            maxValuePos=0;
            for (int j = 1; j <= maxPox ; j++) {
                if(array[j]>array[maxValuePos]){
                    maxValuePos=j;
                }
            }
            if(maxPox!=maxValuePos){
                int t=array[maxPox];
                array[maxPox]=array[maxValuePos];
                array[maxValuePos]=t;
            }
        }
        return array;
    }

    public static void main(String[] args) {
        int[] a={1,31,42,2,8,16,17};
        System.out.println(Arrays.toString(selectSort(a)));
    }
}

结果展示

3.插入排序

插入排序的思路

基本思路步骤：

初始状态：将数组分为已排序部分和未排序部分。初始时，已排序部分只包含第一个元素，而未排序部分包含其余的元素。
逐步构建有序序列：从未排序部分取出第一个元素，将其插入到已排序部分的正确位置，使得已排序部分仍然保持有序。
比较并移动：将取出的元素与已排序部分的元素逐一比较，找到其正确的插入位置。为了插入，可能需要将比它大的元素依次向右移动，为新元素腾出插入的位置。
重复步骤 2-3：重复以上步骤，每次取出未排序部分的一个元素，插入到已排序部分的正确位置。这样，已排序部分逐渐增加，未排序部分逐渐减小。
直到排序完成：重复上述过程，直到未排序部分为空，整个数组就被排序完成了。

插入排序的核心思想是将元素逐个插入到已经有序的部分中，通过不断地扩大已排序部分的范围，最终完成整个数组的排序。

插入排序代码

public class Sort {
    //3.插入排序
    public static int[] inserSort(int... array){
        int i,j;
        for(i=1;i< array.length;i++){
            if(array[i]>=array[i-1]){
                continue;
            }
            int t=array[i];
            //
            for(j=i-1;j>=0&&array[j]>t;j--){
                array[j+1]=array[j];
            }
            array[j+1]=t;
        }
        return array;
    }

    public static void main(String[] args) {
        int[] a={94,54,52,36,17,4,9};
        System.out.println(Arrays.toString(inserSort(a)));
    }
}

结果展示

4.希尔排序

希尔排序的思路

希尔排序是一种改进的插入排序算法，其核心思想是通过间隔逐渐减小的方式，对子序列进行插入排序，最终完成整个数组的排序。下面是希尔排序的基本思路：

确定间隔：选择一个初始的间隔（也称为增量），通常将数组长度除以2，并逐渐减小这个间隔。
对子序列进行插入排序：根据确定的间隔，将数组分成若干个子序列，对每个子序列进行插入排序。这意味着对于每个子序列，相隔间隔的元素会被比较和交换位置。
减小间隔：缩小间隔，重复步骤 2。持续缩小间隔并对子序列进行插入排序，直到间隔为1。
最后一次插入排序：当间隔为1时，希尔排序变为普通的插入排序，但此时数组已经相对有序，插入排序的效率会比较高。

希尔排序代码

public class Sort {
    //4.希尔排序
    public static int[] shellSort(int... array){
        int step = array.length,t,i;
        while(step>1){
            step/=2;
            for(i=0 ; i+step < array.length ; i++){
                if(array[i]>array[i+step]){
                    t=array[i];
                    array[i]=array[i+step];
                    array[i+step]=t;
                }
            }
        }
        for(i=1;i<array.length;i++){
            if(array[i]>=array[i-1]){
                continue;
            }
            int low=0;
            int high=i-1,mid;
            while(low<high){
                mid=low+(high-low)/2;
                if(array[i]<=array[mid]){
                    high=mid;
                }else{
                    low=mid+1;
                }
            }
            int v=array[i];
            System.arraycopy(array,low,array,low+1,i-low);
            array[low]=v;
        }
        return array;
    }

    public static void main(String[] args) {
        int[] a={53,51,52,54,82,7,9};
        System.out.println(Arrays.toString(shellSort(a)));
    }
}

结果展示

5.计数排序

计数排序的思路

计数排序的基本思路：

确定取值范围： 遍历整个待排序的数组，确定数组中元素的取值范围，找到最小值和最大值。
创建计数数组： 创建一个计数数组，其长度为取值范围的大小，用于统计原始数组中每个元素出现的次数。
统计元素个数： 遍历原始数组，将每个元素出现的次数记录到计数数组中，计数数组的索引对应于元素的值。
累加计数数组： 对计数数组进行累加操作，每个位置的值等于其前面所有位置值之和。这一步的目的是确定每个元素在排序后的数组中的位置。
构建有序数组： 创建一个与原始数组等长的临时数组，遍历原始数组，根据累加计数数组确定每个元素在有序数组中的位置，同时更新计数数组中对应元素的计数。
得到排序结果： 此时，临时数组就是排序完成的结果。

计数排序的代码

public class Sort {
    //5.计数排序
    public static int[] countingSort(int... array){
        int max=array[0],i,j;
        for(i=1;i<array.length;i++){
            if(array[i]>max){
                max=array[i];
            }
        }
        //新建max+1的整数数组
        int[] tempArray = new int[max+1];
        for (i = 0; i < array.length; i++) {
            tempArray[array[i]]++;
        }
        for (i = 0,j=0; i < tempArray.length; i++) {
            for (int k = 0; k < tempArray[i]; k++) {
                array[j++]=i;
            }
        }
        return array;
    }

    public static void main(String[] args) {
        int[] a={52,1,0,49,70,62,81,17};
        System.out.println(Arrays.toString(countingSort(a)));
    }
}

结果展示

6.基数排序

基数排序的思路

基数排序的基本思路：

按位排序： 基数排序将待排序的数字按照位数拆分为个位、十位、百位等各个数字位。它从最低位（个位）开始，依次向更高位进行排序。
按位分组： 将所有待排序的数字按照当前位的数值进行分组，比如根据个位数值将数字分成 0 到 9 这十个桶（或队列）。
依次收集： 从 0 到 9 的顺序，依次收集各个桶中的数字。首先收集个位为 0 的所有数字，然后是个位为 1 的，依此类推。这样就完成了一轮按个位数的排序。
重复步骤： 对十位、百位等其他位数重复上述过程，直到所有位数都被遍历完毕。每一轮按位分组和收集都会逐步使得数字序列变得更加有序。
得到排序结果： 当所有位数都经过排序后，整个数组就被排序完成了。

计数排序代码

public class Sort {
    //6.基数排序
    public static int[] radixSort(int... array){
        int i,j;
        int max1=array[0];
        for(i=1;i<array.length;i++){
            if(array[i]>max1){
                max1=array[i];
            }
        }
        int size=0;
        while(max1>=1){
            max1/=10;
            size++;
        }
        int[][] buckets = new int[10][array.length];
        int[] ixs=new int[10];//计数器

        int u;
        int sw;
        for (i = 0; i < size; i++) {
            u=(int)Math.pow(10,i);
            for(j=0;j<array.length;j++){
                sw=(array[j]/u)%10;
                buckets[sw][ixs[sw]++]=array[j];
            }
            int m=0;
            for(j=0;j<ixs.length;j++){
                for(int k=0;k<ixs[j];k++){
                    array[m++]=buckets[j][k];
                }
                ixs[j]=0;
            }
        }
        return array;
    }

    public static void main(String[] args) {
        int[] a={81,12,16,42,92,86,71,1};
        System.out.println(Arrays.toString(radixSort(a)));
    }
}

结果展示

7.快速排序

快速排序的思路

快速排序的基本思路：

选择基准元素： 从数组中选择一个基准元素（pivot）。通常可以选择数组的第一个元素、最后一个元素或者随机选择。
分割操作： 将数组中小于基准元素的元素移到基准元素的左边，大于基准元素的元素移到右边。这个过程称为分割操作。
递归排序： 对基准元素左右两侧的子数组分别递归地进行快速排序。即，对左侧子数组重复步骤 1 和步骤 2，然后对右侧子数组也进行相同的操作，直到子数组的长度为 1 或 0。
合并结果： 当所有子数组都有序时，整个数组就被排序完成了。

快速排序的关键在于分割操作，它通过不断地将元素分离到基准元素的左右两侧，使得基准元素最终找到了自己在排序后数组中的正确位置。在递归排序的过程中，整个数组逐渐变得有序。

快速排序代码

public class Sort {
    //7.快速排序
    public static int mid(int[] array, int begin, int end){
        int base=array[begin],mid=begin;
        while(begin<end){
            while(begin<end && array[end]>=base){
                end--;
            }
            while(begin<end && array[begin]<=base){
                begin++;
            }
            if(begin<end){
                int t=array[begin];
                array[begin]=array[end];
                array[end]=t;
            }
        }
        if(begin!=mid) {
            int t = array[begin];
            array[begin] = array[mid];
            array[mid] = t;
        }
        return begin;
    }
    public static int[] quickSort(int[] array,int begin,int end){
        if(begin>=end){
            return null;
        }
        final int mid=mid(array,begin,end);
        quickSort(array, begin, mid-1);
        quickSort(array, mid+1, end);
        return array;
    }

    public static void main(String[] args) {
        int[] a={81,12,16,42,92,86,71,1};
        System.out.println(Arrays.toString(quickSort(a,0,a.length-1)));
    }
}

结果展示

8.归并排序

归并排序的思路

归并排序的基本思路：

分解数组： 将待排序的数组分成两个大致相等的子数组，这是通过找到数组的中间位置来完成的。
递归排序： 递归地对这两个子数组进行归并排序。这一步骤会将每个子数组继续分解成更小的子数组，并对其进行排序。
合并子数组： 将排好序的两个子数组合并成一个有序的数组。这是通过比较两个子数组的首个元素，并将较小（或较大）的元素依次放入新的数组中完成的。
递归返回： 重复上述过程，直到所有子数组都被合并成一个完整的有序数组。

归并排序的关键在于合并操作，它确保了每次合并的两个子数组都是有序的。这样，当两个有序的子数组合并时，新的大数组也是有序的。

归并排序代码

public class Sort {
    //8.归并排序
    public static int[] mergeSort(int[] array, int begin, int end){
        //相遇(拆)
        if(begin==end){
            return new int[]{array[end]};
        }
        int mid=begin+(end-begin)/2;
        int[] left=mergeSort(array,begin,mid);
        int[] right=mergeSort(array,mid+1,end);
        //并
        int[] mix=new int[left.length+right.length];
        int i=0,j=0,m=0;//m为新数组下标
        while(i<left.length&&j<right.length){
            mix[m++]=left[i]<=right[j]?left[i++]:right[j++];
        }
        //剩余
        while(i<left.length){
            mix[m++]=left[i++];
        }
        while(j<right.length){
            mix[m++]=right[j++];
        }
        return mix;
    }

    public static void main(String[] args) {
        int[] a={6,59,81,75,84,17,71,1,54,36};
        System.out.println(Arrays.toString(mergeSort(a,0,a.length-1)));
    }
}