排序算法-备忘录

已于 2022-07-03 21:34:36 修改
阅读量159 收藏
点赞数
分类专栏： 数据结构与算法 文章标签： 算法 排序算法
于 2022-04-22 00:21:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/haowu8888/article/details/124310812
版权

跳转到总目录

文章目录

排序算法

排序的分类：

  • 内部排序:
    指将需要处理的所有数据都加载到内部存储器中进行排序。
  • 外部排序法：
    数据量过大，无法全部加载到内存中，需要借助外部存储进行排序。

常见的排序算法分类(见下图):
在这里插入图片描述

冒泡排序

基本介绍
冒泡排序（Bubble Sorting）的基本思想是：通过对待排序序列从前向后（从下标较小的元素开始）,依次比较相邻元素的值，若发现逆序则交换，使值较大的元素逐渐从前移向后部，就像水底下的气泡一样逐渐向上冒。

因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下来没有进行过交换，就说明序列有序。因此要在排序过程中设置一个标志flag判断元素是否进行过交换，优化后可以减少不必要的比较。

示例图解
在这里插入图片描述
代码示例

//冒泡排序
public class BubbleSort {
    public static void main(String[] args) {
     /*   int arr[]={3,9,-1,10,20};
        System.out.println("排序前: "+Arrays.toString(arr));
        bubbleSort(arr);
        System.out.println("排序后: "+Arrays.toString(arr));*/

        //测试冒泡排序的速度O(n^2),80000个随机数据  用时13s
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

        bubbleSort(arr);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);
    }

    //冒泡排序方法 已优化
    public static void bubbleSort(int[] arr) {
        boolean flag = false; //记录标识,表示是否交换过
        int temp =0;
        for (int i = 0; i < arr.length-1; i++) {
            for (int j = 0; j < arr.length - i-1; j++) {
                if (arr[j]>arr[j+1]){
                    flag=true;
                    temp=arr[j];
                    arr[j]=arr[j+1];
                    arr[j+1]=temp;
                }
            }
           /* System.out.printf("第%d躺排序后",i+1);
            System.out.println(Arrays.toString(arr));*/
            if (!flag){
                break;
            }else {
                flag=false; //不重置 等于没有优化
            }
        }
    }
}

选择排序

选择排序思想

选择排序（select sorting）也是一种简单的排序方法。它的基本思想是：第一次从arr[0]arr[n-1]中选取最小值，与arr[0]交换，第二次从arr[1]arr[n-1]中选取最小值，与arr[1]交换，第三次从arr[2]arr[n-1]中选取最小值，与arr[2]交换，…，第i次从arr[i-1]arr[n-1]中选取最小值，与arr[i-1]交换，…, 第n-1次从arr[n-2]~arr[n-1]中选取最小值，与arr[n-2]交换，总共通过n-1次，得到一个按排序码从小到大排列的有序序列。

示例图解
在这里插入图片描述
代码示例

//选择排序
public class SelectSort {
    public static void main(String[] args) {

        //测试选择排序的速度O(n^2),80000个随机数据  用时2s
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

        selectSort(arr);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);
//        int[] arr = {100,33,15,-1,125,1,2,16};
//        selectSort(arr);
//        System.out.println(Arrays.toString(arr));
    }

    //选择排序
    public static void selectSort(int[] arr) {
    //时间复杂度O(n^2)
        for (int j = 0; j < arr.length-1; j++) {
            int minIndex = j;
            int min = arr[j];
            for (int i = j+ 1; i < arr.length; i++) {
                if (min > arr[i]) {
                    minIndex=i;
                    min=arr[i];
                }
            }
            if (minIndex!=j) {
                arr[minIndex] = arr[j];
                arr[j] = min;
            }
        }
    }
}

插入排序

插入排序法思想
插入排序（Insertion Sorting）的基本思想是：把n个待排序的元素看成为一个有序表和一个无序表，开始时有序表中只包含一个元素，无序表中包含有n-1个元素，排序过程中每次从无序表中取出第一个元素，把它的排序码依次与有序表元素的排序码进行比较，将它插入到有序表中的适当位置，使之成为新的有序表。

示例图解
在这里插入图片描述
代码示例

//插入排序
public class InsertSort {
    public static void main(String[] args) {
        //测试插入排序的速度O(n^2),80000个随机数据  用时1s
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

        insertSort(arr);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);

       /* int[] arr = {124,1,16,11,-1,111};
        insertSort(arr);
        System.out.println(Arrays.toString(arr));*/
    }

    //插入排序
    public static void insertSort(int[] arr){
        for (int i = 0; i < arr.length-1; i++) {
            int insertVal = arr[i+1];
            int insertIndex = i ;
            // 给insertVal 找到插入的位置
            // 说明
            // 1. insertIndex >= 0 保证在给insertVal 找插入位置，不越界
            // 2. insertVal < arr[insertIndex] 待插入的数，还没有找到插入位置
            // 3. 就需要将 arr[insertIndex] 后移
            //必须是insertVal<arr[insertIndex] 不能是 arr[i+1]<arr[insertIndex]
            while (insertIndex >= 0 && insertVal<arr[insertIndex]){
                arr[insertIndex+1]=arr[insertIndex];
                insertIndex--;
            }
            // 当退出while循环时，说明插入的位置找到, insertIndex + 1
            //这里我们判断是否需要赋值
            if (insertIndex!=i){
                arr[insertIndex+1] = insertVal;
            }
        }
    }
}

希尔排序

我们看简单的插入排序可能存在的问题.

数组 arr = {2,3,4,5,6,1} 这时需要插入的数 1(最小), 这样的过程是：
{2,3,4,5,6,6}
{2,3,4,5,5,6}
{2,3,4,4,5,6}
{2,3,3,4,5,6}
{2,2,3,4,5,6}
{1,2,3,4,5,6}
结论: 当需要插入的数是较小的数时，后移的次数明显增多，对效率有影响.

希尔排序法介绍
希尔排序是希尔（Donald Shell）于1959年提出的一种排序算法。希尔排序也是一种插入排序，它是简单插入排序经过改进之后的一个更高效的版本，也称为缩小增量排序。

希尔排序法基本思想
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止

示例图解
在这里插入图片描述
代码示例

//希尔排序
public class ShellSort {
    public static void main(String[] args) {
        //测试希尔排序(交换法) 速度慢 要用移位法,80000个随机数据  用时10s
        //测试希尔排序(移位法)的速度O(n log n),80000个随机数据  用时1s不到
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

//        shellSort (arr); //交换法
        shellSort2 (arr); //移位法

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);

 /*       int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort(arr);
        System.out.println(Arrays.toString(arr));*/

 /*       int[] arr = {8, 9, 1, 7, 2, 3, 5, 4, 6, 0};
        shellSort2(arr);
        System.out.println(Arrays.toString(arr));*/
    }

    //希尔排序 交换法(速度慢 要用移位法)
    public static void shellSort(int[] arr) {
        int temp = 0;
        for (int i = arr.length / 2; i > 0; i /= 2) {
            //下面两个循环 重点
            for (int j = i; j < arr.length; j++) {
                for (int k = j - i; k >= 0; k -= i) {
                    if (arr[k] > arr[k + i]) {
                        temp = arr[k];
                        arr[k] = arr[k + i];
                        arr[k + i] = temp;
                    }
                }
            }
        }
    }

    //希尔排序 移位法
    public 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[i];
                if (arr[j - gap] > arr[j]) {
                    //重点 arr[j - gap] > temp 不能写成 arr[j - gap] > arr[j]
                    while (j - gap >= 0 && arr[j - gap] > temp) {
                        arr[j] = arr[j - gap];
                        j -= gap;
                    }
                    arr[j] = temp;
                }
            }
        }
    }
}

快速排序

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

示例图解
在这里插入图片描述

代码示例

//快速排序
public class QuickSort {
    public static void main(String[] args) {
        //快速排序 速度O(n log n),80000个随机数据  用时1s不到
   /*     int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

        quickSort (arr,0,arr.length-1);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);*/

        int[] arr = {-9, 80, 77, 110, 35, -576, 50};
        quickSort(arr, 0, arr.length - 1);
        System.out.println(Arrays.toString(arr));
    }

    public static void quickSort(int[] arr, int left, int right) {
        int l = left;
        int r = right;
        //pivot 中轴值
        int pivot = arr[(l + r) / 2];
        int temp = 0;
        //while循环的目的是让比pivot 值小放到左边
        //比pivot 值大放到右边
        while (l < r) {
            //在pivot的左边一直找,找到大于等于pivot值,才退出
            while (arr[l] < pivot) {
                l += 1;
            }
            //在pivot的右边一直找,找到小于等于pivot值,才退出
            while (arr[r] > pivot) {
                r -= 1;
            }
            //如果l >= r说明pivot 的左右两的值已经按照
            //左边全部是小于等于pivot值，右边全部是大于等于pivot值
            if (l >= r) {
                break;
            }
            //交换
            temp = arr[l];
            arr[l] = arr[r];
            arr[r] = temp;
            //如果交换完后，发现这个arr[l] == pivot值 相等 r--， 前移  防止相同的数死循环
            if (arr[l] == pivot) {
                r -= 1;
            }
            //如果交换完后，发现这个arr[r] == pivot值 相等 l++， 后移  防止相同的数死循环
            if (arr[r] == pivot) {
                l += 1;
            }
        }
        // 如果 l == r, 必须l++, r--, 否则为出现栈溢出
        if (l == r) {
            l++;
            r--;
        }
        //向左递归
        if (left < r) {
            quickSort(arr, left, r);
        }
        //向右递归
        if (right>l){
            quickSort(arr,l,right);
        }
    }
}

归并排序

归并排序介绍
归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。
示例图解
在这里插入图片描述
说明:
可以看到这种结构很像一棵完全二叉树，本文的归并排序我们采用递归去实现（也可采用迭代的方式去实现）。分阶段可以理解为就是递归拆分子序列的过程。

归并排序思想示意图2-合并相邻有序子序列:
再来看看治阶段，我们需要将两个已经有序的子序列合并成一个有序序列，比如上图中的最后一次合并，要将[4,5,7,8]和[1,2,3,6]两个已经有序的子序列，合并为最终序列[1,2,3,4,5,6,7,8]，来看下实现步骤
在这里插入图片描述
代码示例

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

        //归并排序 速度O(n log n),80000个随机数据  用时1s不到
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);
        int[] temp=new int[arr.length];
        mergetSort (arr,0,arr.length-1,temp);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);
    }

    //分+合
    public static void mergetSort(int[] arr,int left,int right,int[] temp){
        if (left<right){
            int mid =(left+right)/2;
            mergetSort(arr,left,mid,temp);
            mergetSort(arr,mid+1,right,temp);
            merget(arr,left,mid,right,temp);
        }
    }

    //合并的方法
    /**
     *
     * @param arr 排序的原始数组
     * @param left 左边有序序列的初始索引
     * @param mid 中间索引
     * @param right 右边索引
     * @param temp 做中转的数组
     */
    public static void merget(int[] arr,int left,int mid,int right,int[] temp){
        int i=left;
        int j=mid+1;
        int t = 0;

        while (i<=mid && j<=right){
            if (arr[i]<arr[j]){
                temp[t]=arr[i];
                t+=1;
                i+=1;
            }else {
                temp[t]=arr[j];
                t+=1;
                j+=1;
            }
        }

        while (i<=mid){
            temp[t]=arr[i];
            t+=1;
            i+=1;
        }
        while (j<=left){
            temp[t]=arr[j];
            t+=1;
            j+=1;
        }

        t=0;
        int leftTemp=left;
        while (leftTemp<=right){
        arr[leftTemp]=temp[t];
        leftTemp+=1;
        t+=1;
        }
    }
}

基数排序

基数排序(桶排序)介绍

  • 基数排序（radix sort）属于“分配式排序”（distribution sort），又称“桶子法”（bucket sort）或bin sort，顾名思义，它是通过键值的各个位的值，将要排序的元素分配至某些“桶”中，达到排序的作用
  • 基数排序法是属于稳定性的排序，基数排序法的是效率高的稳定性排序法
  • 基数排序(Radix Sort)是桶排序的扩展
  • 基数排序是1887年赫尔曼·何乐礼发明的。它是这样实现的：将整数按位数切割成不同的数字，然后按每个位数分别比较。

基数排序基本思想
将所有待比较数值统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后, 数列就变成一个有序序列。
这样说明，比较难理解，下面我们看一个图文解释，理解基数排序的步骤
示例图解
在这里插入图片描述
代码示例

//基数排序
public class RadixSort {
    public static void main(String[] args) {
        //基数排序 速度O(n*k) k指的是桶的个数,80000个随机数据  用时1s不到
        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

        radixSort (arr);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);

      /*  int[] arr = {52, 83, 5, 567, 16, 479, 28};
        radixSort(arr);
        System.out.println(Arrays.toString(arr));*/
    }

    //基数排序
    public static void radixSort(int[] arr) {
        //定义一个二维数组，表示10个桶, 每个桶就是一个一维数组
        int[][] bucket = new int[10][arr.length];
        //为了记录每个桶中，实际存放了多少个数据,我们定义一个一维数组来记录各个桶的每次放入的数据个数
        int[] bucketElementCounts = new int[10];

        //1. 得到数组中最大的数的位数
        int max = arr[0];
        for (int i = 0; i < arr.length; i++) {
            if (max<arr[i]){
                max=arr[i];
            }
        }
        int maxLength =(max+"").length();

        for (int k = 0, n=1; k < maxLength; k++,n*=10) {
        //(针对每个元素的对应位进行排序处理)， 第一次是个位，第二次是十位，第三次是百位..
            for (int i = 0; i < arr.length; i++) {
//                int tempOfElement = arr[i] % 10 ^ k / 10;
                //取出每个元素的对应位的值
                int tempOfElement = arr[i] / n % 10;
                //放入到对应的桶中
                bucket[tempOfElement][bucketElementCounts[tempOfElement]] = arr[i];
                bucketElementCounts[tempOfElement]++;
            }
            //按照这个桶的顺序(一维数组的下标依次取出数据，放入原来数组)
            int index = 0;
            for (int i = 0; i < bucketElementCounts.length; i++) {
                //如果桶中，有数据，我们才放入到原数组
                if (bucketElementCounts[i] != 0) {
                    for (int j = 0; j < bucketElementCounts[i]; j++) {
                        arr[index++] = bucket[i][j];
                    }
                    bucketElementCounts[i] = 0;
                }
            }
        }
    }
}

堆排序

基本结束

  • 堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(nlogn)，它也是不稳定排序。
    -堆是具有以下性质的完全二叉树：每个结点的值都大于或等于其左右孩子结点的值，称为大顶堆, 注意 : 没有要求结点的左孩子的值和右孩子的值的大小关系。

  • 每个结点的值都小于或等于其左右孩子结点的值，称为小顶堆

  • 大顶堆举例说明:
    在这里插入图片描述

  • 小顶堆举例说明:
    在这里插入图片描述

基本思想

1.将待排序序列构造成一个大顶堆
2.此时，整个序列的最大值就是堆顶的根节点。
3.将其与末尾元素进行交换，此时末尾就为最大值。
4.然后将剩余n-1个元素重新构造成一个堆，这样会得到n个元素的次小值。如此反复执行，便能得到一个有序序列了。

可以看到在构建大顶堆的过程中，元素的个数逐渐减少，最后就得到一个有序序列了.

图解说明
在这里插入图片描述

代码实现

/**
 * @author haowu
 * @create 2022-06-26-23:39
 * @Description 堆排序
 */
public class HeapSort {
    public static void main(String[] args) {
        //int[] arr = {4,6,8,5,9};
        //heapSort(arr);

        int[] arr=new int[80000];
        for (int i = 0; i < 80000; i++) {
            arr[i] = (int) (Math.random() * 8000000); //生成[0,8000000)随机数
        }
        Date date = new Date();
        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = simpleDateFormat.format(date);
        System.out.println("排序前的时间: "+format);

        heapSort(arr);

        Date date1 = new Date();
        String format1 = simpleDateFormat.format(date1);
        System.out.println("排序前的时间: "+format1);
    }

    //编写一个堆排序的方式
    public static void heapSort(int[] arr){
        System.out.println("堆排序");
        int temp = 0;
        for (int i = arr.length/2-1; i >=0; i--) {
            handleHeap(arr,i,arr.length);
        }
        for (int j = arr.length-1; j >0; j--) {
            temp = arr[0];
            arr[0] = arr[j];
            arr[j]  = temp;
            handleHeap(arr,0,j);
        }
        System.out.println(Arrays.toString(arr));
    }

    //将一个数组(二叉树),调整成大顶堆
    public static void handleHeap(int arr[],int i, int lenght){
        int temp = arr[i];
        for (int k = 2*i+1; k < lenght; k=2*k+1) {
            if (k+1<lenght && arr[k]<arr[k+1]){
                k++;
            }
            if (arr[k]>temp){
                arr[i] = arr[k];
                i = k;
            }else {
            break;
            }
            arr[i] =temp;
        }
    }
}

常用排序算法总结和对比

在这里插入图片描述

相关术语解释：
稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；
不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；
内排序：所有排序操作都在内存中完成；
外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；
时间复杂度： 一个算法执行所耗费的时间。
空间复杂度：运行完一个程序所需内存的大小。
n: 数据规模
k: “桶”的个数
In-place: 不占用额外内存
Out-place: 占用额外内存

虚火徉攻
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
leetcode备忘录系统-Algorithms-DataStructures:算法-数据结构
06-30
leetcode备忘录系统算法-数据结构 两个不错的排序算法及其 Big-O（完成） 归并排序 快速排序 冒泡排序 基本数据结构实现及其 Big-O 复杂性 哈希图 堆 队列 双端队列双端队列 链表 反转链表 合并两个排序列表 回文...
python使用tkinter实现简单有界面的备忘录
04-22
此外，这个应用还可以扩展，比如添加文件保存和加载功能，或者实现更复杂的搜索和排序算法。 总结，使用Tkinter创建备忘录应用涉及以下知识点： 1. Tkinter库的导入与使用。 2. GUI元素（如窗口、按钮、文本框、...
常用八大排序算法
qq_41937438的博客
10-31 272
冒泡排序 基本介绍： 冒泡排序（Bubble Sorting）的基本思想是：通过对待 排序序列从前向后（从下标较小的元素开始）,依次比较 相邻元素的值，若发现逆序则交换，使值较大 的元素逐渐从前移向后部，就象水底下的气泡一样逐渐 向上冒。 优化： 因为排序的过程中，各元素不断接近自己的位置，如果一趟比较下 来没有进行过交换，就说明序列有序，因此要在排序过程中设置 一个标志flag判断元素是否进行过...
数据结构与算法之简单排序算法
XDE_miao的博客
10-08 143
简单选择排序法就是通过n-i次关键字间的比较，从n-i+1个记录中选出关键字最小的记录，并和第i个记录交换。 通俗得讲，每一趟从待排序的数据元素中选择最小（或最大）的一个元素作为首元素，直到所有元素排完为止，简单选择排序是不稳定排序。 #define N 5 int a[N] = {12,56,80,91,20}; void swap(int *a, int *b) { int temp; temp = *a; *a = *b; *b = temp; } v
数据结构笔记-简单排序算法-选择排序
qq_55059421的博客
07-23 386
简单排序算法，最简单的排序算法，一般也都是学习C语言中第一个接触的算法。
八大排序算法图示
guanhang89的专栏
03-09 591
详见：这里
数据结构与算法------选择排序
最新发布
flying0916的博客
10-23 106
选择排序
android-shuffle 备忘录源代码
10-30
【标题解析】 "android-shuffle 备忘录源代码" 这个标题指的是一个针对Android...同时，对于想要深入理解“shuffle”功能实现的开发者，可以仔细研究相关代码，学习如何实现随机化算法并将其应用于备忘录的展示或排序。
基本排序算法及其在MapReduce的应用
02-01
该文档为学习基本排序算法过程中的学习笔记，大部分内容从网络上其他渠道也能得到，仅用于记录备忘之用。冒泡、选择、插入三种作为基本的排序算法是必须要掌握的，而在MapReduce的实际应用中。在Map阶段，k-v溢写时...
leetcode备忘录系统-LeetCode:力码
06-30
这些编号通常对应于LeetCode网站上的题目ID，按照编号顺序，我们可以推断出这个备忘录系统至少包括了近2000个编程挑战，覆盖了初级到高级的各种编程题目类型，如数组、字符串、链表、树、图、排序、搜索等。...
数据结构——快速排序
weixin_34413103的博客
03-15 81
系列文章：数据结构与算法系列——从菜鸟到入门 描述 快速排序是基于分治模式的，下面按分治模式来进行分析： 分解： 　　数组 A[p..r]被划分成两个（可能空）子数组，A[p..q-1]和 A[q+1..r]，使得 A[p..q-1]中的每个元素都小于等于 A(q)，也小于等于 A[q+1..r]中的元素。 解决： 　　递归的对子数组 A[p..q-1]和 A[q+1..r]进行再排序...
数据结构排序之快速排序
Jlzlight
10-28 711
一、快速排序思想 1、对未排序的序列进行下标的分配，左指针low和右指针high分别指向最低和最高下标 2、从序列右侧下标为high的元素开始，与标准元素60进行比较，若小于60，就将严肃放置在low指定的位置，并且将low向右移动一位    3、从序列左面下标为low的元素开始，与标准元素60进行比较，若大于60，就将元素放置在high指定的位置，并且将high向左移动一位
数据结构排序算法之快速排序
andy2541的博客
04-12 145
　　排序算法包括很多种，其中快速排序是其中一种比较快的排序算法，今天就来介绍一下： 　　快速排序的基本实现思想就是将当前待排序列分成两个部分、一个值。一个值：就是选定出一个值作为被比较的元素。两个部分：所有比该被选定元素大的部分都去该元素的右边，所有比被选定元素小的部分都去该元素的左边。这样我们就确定了该元素在这个待排序列中的位置，其实也就是我们已经将这个元素“排好了”。 　　那么，...
数据结构与算法——快速排序
04-23 505
每次看大牛的博客都有一种感想：啥时候我也能成为大牛。。。。。插入一个：上两篇文章分别介绍了选择排序和冒泡排序，其思想都差不多，只是选择排序是比较完所有数据后确定最小的数再交换，而冒泡排序是比较相邻的两个数如果顺序不对就要交换：两者的时间复杂度都是o（n2） 下面是我在数组里面存在相同数据的结果：选择排序和冒泡排序的结果 选择排序的结果： 第1次排序结果：1 33 12 45 23 68 33
排序算法 - 快速排序详解
张大安的博客
05-08 1203
基本思想 对于一组数据，选择一个基准元素（base），通常选择第一个或最后一个元素，通过一轮扫描，比base小的元素都在base左边，比base大的元素都在base右边，对左右子序列用相同的方法递归排序，直到序列中所有数据均有序为止。 快速排序，说白了就是给基准数据找其正确索引位置的过程。 思路图解 以 [19,97,09,17,01,08] 为例，以第一个元素19为base，定义左右两个指针 L和 R，分别从两端开始扫描。从右向左找比19小的数，替换L所在位置的元素。再从左往右找比19大的数，然后替换
数据结构——排序
lfm1010123的博客
06-15 552
对于一组待排序的数据，数据中有两个或两个以上的相同的元素，在经过排序后，这两个或两个以上的相同元素与之前未排序的顺序相同，则说明此排序操作是稳定的。举例说明：在下图中，待排序数据 ① 经过排序成为 ② ，我们发现绿色数字5和红色数字5与排序前的顺序并未发生改变，那么排序 ② 就是稳定的。 反之，排序 ③ 就是不稳定的。 思路：从数组的第二个元素开始，遍历数组，不断地与数组第一个元素进行比较。 输出结果： 希尔排序本质上就是直接插入排序，只不过对其进行了分组。当我们给定了一组数据，直接插入排序直接对这组数据进
MMR 排序多样化重排序算法
weixin_42357472的博客
07-07 797
参考：https://zhuanlan.zhihu.com/p/102285855 https://blog.csdn.net/Mercedes_wwz/article/details/109028124 sim1是query与doc的相关权重；sim2是docs之间的相关权重 或
【数据结构】常见的排序方法
kdjjdjdjjejje128的博客
08-31 817
排序
深入浅出理解排序算法系列（一） 排序算法概述
Horace_hr的博客
08-09 564
概述：       排序（又称分类、整序）是指将无序序列排成一个有序序列（由小到大或由大到小）的运算。用于作为排序依据的数据项称为关键词，也就说排序算法是基于关键词从小到大或从大到小进行排序的。 本系列的文章包含： 1、排序算法概述 2、插入排序的实现方法及性能分析 3、交换排序的实现方法及性能分析 4、选择排序的实现方法及性能分析 5、归并排序的实现方法及性能分析 6、基数排序的...
数据结构课程设计(内部排序算法性能分析).doc
05-30
其次，数据结构课程设计的内容通常包括以下几个方面：基本概念和术语、线性表、栈和队列、树和二叉树、图、排序和查找算法等。学生将通过这些内容了解数据结构的基本概念和操作方式，学会如何使用数据结构来组织和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值