排序算法详细介绍及代码实现

最新推荐文章于 2025-03-02 19:54:50 发布
原创 最新推荐文章于 2025-03-02 19:54:50 发布 · 370 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
算法

当前文章被收录于：

算法
1 篇文章 0 人学习
订阅专栏 查看详情
本文详细介绍了排序算法，包括时间复杂度解读，插入排序（直接插入和希尔排序）、选择排序（直接选择和堆排序）、交换排序（冒泡排序和快速排序）、归并排序以及基数排序，每个算法都配有相应的代码实现。

一、基础准备：时间复杂度解读

我们需要知道的是，算法里经常会被问到时间复杂度，那么我们需要先了解时间复杂度是怎么回事。
具体内容见下边。我们一般是先进行具体的分析，完了再写出具体的实现代码.

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

二、插入排序

插入排序法的介绍：
·	  插入式排序属于内部排序法，是对于欲排序的元素以插入的方式找寻该元素的适当位置，以达到排序的目的。
      插入排序的基本思想：把n个待排序的元素看成一个有序表和无序表，开始时有序表中只包含一个元素，
      无序表中包含有n-1个元素，排序过程中每次从无序表中取出一个元素，把它的排序码依次与有序表元素的排序码进行比较，
      将它插入到有序表中的适当位置，使之成为新的有序表。

1.直接插入排序

package sort;

import java.util.Arrays;

//插入排序的推导过程
public class InsertSort {
    public static void main(String[] args) {
        int [] arr = {10,-42,8,53,21};
        insertSort(arr);
    }

    private static void insertSort(int[] arr) {
        //第一步
        //定义两个变量
        int insertVal=arr[1];
        int insertIndex = 1-1;
        //这里需要做一个逻辑判断
        while(insertIndex>=0 && insertVal<arr[insertIndex]){
            //前者防止越界，后者用于具体调整插入的位置
            //其实就是将较大的值往后移动一位，给那个较小的值挪地方
            arr[insertIndex + 1 ] = arr [insertIndex] ;
            //继续往前走，判断前面值应不应该挪动
            insertIndex--;
        }

        //如果我们上述条件都符合的话，那么我们可以将对应的值插到对应的位置了
        //我们需要知道，如果insertVale不小于arr[insertIndex],我们找到的值需要插入到insertIndex的后边
        arr[insertIndex+1] = insertVal;
        System.out.println(Arrays.toString(arr));

        //第一步
        //定义两个变量
        insertVal=arr[2];
        insertIndex = 2-1;
        //这里需要做一个逻辑判断
        while(insertIndex>=0 && insertVal<arr[insertIndex]){
            //前者防止越界，后者用于具体调整插入的位置
            //其实就是将较大的值往后移动一位，给那个较小的值挪地方
            arr[insertIndex + 1 ] = arr [insertIndex] ;
            //继续往前走，判断前面值应不应该挪动
            insertIndex--;
        }

        //如果我们上述条件都符合的话，那么我们可以将对应的值插到对应的位置了
        //我们需要知道，如果insertVale不小于arr[insertIndex],我们找到的值需要插入到insertIndex的后边
        arr[insertIndex+1] = insertVal;
        System.out.println(Arrays.toString(arr));
    }
}

public class InsertSort {
    public static void main(String[] args) {
        int [] arr = {10,-42,8,53,21};
        insertSort(arr);
    }

    private static void insertSort(int[] arr) {
        for(int i=1;i<arr.length;i++){
            int insertVal = arr[i];
            int insertIndex = i-1;
            while(insertIndex >= 0 && insertVal<arr[insertIndex]){
                arr[insertIndex +1] = arr[insertIndex];
                insertIndex--;
            }
            arr[insertIndex+1] = insertVal;
        }
        System.out.println(Arrays.toString(arr));
    }
}

2.希尔排序

希尔排序法介绍：
	希尔排序是希尔于1959年提出的一种排序算法，希尔排序也是一种插入排序，
	它是简单插入排序经过改进之后的一个更高效的版本，也被称之为缩小增量排序。
	希尔排序分为两种，一种是交换排序，一种是移动排序,移动排序是优化后的。
希尔排序怕基本思想：
	希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序，随着增量逐渐减少，
	每组包含的关键词越来越多，等增量减至1时，整个文件被分成一组，算法便终止了。如果不懂请看下边的图片演示。

在这里插入图片描述

2.1交换希尔排序

private static void shellSort1(int[] arr) {
        int temp = 0;
        //第一步：分为五组，步长为5
        //如果上边有十个数，我们需要将他们分为五组，然后根据大小进行交换
        for(int i=5;i<arr.length;i++){
            for(int j=i-5;j>=0;j-=5){
                if(arr[j]>arr[j+5]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }
        //第二部 分为两组，步长为2
        for(int i=2;i<arr.length;i++){
            for(int j=i-2;j>=0;j-=2){
                if(arr[j]>arr[j+2]){
                    temp = arr[j];
                    arr[j] = arr[j+2];
                    arr[j+2] = temp;
                }
            }
        }

        //第三步：分为一组，步长为1
        for(int i=1;i<arr.length;i++){
            for(int j=i-1;j>=0;j-=1){
                if(arr[j]>arr[j+1]){
                    temp = arr[j];
                    arr[j] = arr[j+1];
                    arr[j+1] = temp;
                }
            }
        }

        System.out.println(Arrays.toString(arr));
    }

private static void shellSort1(int[] arr) {
        int temp = 0;
        for(int gap = arr.length/2;gap>0;gap /= 2) {
            for (int i = gap; i < arr.length; i++) {
                for (int j = i - gap; j >= 0; j -= gap) {
                    if (arr[j] > arr[j + gap]) {
                        temp = arr[j];
                        arr[j] = arr[j + gap];
                        arr[j + gap] = temp;
                    }
                }
            }
        }
        System.out.println(Arrays.toString(arr));

    }

2.2移动希尔排序

private static void shellSort2(int[] arr) {
        for(int gap = arr.length/2;gap>0;gap /= 2){
            for(int i=gap;i<arr.length;i++){
                int j = i;//这里就是保存一个要插入的值
                int temp = arr[j];
                if(arr[j]<arr[j-gap]){
                    while(j-gap>=0 && temp<arr[j-gap]){
                        //那么就和插入排序一样，需要进行移动
                        arr[j] = arr[j-gap];
                        j -= gap;
                    }
                    //这里进行插入
                    arr[j] = temp;
                }
            }
        }
        System.out.println(Arrays.toString(arr));
    }

三、选择排序

选择排序的基本介绍：
   选择排序也属于内部排序法，是从欲排序的数据中，
   按指定的规则选出某一元素，再依规定交换位置后达到排序的目的。

1.直接选择排序

   选择排序的思想：第一次从arr[0]到arr[n-1]中选取最小值，与arr[0]交换，
   第二次从arr[1]到arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]到arr[n-1]中选取最小值，
   与arr[2]交换……直到交换n-1次，得到一个按排序码从小到大的有序序列

public class SelectSort {
    public static void main(String[] args) {
        int arr[] = {3,1,6,0,-2};
        selectSort(arr);
    }

    private static void selectSort(int []arr) {

        //第一轮排序
        int min = arr[0];//我们假设最小值是数组的第一个值
        int minIndex = 0;//我们假设最小值的下标是0
        for(int j=0+1;j<arr.length;j++){
            if(min>arr[j]){
                min = arr[j];//将那个小的值赋给min，此时的min是二者中比较小的值
                minIndex = j;//将那个小的值的下标赋给minIndex，此时的minIndex是二者中较小值的下标
            }
        }
        if (minIndex != 0){
            //开始交换
            arr[minIndex] = arr[0];//将大的值和后边的值交换
            arr[0] = min ;//将小的值放到前边
        }
        
        
        //第二轮排序
        min = arr[1];
        minIndex = 1;
        for(int j=1+1;j<arr.length;j++){
            if (min>arr[j]){
                min = arr[j];
                minIndex = j;
            }
        }
        if (minIndex != 1){//交换
            arr[minIndex] = arr[1];//将大的值放到后边
            arr[1]=min;//将小的值放到前边
        }
        
        //第三轮排序
        min = arr[2];
        minIndex = 2;
        for(int j=2+1;j<arr.length;j++){
            if (min < arr[j]) {
                min = arr[j];
                minIndex = j;
            }
        }
        if(minIndex != 2){
            arr[minIndex] = arr[2];
            arr[2] = min;
        }
        
    }
}

public class SelectSort {
    public static void main(String[] args) {
        int arr[] = {3,1,6,0,-2};
        selectSort(arr);
    }

    private static void selectSort(int []arr) {

        //第一轮排序
        for(int i=0;i<arr.length-1;i++){
            int min = arr[i];//我们假设最小值是数组的第一个值
            int minIndex = i;//我们假设最小值的下标是0
            for(int j=i+1;j<arr.length;j++){
                if(min>arr[j]){
                    min = arr[j];//将那个小的值赋给min，此时的min是二者中比较小的值
                    minIndex = j;//将那个小的值的下标赋给minIndex，此时的minIndex是二者中较小值的下标
                }
            }
            if (minIndex != i){
                //开始交换
                arr[minIndex] = arr[i];//将大的值和后边的值交换
                arr[i] = min ;//将小的值放到前边
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}

2.堆排序

四、交换排序

1.冒泡排序 bubble sorting

冒泡排序的基本思想：通过对待排序序列从前向后（从下标较小的元素开始），
	依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐由前移向后边，就像水底下的气泡一样往上冒。
因为在排序的过程中，各个元素不断接近自己的位置，如果下一次比较没有进行交换，那么说明序列有序，
我们可以使用一个flag来判断元素是否进行交换，用来减少不必要的比较。

//冒泡排序推理过程
public class BubbleSort {
    public static void main(String[] args) {
        int arr[] = {3,-1,5,-5,0,-6,10,2};
        bubbleSort(arr);
    }

    private static void bubbleSort(int[] arr) {
        //为了能够看懂代码，我们的冒泡排序需要一步步的实现
        //第一次排序,假设我们的数组有8个数字，那么我们需要比较7次
        for(int j=0;j<arr.length-1;j++){
            int temp = 0;
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr [j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第一次冒泡排序后的结果"+ Arrays.toString(arr));
        //第二次冒泡排序后的结果
        for(int j=0;j<arr.length-1-1;j++){
            int temp = 0;
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr [j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第二次冒泡排序后的结果"+ Arrays.toString(arr));

        //第三次冒泡排序后的结果
        for(int j=0;j<arr.length-1-2;j++){
            int temp = 0;
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr [j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第三次冒泡排序后的结果"+ Arrays.toString(arr));

        //第四次冒泡排序后的结果
        for(int j=0;j<arr.length-1-3;j++){
            int temp = 0;
            if(arr[j]>arr[j+1]){
                temp = arr[j];
                arr[j] = arr [j+1];
                arr[j+1] = temp;
            }
        }
        System.out.println("第四次冒泡排序后的结果"+ Arrays.toString(arr));
    }
}

//这里是我们正式的冒泡排序的代码，我们直接将优化后的代码写出来
public class BubbleSort(){
	public static void main(String[] args){
		int arr[] = {3,-1,5,-5,0,-6,10,2};
        bubbleSort(arr);
	}
	public static void bubbleSort(int [] arr){
		int temp = 0;
		boolean flag = false;
		for(int i=0;i<arr.length-1;i++){
			for(int j=0;j<arr.length-1-i;j++){
				if(arr[j]<arr[j+1]){
					flag = true;
					temp = arr[j];
					arr[j] = arr[j+1];
					arr[j+1]=temp;
				}
			}
			if(!flag){
				break;
			}
		}
	}
}

2.快速排序

快速排序法介绍：
	快速排序是对冒泡排序的一种改进。基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，
其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，
这个排序过程可以递归进行，以此达到这个数据闭关有序序列。图片解析如下：

在这里插入图片描述

//快速排序
public class QuickSort {
    public static void main(String[] args) {
        int arr[] = {23, -13, 4, 5, 0, 36, -23, 43};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }
    private static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        int mid = arr[(left + right) / 2];
        int temp = 0;//这个是用来交换的中间值
        while (l < r) {
            //如果左边的值小于mid的值,那么l++；只有退出了while才能和右边的值进行交换
            while (arr[l] < mid) {
                l++;
            }
            //如果右边的值大于mid的值，那么r--;只有退出了while才能和左边的值进行交换
            while (arr[r] > mid) {
                r--;
            }
            if (l >= r) {//说明两边的值全部遍历完毕，直接退出
                break;
            }
            //开始交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            /*
            交换完以后，可能会出现一种情况
            就是交换以后的值和我们的mid值相同
            这时候我们需要进行特殊处理
             */
            if (arr[l] == mid) {
                r--;//将r前移一步
            }
            if (arr[r] == mid) {
                l++;//将l后移一步
            }
        }
        //如果r==l 那么我们必须让l++；r--,不然会陷入上边的死循环，无法推出
        if(r==l){
            r--;
            l++;
        }
        //这里我们需要注意，我们的l和r会在每一轮的交换中数值进行改变
        //所以我们要进行递归的时候必须采用改变以后的数值
        if(left<r){
            quickSort(arr,left,r);
        }
        if(right>l){
            quickSort(arr,l,right);
        }

    }
}

五、归并排序

归并排序介绍：
	归并排序是利用归并的思想实现的排序方法，
	该算法使用经典的分治策略，将一个大的问题分成一些小的问题然后递归求解。具体图解如下：

在这里插入图片描述

//归并排序
public class MergetSort {
    public static void main(String[] args) {
        int [] arr = {8,4,5,7,1,3,6,2};
        int [] temp = new int[arr.length];
        mergetSort(arr,0,arr.length-1,temp);
        System.out.println(Arrays.toString(arr));
    }

    private static void mergetSort(int[] arr, int left, int right, int[] temp) {
        if(left<right){
            //我们需要获得中间索引
            int mid = (right+left)/2;
            //向左递归进行求解
            mergetSort(arr,left,mid,temp);
            //向右递归进行求解
            mergetSort(arr,mid+1,right,temp);
            //调用写好的合并函数
            merge(arr,left,mid,right,temp);
        }
    }

    /*这就是一个合并函数，将上边分好的值进行合并就完事了
    int []arr 传过来的数组
    int left 左边索引的起始值
    int mid 中间索引的起始值
    int right 右边索引
    int []temp 用来做中转数组，但是我们这里需要注意，
    temp是指每一次用来做中转的数组，而不是最后一次做中转的数组
     */
    public static void merge(int []arr,int left,int mid,int right,int []temp){
        int i = left;
        int j = mid+1;
        int t = 0;//这个代表的是temp的索引
        while(i<=mid && j<=right){
            //当左边和右边的小数组里的值都没有走完的时候，
            // 我们通过下边的操作将对应的数值填充到临时数组里边
            if(arr[i]<=arr[j]){
                temp[t] = arr[i];
                t++;
                i++;
            }else{
                temp[t] = arr[j];
                t++;
                j++;
            }
        }

        while(i<=mid){//这就说明左边的数组有剩余，需要直接将剩下的元素迁移到temp数组中
            temp[t] = arr[i];
            t++;
            i++;
        }
        while(j<=right){//这就说明右边的数组有剩余，需要将剩下的元素直接迁移到temp数组中
            temp[t] = arr[j];
            t++;
            j++;
        }

        //最后我们会将temp数组中的元素写到原来的数组中
        //这里并不是每一次都拷贝全部元素的值
        t = 0;
        int tempLeft = left;
        //第一次合并tempLeft=0，right=1
        //第二次合并tempLeft=2，right=3，
        //第三次合并tempLeft=0，right=3，
        //...
        //第七次合并tempLeft=0，right=7，
        System.out.println("tempLeft:"+tempLeft+"   right"+right);
        while(tempLeft<=right){
            arr[tempLeft]=temp[t];
            t+=1;
            tempLeft+=1;
        }
    }
}

六、基数排序

基数排序介绍：
	基数排序属于分配时排序，又称桶排序，顾名思义，它是通过键值的各个位e值，将要排序的元素分配至某些桶中，达到排序的作用。
	基数排序法是属于稳定性的排序，计数排序法是效率高的稳定性排序法。
	基数排序是桶排序的扩展
	基数排序是将整数按位切割成不同的数字，然后按每个位数分别比较。
基数排序的基本思想：
	将所有待比较数值统一为同样的我数位长度，数位较短的书前面补零，然后从最低位开始，依次进行一次排序，这样从最低位排序一直到最高位排序完成以后，数列就编程一个有序序列。
	具体看下边的图像演示：

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

//这里是对基数排序的逐步推导
public static void radixSort(int []arr){

        /*
        定义一个二位数组，表示十个桶，每个桶都是一个二维数组
        1.二维数组中包含了十个一维数组
        2.为了防止放入数的时候，数据溢出，也就是极端情况下所有数据
        会出现在一个桶中，则每一个一位数组的大小定位arr.length
        3.我们在这里可以知道，基数排序就是典型的空间换时间的排序算法
        4.为了记录每个桶中，实际存放了多少个数据，我们定义一个
        一位数组来记录各个桶中每次放入的数据个数
        */

        //这个数组就是那个二维数组
        int [][] bucket = new int[10][arr.length];
        //这个数组就是用来存放每个桶中元素数量的值
        int []bucketElementCounts = new int[10];
        //第一轮，我们会针对个位数字进行排序处理
        for(int j=0;j<arr.length;j++){
            //我们取出每个元素个位的值
            int digitOfElement = arr[j]%10;
            //将这个元素的值放入到对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //然后我们按照这个桶的顺序，依次取出数值，放入原来的数组中
        int index = 0;
        //遍历每一个桶，并将桶中的数据，放入原来的数组
        for(int k=0;k<bucketElementCounts.length;k++){
            //如果桶中有数据，我们才放入到员数组中
            if(bucketElementCounts[k]!=0){
                //循环第k个桶，即第k个一位数组，放入
                for(int l = 0;l<bucketElementCounts[k];l++){
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            //我们需要知道，如果一轮排序完成以后，那么桶中存放数据的个数必须清零才能进行下一次操作
            bucketElementCounts[k] = 0;
        }
        System.out.println(Arrays.toString(arr));
        //第二轮，我们会针对十位数字进行排序处理
        for(int j=0;j<arr.length;j++){
            //我们取出每个元素十位的值
            int digitOfElement = arr[j]/10%10;
            //将这个元素的值放入到对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //然后我们按照这个桶的顺序，依次取出数值，放入原来的数组中
        index = 0;
        //便利每一个桶，并将桶中的数据，放入原来的数组
        for(int k=0;k<bucketElementCounts.length;k++){
            //如果桶中有数据，我们才放入到员数组中
            if(bucketElementCounts[k]!=0){
                //循环第k个桶，即第k个一位数组，放入
                for(int l = 0;l<bucketElementCounts[k];l++){
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }

        System.out.println(Arrays.toString(arr));

        //第三轮，我们会针对十位数字进行排序处理
        for(int j=0;j<arr.length;j++){
            //我们取出每个元素十位的值
            int digitOfElement = arr[j]/10/10%10;
            //将这个元素的值放入到对应的桶中
            bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
            bucketElementCounts[digitOfElement]++;
        }
        //然后我们按照这个桶的顺序，依次取出数值，放入原来的数组中
        index = 0;
        //便利每一个桶，并将桶中的数据，放入原来的数组
        for(int k=0;k<bucketElementCounts.length;k++){
            //如果桶中有数据，我们才放入到员数组中
            if(bucketElementCounts[k]!=0){
                //循环第k个桶，即第k个一位数组，放入
                for(int l = 0;l<bucketElementCounts[k];l++){
                    arr[index] = bucket[k][l];
                    index++;
                }
            }
            bucketElementCounts[k] = 0;
        }

        System.out.println(Arrays.toString(arr));
    }

public class RadixSort {
    public static void main(String[] args) {
        int arr[] = {53,3,542,748,14,214};
        radixSort(arr);
    }
    public static void radixSort(int []arr){
        //我们需要得到数组中的最大值
        int max = arr[0];
        for(int i=1;i<arr.length-1;i++){
            if(arr[i]>max){
                max = arr[i];
            }
        }
        //得到最大位数是几位数
        String maxLength = max+"";
        int maxlength=maxLength.length();
        System.out.println(maxlength);
        for(int i=0,n=1;i<maxlength;i++,n *=10){
            int [][] bucket = new int[10][arr.length];
            int []bucketElementCounts = new int[10];
            for(int j=0;j<arr.length;j++){
                int digitOfElement = (arr[j] / n) % 10;
                bucket[digitOfElement][bucketElementCounts[digitOfElement]]=arr[j];
                bucketElementCounts[digitOfElement]++;
            }
            int index = 0;
            for(int k=0;k<bucketElementCounts.length;k++){
                if(bucketElementCounts[k]!=0){
                    for(int l = 0;l<bucketElementCounts[k];l++){
                        arr[index] = bucket[k][l];
                        index++;
                    }
                }
                bucketElementCounts[k] = 0;
            }
        }
        System.out.println(Arrays.toString(arr));
    }
}
标签
#java
经典排序算法C++实现（10种）
weixin_42023936的博客
08-27 3219
C++实现经典排序算法插入排序希尔排序（缩小增量排序）选择排序堆排序冒泡排序冒泡排序的原理：快速排序合并排序折中排序新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章U...
合并排序算法介绍，以及C语言实现
Lunar112的博客
06-11 6793
算法介绍 C语言实现 算法介绍合并排序算法原理简单，时间复杂度低，且算法具有稳定性，在各类排序算法中具有较好的性能。本文将介绍合并算法的原理，并给出其C语言的实现。合并排序将待排序数组分隔成两个部分。先将这两个子数组进行排序，然后再将其合并。对于子数组的排序，则可以递归调用合并排序算法本身。算法分成数组拆分，与合并两个部分。拆分的实现较为简单，可以直接将数组从中间分隔成两个子数组。递归调用拆分，直到
尚硅谷数据结构与算法(Java)--12--冒泡排序
shlr_的博客
04-07 640
：冒泡排序 比较相邻的元素。如果第一个比第二个大，就交换他们两个。 package com.atguigu.sort; import java.text.SimpleDateFormat; import java.util.Arrays; import java.util.Date; /* 冒泡排序 */ public class BubleSort { public static void main(String[] args) { // int arr[] = { 3, 9, .
PHP实现四种基本排序算法
JineD的博客
07-05 8914
前提：分别用冒泡排序法，快速排序法，选择排序法，插入排序法将下面数组中的值按照从小到大的顺序进行排序。 $arr(1,43,54,62,21,66,32,78,36,76,39); 1. 冒泡排序 思路分析：在要排序的一组数中，对当前还未排好的序列，从前往后对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即，每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。 代码实现： <?php $arr=array(1,43,54,62,21,66,32,78,.
尚硅谷数据结构与算法(Java)--17--归并排序
shlr_的博客
04-09 896
：归并排序 归并排序是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法（Divide and Conquer）的一个非常典型的应用。 将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。 若将两个有序表合并成一个有序表，称为二路归并。 图片链接https://www.runoob.com/wp-content/uploads/2019/03/mergeSort.gif package com.atguigu.sort; impor...
8种排序算法(有代码)
NotePad
03-13 1352
 1.简单的选择排序 代码:bool selectionsort(int *array,int n)     //array为存储数据的数组,n为数组元素个数{int k,temp;        //k用来存储,临时最小数据的位置for(int i=0;i{   k=i;          for(int j=i+1;jif(array[j]k=j;   if(k!=i)    //
排序算法之归并排序(JAVA)
热门推荐
heitdf
12-28 5万+
public class MergeSort { /** * 归并排序 * 简介:将两个（或两个以上）有序表合并成一个新的有序表 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列 * 时间复杂度为O(nlogn) * 稳定排序方式 * @param nums 待排序数组 * @return 输出有序数组 */ public s
《尚硅谷数据结构》-冒泡排序和选择排序
Amigo_1997的博客
03-15 516
目录 冒泡排序 选择排序 冒泡排序 冒泡排序（Bubble Sorting） 的基本思想是： 通过对待排序序列从前向后（从下标较小的元素开始） ,依次比较相邻元素的值（两两比较）， 若发现逆序则交换， 使值较大的元素逐渐从前移向后部， 就像水底下的气泡一样逐渐向上冒。 冒泡排序规则 （1）一共进行 数组大小-1 次的大循环 （2）每一趟排序的次数在逐渐减少 （3）如果在某趟排序中，没有发生一次交换，则可以提前结束 import java.util.Arrays; public clas
排序算法——八种常见排序算法的简单介绍和JAVA代码实现
qq_65754164的博客
02-15 1243
本文进行了八种常见排序算法（冒泡，快排，插入，希尔，归并，基数，选择，堆排序）的简单介绍和JAVA代码实现
C语言八大排序算法【详细 代码+图文】
qq_43579888的博客
11-22 1万+
C语言八大排序算法 辅助方法代码 void ShowArr(int* arr, int len) //显示数组 { for (int i = 0; i < len; ++i) { printf("%d ", arr[i]); } printf("\n"); } bool IsSort(int* arr, int len) //判断数据是否有序，从小到大 { for (int i = 0; i < len - 1; ++i) { if (arr[i] > arr[
10种排序算法详解及其代码实现
软件开发工程师
01-19 1324
排序算法是计算机科学中的经典算法问题之一。排序算法根据不同的排序原理和实现方式有着不同的时间复杂度、空间复杂度和适用场景。以下是常见的10种排序算法的详解和代码实现，涵盖了从简单的交换排序到更高效的归并排序、快速排序等算法。
算法 经典的八大排序算法详解和代码实现
菜鸟心声：学的不仅是技术，更是梦想！
12-20 4537
算法 经典的八大排序算法详解和代码实现排序算法的介绍排序的分类算法的时间复杂度时间频度示例图表理解时间复杂度的特点时间复杂度常见的时间复杂度空间复杂度排序算法的时间复杂度冒泡排序基本思想图解代码示例结果展示代码优化结果展示选择排序基本思想图解代码实现结果展示插入排序基本思想图解代码实现结果展示希尔排序基本思想图解代码实现结果展示快速排序基本思想图解代码实现结果展示归并排序基本思想图解代码实现结果展示基数排序基本思想图解代码实现 排序算法的介绍 排序也称排序算法，排序时将一组数据，依指定的顺序进行排列的过程
C++实现基本的排序算法（详细解析以及源代码实现）
02-17 474
排序算法是一种基本并且常用的算法。由于实际工作中处理的数量巨大，所以排序算法对算法本身的速度要求很高。 而一般我们所谓的算法的性能主要是指算法的复杂度，一般用O方法来表示。在后面我将 给出详细的说明。      这里将按照算法的复杂度，从简单到难来分析算法。  一、简单排序算法  由于程序比较简单，所以没有加什么注释。所有的程序都给出了完整的运行代码，并在我的VC6.0环境  下运行通过。
排序算法的详解和分析对比（详细讲解）
gongjunbox的博客
10-31 9569
排序算法各式各样，每种排序算法的思想也大同小异。读者应该深度了解每种算法的基本思想、排序每一步过程细节和每种排序的特性，看到特定的序列，应该立马想到最适合的排序方法。一些简单的排序算法中，虽然效率不高，但是在低数量规模情况下，就比如一万数量级以下，一般运行时间还能可以被人们所接受，零点几秒左右很难被察觉出来。但是如果到了十万数量级，排序就需要非常久的时间，可能会导致我们一些系统会出现误差，从而引起巨大的麻烦和问题。
排序算法——计数排序【代码实现】
数据联盟
06-15 7146
伪代码 function countingSort(array, min, max): count: array of (max - min + 1) elements initialize count with 0 for each number in array do count[number - min] := count[number - min] ...
排序算法代码实现（一）—— 选择排序
CherishTheYouth的博客
08-11 1043
以下几篇随笔都是记录的我实现八大排序的代码，主要是贴出代码吧，讲解什么的都没有，主要是为了方便我自己复习，哈哈，如果看不明白，也不要说我坑哦！ 本片分为两部分代码： 常用方法封装 排序算法里需要频繁使用 交换数组中两数位置 的操作，另外，为了方便我打印数组查看结果，我封装一个 ArrayBase.java基类，用来实现swap方法和printArray方...
十大排序算法 思路+图解+代码示例【排序算法】
最新发布
李赛赛的专栏
03-02 1323
摘要: 这里罗列了常见的十大排序算法，通过注解、思路、图解、代码来快速了解各种排序算法的原理。
简单排序算法代码实现
冷眼看world的博客
12-07 566
1.冒泡排序 最基础的排序，本质在于交换，即每次通过交换的方式把当前剩余元素的最大值移动到一端，而当剩余元素减少为0时，排序结束。 void Bubble_sort(int a[]) { int len = sizeof(a) / sizeof(a[0]); for(int i = 0; i < len; i++) //要比较的次数 { for(int j = 0; j < ...
冒泡，选择，插入，快速四大排序算法详细解析说明
SeeYouAgain的博客
02-02 1988
基本的四大排序算法解释说明，冒泡排序，选择排序，插入排序，快排，都有用代码实现，并图解分析排序过程
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

erwang1123

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值