排序-算法

已于 2023-10-15 22:40:15 修改
阅读量481 收藏 3
点赞数 3
分类专栏： 初阶数据结构-Java 文章标签： 算法 java 数据结构 排序算法 开发语言
于 2023-10-15 22:36:04 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64668629/article/details/133802595
版权

文章目录

一、排序的概念及引用

1.1 排序概念

排序：使一串数据，按照其中某个或某些关键字的大小，递增或递减排列起来的操作。（本文所讲排序都是按升序排列。）
稳定性：假设在待排序的记录序列中，存在多个具有相同的关键字，若经过排序，这些数据的相对次序保持不变，即在原序列中，r[i]=r[j]，且r[i]在r[j]之前，而在排序后的序列中，r[i]仍在r[j]之前，则称这种排序算法是稳定的；否则称为不稳定的。
在这里插入图片描述
内部排序：数据元素全部放在内存中的排序。
外部排序：数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。

1.2 排序运用

在这里插入图片描述

1.3 常见排序算法

在这里插入图片描述

二、常见排序算法的实现

2.1 插入排序

2.1.1 基本思想

把待排序的数据集合按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有数据插入完为止，得到一个新的有序序列。
在这里插入图片描述

2.1.2 直接插入排序

初始时，第一个元素为有序序列，从第二个元素i所指的值(tmp)开始，与前面的有序序列的末尾下标j所指值开始进行比较，如果j所指的值大于tmp，j所指元素向后移，直到j所指的值小于等于tmp，j后一位存放tmp，i向后走重复上述步骤。
在这里插入图片描述

public static void insertSort(int[] array){
        for(int i = 1;i < array.length; i++){
            int j = i-1;
            int tmp = array[i];
            for(;j >= 0;j--){
                if(array[j] > tmp){
                    array[j+1] = array[j];
                }else {
                    break;
                }
            }
            array[j+1] = tmp;
        }
    }

直接插入排序的特性总结：
1. 元素集合越有序，算法的时间效率越高 ，适用于待排序序列 已经基本上趋于有序了
2. 时间复杂度：最坏情况O(N^2) 最好情况O(N)
3. 空间复杂度：O(1)
4. 稳定性：稳定

2.1.3 希尔排序

希尔排序法又称缩小增量法，基本思想：先选定一个整数gab，把待排序集合中所有元素分成多个组，所有距离为gab的元素分在同一组，并对每一组内的记录进行插入排序。然后设定一个新的整数，重复上述分组和排序的工作。当到达=1时，所有记录在一组内排好序。
在这里插入图片描述

/**
* 希尔排序
*/
public static void shellSort(int[] array){
     int gab = array.length;
     while (gab >1){
         gab /= 2;
         shell(array,gab);
     }

}
/**
* 将array分为gab组进行插入排序
*/
private static void shell(int[] array,int gab){
     for (int i = gab; i < array.length; i++) {
         int j = i-gab;
         int tmp = array[i];
         for (;j >= 0; j -= gab){
             if (array[j] > tmp){
                 array[j+gab] = array[j];
             }else {
                 break;
             }
         }
         array[j+gab] = tmp;
     }
}

希尔排序的特性总结：

  1. 希尔排序是对直接插入排序的优化。
  2. 当gap > 1时都是预排序，目的是让集合更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。
  3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，因此在好些树中给出的希尔排序的时间复杂度都不固定，按O(N1.25)到O(1.6*N1.25)来算
  4. 稳定性：不稳定

2.2 选择排序

2.2.1 基本思想

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

2.2.2 直接选择排序

以i=0遍历数组，从i开始的数中找到最小（大）值下标minindex（maxindex），minindex（maxindex）和i位置的值进行交换。
在这里插入图片描述

public static void selectSort(int[] array){
    for (int i = 0; i < array.length; i++) {
         //记录最小值下标
         int minindex = i;
         for (int j = i+1; j <array.length ; j++) {
             if (array[j] < array[minindex]){
                 minindex = j;
             }
         }
         //最小值不是i位置的数据
         if(minindex != i){
             swap(array,minindex,i);
         }
     }
}
//交换
private static void swap(int[] array,int i,int j) {
    int tmp = array[i];
    array[i] = array[j];
    array[j] = tmp;
}

双向选择排序：
1.从数组指定区间（left，right）内找到最小值和最值下标—minindex与maxindex
2.将其与区间端点值进行交换,缩小区间重复执行上述操作，直到区间只剩下一个元素
在这里插入图片描述

public static void selectSort(int[] array){
     int left = 0;
     int right = array.length-1;
     while(left < right){
         int minindex = left;
         int maxindex = left;
         for (int i = left; i <= right; i++) {
             if (array[i] < array[minindex]){
                 minindex = i;
             }
             if(array[i] > array[maxindex]){
                 maxindex = i;
             }
         }
         //走到这里，minindex和maxindex是区间（left，right）内的最小值和最值下标
         //最小值不是区间第一个元素
         if (minindex != left){
             swap(array,minindex,left);
         }
         swap(array,maxindex,right);
         left++;
         right--;
     }
}

直接选择排序的特性总结：

  1. 直接选择排序思考非常好理解，但是效率不是很好，实际中很少使用
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

2.2.3 堆排序

堆排序(Heapsort)是指利用堆积树（堆）这种数据结构所设计的一种排序算法，它是选择排序的一种。
步骤：
1.建堆----升序建大根堆，降序建小根堆
2.利用堆删除思想进行排序

public static void heapSort(int[] array){
    //创建大根堆
    createHeap(array);
    //利用堆删除思想进行排序
    int end = array.length-1;
    while(end > 0){
         swap(array,0,end);
         sifiDown(array,0,end);
         end--;
    }
}
/**
* 创建大根堆
*/
private static  void createHeap(int[] array){
    //从最后一颗子树开始向下调整
    for (int parent = (array.length-1)/2; parent >=0 ; parent--) {
         sifiDown(array,parent,array.length);
    }
}
/**
* 向下调整
*/
private static void sifiDown(int[] array,int parent,int length){
     int child = 2*parent+1;
     //至少存在左孩子
     while(child < length){
        //存在右孩子 且 右孩子值大于左孩子
        if(child+1 < length && array[child] < array[child+1]){
            child++;
        }
        //走到这里，child是孩子节点最大值的下标
        //父亲节点的值小于最大孩子节点值
        if(array[parent] < array[child]){
             swap(array,parent,child);
             //子树向下调整
             parent = child;
             child = parent*2+1;
         }else {
             break;
         }
     }
}

堆排序的特性总结：

  1. 堆排序使用堆来选数，效率就高了很多。
  2. 时间复杂度：O(N* log ⁡ 2 N \log_{2}N log2​N)
  3. 空间复杂度：O(1)
  4. 稳定性：不稳定

2.3 交换排序

基本思想：比较序列中两个值，如果不满足排序要求，交换两个值，交换排序的特点是：将值较大的向序列的尾部移动，值较小的向序列的前部移动。

2.3.1 冒泡排序

j遍历集合，j和j+1对应的值比较，如果j对应值大于j+1对应值，交换，j向后走直至j指向最后一个元素，一趟排序结束，需要比较n-1趟，冒泡排序特点：每一趟确定一个数的位置且位置在待排序序列最后，下一趟就可以少比较一个数，趟数为n-1（n是集合中元素的个数），如果本趟没有进行交换，说明集合已经排好序。
在这里插入图片描述

public static void bubbleSort(int[] array){
    //i表示趟数
    for (int i = 0; i < array.length-1; i++) {
        boolean flog = false;
        for (int j = 0; j < array.length-1-i; j++) {
            if(array[j] > array[j+1]){
                swap(array,j,j+1);
                flog = true;
            }
        }
        if(!flog){
            break;
        }
    }
}
    //交换
    private static void swap(int[] array,int i,int j) {
        int tmp = array[i];
        array[i] = array[j];
        array[j] = tmp;
    }

冒泡排序的特性总结：

  1. 冒泡排序是一种非常容易理解的排序
  2. 时间复杂度：O(N^2)
  3. 空间复杂度：O(1)
  4. 稳定性：稳定

2.3.2 快速排序

以区间内第一个数为基准值，将整个区间划分为两个子序列，左子序列都是比基准值小的数，右子序列都是比基准值大的数；对左、右子序列为新的区间进行前面操作，直至区间只存在一个元素。

public static void quick(int[] array,int left,int right){
        //区间不存在或区间只有一个元素
        if(left >= right){
            return;
        }
        //按基准值对数组的（left，right）区间进行划分 并返回基准值所在下标
        int pivot = partion(array,left,right);
        //对数组的（left，pivot）区间进行快速排序
        quick(array,left,pivot-1);
        //对数组的（pivot+1，right）区间进行快速排序
        quick(array,pivot+1,right);
    }

将区间按照基准值划分为左右两半部分的常见方式有：
1. Hoare 版
在这里插入图片描述

private static int partion(int[] array,int left,int right){
        int tmp = array[left];
        int i = left;
        while(left < right){
            while (left < right && array[right] >=tmp){
                right--;
            }
            while(left < right && array[left] <= tmp){
                left++;
            }
            swap(array,left,right);
        }
        swap(array,i,left);
        return left;
    }

2. 挖坑法
在这里插入图片描述
在这里插入图片描述

private static int partion(int[] array,int left,int right){
        int tmp = array[left];
        while (left < right){
            while (left < right && array[right] > tmp){
                right--;
            }
            //走到这，right是比基准值小的下标或left == right
            array[left] = array[right];
            while (left < right && array[left] <tmp){
                left++;
            }
            //走到这，left是比基准值大的下标或left == right
            array[right] = array[left];
        }
        //基准值放入坑中
        array[left] = tmp;
        return  left;
    }

3. 前后指针法
在这里插入图片描述
写法一

private static int partion(int[] array,int left,int right){
    int prev = left;
    int cur = left+1;
    while (cur <= right){
       if(array[cur] < array[left] && array[++prev] != array[cur]){
            swap(array,cur,prev);
       }
       cur++;
   }
   swap(array,left,prev);
   return prev;
}

写法二

private static int partition(int[] array, int left, int right) {
	int d = left + 1;
	int pivot = array[left];
	for (int i = left + 1; i <= right; i++) {
		if (array[i] < pivot) {
			swap(array, i, d);
			d++;
		}
	}
	swap(array, d - 1, left);
	return d - 1;
}

2.3.3 快速排序优化

1.三数取中法选key
在下标为left（区间第一个数下标）、right（区间最后一个数下标）和mid（区间中间数下标）对应数值中找到中间数，与区间第一个数进行交换，使得以基准值（区间第一个数）划分的尽可能使左右区间都超过一个数，从而减少递归次数。

private static void quick(int[] array,int start,int end) {
    if(start >= end) {
        return;
    }
    //1 2 3 4 5 6 7
    int index = middleNum(array,start,end);
    swap(array,index,start);
    //4 2 3 1 5 6 7

    int pivot = partition(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}
/**
* 求中位数的下标
*/
private static int middleNum(int[] array,int left,int right) {
    int mid = (left+right)/2;
    if(array[left] < array[right]) {
       if(array[mid] < array[left]) {
            return left;
       }else if(array[mid] > array[right]) {
            return right;
        }else {
            return mid;
        }
    }else {
        //array[left] > array[right]
        if(array[mid] < array[right]) {
            return right;
        }else if(array[mid] > array[left]) {
            return left;
        }else {
            return mid;
        }
    }
}

2. 递归到小的子区间时，可以考虑使用插入排序

private static void quick(int[] array,int start,int end) {
    if(start >= end) {
        return;
    }
	//区间比较小
    if(end - start + 1 <= 15) {
        insertSort(array, start, end);
        return;
    }
    int pivot = partition(array,start,end);
    quick(array,start,pivot-1);
    quick(array,pivot+1,end);
}
public static void insertSort(int[] array,int left,int right) {
    for (int i = left+1; i <= right; i++) {
        int tmp = array[i];
        int j = i-1;
        for (; j >= left ; j--) {
            if(array[j] > tmp) {
                array[j+1] = array[j];
            }else {
                break;
            }
        }
        array[j+1] = tmp;
    }
}

2.3.4 快速排序非递归

在这里插入图片描述

/**
    快速排序非递归
*/
public static void quickSortNor(int[] array){
    int start = 0;
    int end = array.length-1;
    //存放要排序的区间端点下标
    Stack<Integer> stack = new Stack<>();
    //基准值下标
    int privot = partion(array,start,end);
    //基准值的左边（左区间）的元素至少有2个
    if(privot-1 > start){
        stack.push(start);
        stack.push(privot-1);
    }
    //基准值的右边（右区间）的元素至少有2个
    if(privot+1 < end){
        stack.push(privot+1);
        stack.push(end);
    }
    while ( !stack.isEmpty()){
        end = stack.pop();
        start = stack.pop();
        privot = partion(array,start,end);
        //基准值的左边（左区间）的元素至少有2个
        if(privot-1 > start){
            stack.push(start);
            stack.push(privot-1);
        }
        //基准值的右边（右区间）的元素至少有2个
        if(privot+1 < end){
             stack.push(privot+1);
             stack.push(end);
        }
    }
}

快速排序总结：
1.快速排序整体的综合性能和使用场景都比较好
2.时间复杂度：O(N*logN)
3. 空间复杂度：O(logN)
4. 稳定性：不稳定

2.4 归并排序

2.4.1 基本思想

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法。将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表，称为二路归并。
在这里插入图片描述
在这里插入图片描述

/**
      递归实现排序
  */
 public static void mergeSort(int[] array){
      merge(array,0,array.length-1);
}
private static void merge(int[] array, int left, int right) {
      if(left >= right){
          return;
      }
      int mid = (left + right)/ 2;
      //划分为两组
      merge(array,left,mid);
      merge(array,mid+1,right);
      //合并
      combine(array,left,mid,right);
}
/**
     合并两个有序数组
*/
private static void combine(int[] array, int left, int mid, int right) {
     //第一个数组的区间端点下标
     int s1 = left;
     int e1 = mid;
     //第二个数组的区间端点下标
     int s2 = mid+1;
     int e2 = right;
     //新数组的长度
     int length = right-left+1;
     int[] arr = new int[length];
     //新数组下标
     int k = 0;
     //合并
     while( s1 <= e1 && s2 <= e2){
         if(array[s1] < array[s2]){
             arr[k++] = array[s1++];
         }else {
             arr[k++] = array[s2++];
         }
     }
     while (s1 <= e1){
         arr[k++] = array[s1++];
    }
    while (s2 <= e2){
        arr[k++] = array[s2++];
    }
    //将合并的新数组放入原来数组对应位置
    for (int i = 0; i < arr.length; i++) {
         array[i+left] = arr[i];
    }
}`

//非递归
public static void mergeSortNor(int[] array){
     //每个子序列元素个数
     int gap = 1;
     while( gap < array.length){
         for (int i = 0; i < array.length; i+=gap*2) {
             //left 代表一组的第一个元素下标
             int left = i;
             //mid 代表此组最后一个元素下标
             int mid = left+gap-1;
             if(mid >= array.length){
                 mid = array.length-1;
             }
             //right 代表下一组的最后一个元素下标
             int right = mid+gap;
             if(right >= array.length){
                 right = array.length-1;
             }
             combine(array,left,mid,right);
         }
         gap *= 2;
     }
}

归并排序总结：

  1. 归并的缺点在于需要O(N)的空间复杂度，归并排序更多是解决在磁盘中的外排序问题
  2. 时间复杂度: O(N*logN)
  3. 空间复杂度：O(logN)
  4. 稳定性：稳定

2.4.2 海量数据的排序问题

外部排序：排序过程需要在磁盘等外部存储进行的排序
前提：内存只有 1G，需要排序的数据有 100G
因为内存中因为无法把所有数据全部放下，所以需要外部排序，而归并排序是最常用的外部排序

  1. 先把文件切分成 200 份，每个 512 M
  2. 分别对 512 M 排序，因为内存已经可以放的下，所以任意排序方式都可以
  3. 进行 2路归并，同时对 200 份有序文件做归并过程，最终结果就有序了

三、排序算法复杂度及稳定性分析

在这里插入图片描述

在这里插入图片描述

四、其他非基于比较排序

1.计数排序

计数排序以数组来实现，数组的下标是待排序序列值，数组存储的是元素出现的个数。操作步骤：

  1. 统计待排序序列中各个元素的个数到新数组
  2. 遍历新数组，将原序列进行覆盖
public static void countSort(int[] array){
    //获取集合中的最大值和最小值
    int minvalue = array[0];
    int maxvalue = array[0];
    for (int i = 0; i < array.length; i++) {
        if(array[i] < minvalue){
            minvalue = array[i];
        }
        if(array[i] > maxvalue){
            maxvalue = array[i];
        }
    }
    //新建数组长度
    int length = maxvalue-minvalue+1;
    //以数组值存储元素的个数，数组的下标值为元素值-minvalue的结果
    int[] count = new int[length];
    //记录集合中元素个数
    for (int i = 0; i < array.length; i++) {
        count[array[i]-minvalue]++;
    }
    //array下标
    int k = 0;
    //遍历count数组，将实际值重写回array中
    for (int i = 0; i < count.length; i++) {
        while( count[i] > 0){
            array[k++] = i+minvalue;
            count[i]--;
        }
    }
}

计数排序总结：
3. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
4. 时间复杂度：O(MAX(N,范围))
5. 空间复杂度：O(范围)
6. 稳定性：稳定

2.基数排序

基数排序

3.桶排序

桶排序

五.选择题

1. 快速排序算法是基于()的一个排序算法。
A：分治法   B：贪心法   C：递归法   D：动态规划法
2.对记录（54,38,96,23,15,72,60,45,83）进行从小到大的直接插入排序时，当把第8个记录45插入到有序表时，为找到插入位置需比较()次？（采用从后往前比较）
A: 3  B: 4  C: 5  D: 6
3.以下排序方式中占用O(n)辅助存储空间的是()
A: 简单排序  B: 快速排序  C: 堆排序  D: 归并排序
4.下列排序算法中稳定且时间复杂度为O(n^2)的是()
A: 快速排序  B: 冒泡排序  C: 直接选择排序  D: 归并排序
5.关于排序，下面说法不正确的是()
A: 快排时间复杂度为O(N*logN)，空间复杂度为O(logN)
B: 归并排序是一种稳定的排序,堆排序和快排均不稳定
C: 序列基本有序时，快排退化成 "冒泡排序"，直接插入排序最快
D: 归并排序空间复杂度为O(N), 堆排序空间复杂度的为O(logN)
6.设一组初始记录关键字序列为(65,56,72,99,86,25,34,66)，则以第一个关键字65为基准而得到的一趟快速排序结果是（）
A: 34，56，25，65，86，99，72，66  B: 25，34，56，65，99，86，72，66
C: 34，56，25，65，66，99，86，72  D: 34，56，25，65，99，86，72，66


答案：1.A  2.C  3.D  4.B  5.D  6.A
羽翼~
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
快速排序-算法.zip
03-22
快速排序算法
快速排序-算法报告.doc
04-14
算法设计与分析课程，算法实验报告，基于python。涉及快速排序及其改进算法：三路快排。设置"重复率的参数"，通过实验可以看到，重复率越高，改进性能越好。
十大经典排序算法-归并排序算法详解
qq_35344198的博客
06-19 11万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
十大经典排序算法-快速排序算法详解
qq_35344198的博客
06-16 8万+
一、什么是快速排序 1.概念 快速排序（Quick Sort）是从冒泡排序算法演变而来的，实际上是在冒泡排序基础上的递归分治法。快速排序在每一轮挑选一个基准元素，并让其他比它大的元素移动到数列一边，比它小的元素移动到数列的另一边，从而把数列拆解成了两个部分 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照快速排序的思想，我们先选择一个基准元素，进行排序 我们选取4为我们的基准元素，并设置基准元素的位置为index，设置两个指针left和right，分别指向最左
常用十大排序算法
热门推荐
qq_51664685的博客
04-26 12万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
程序员那些必须掌握的排序算法(上)
。。。
08-17 8万+
现在的IT行业并不像以前那么好混了，从业人员过多，导致初级程序员过剩，这也间接导致了公司的招聘门槛越来越高，要求程序员掌握的知识也越来越多。 算法也是一个争论了很久的话题，程序员到底该不该掌握算法？不同的人有不同的答案，而事实上，很多公司都对算法有一定的要求，有些公司直接在面试的时候便会要求面试者手写算法题。这就对程序员的技术要求产生了很大的考验，所以面对如今的大环境，我们必须掌握算法，才能在今后...
C语言的5种简单排序算法
Finecsr的博客
04-27 5万+
基本概要： 本文主要介绍五种简单常用的排序算法：冒泡排序，快速排序，插入排序，选择排序，希尔排序，包括它们的基本思想和代码实现。值得一说的是：插入排序，冒泡排序，选择排序平均情况下的时间复杂度为，因此在排序数据较少的情况下较好；而希尔排序和快速排序的平均时间复杂度为，因此在排序数据较多的情况下较好，但是对于快速排序而言，数据基本有序时反而不好，接下来会详细阐述。 1.冒泡排序（Bubble Sort） 基本思想： 冒泡排序是一个非常好理解的排序，顾名思义——冒泡，此时将要排序的数据从上至下排列，从最
十大经典排序算法-冒泡排序算法详解
qq_35344198的博客
05-30 2万+
一、什么是冒泡排序 1.概念 冒泡排序（Bubble Sort）是排序算法里面比较简单的一个排序。它重复地走访要排序的数列，一次比较两个数据元素，如果顺序不对则进行交换，并一直重复这样的走访操作，直到没有要交换的数据元素为止。 2.算法原理 这是一个无序数列：1、5、4、2、6、3，我们要将它按从小到大排序。按照冒泡排序的思想，我们要把相邻的元素两两比较，根据大小来交换元素的位置 首先开始第一轮比较 第一步：比较1和5，1比5小，顺序正确，元素位置不变 第二步：比较5和4，5比4大，顺序错误，交换元素位置
七大排序算法
yahid的博客
06-28 1万+
排序：排序就是对某项数据按照特定的要求，比如大小或字符长短等按照升序或降序排序。排序过程中设计稳定性，稳定性指的是若有两个相同的数字，比如1和1。如果排序前1在1的前面，排完序后1还在1的前面。那么就说这个排序算法是稳定的，相反则说明不稳定。注意：如果本身就是一个稳定的排序，可以将其变成不稳定排序；如果本身就是不稳定排序，不能变成稳定的排序。常见的排序方法 上面是基于比较的排序。下面一个一个的分析一：直接插入排序 直接插入排序指的是将新的数据插入在已经排好序的序列中。比如我们生活中的玩的斗地主，我们需要将新
排序算法-算法时间复杂度和空间复杂度概念 详细讲解
舒克日记的博客
05-06 2800
排序算法-算法时间复杂度和空间复杂度概念 详细讲解 排序算法的介绍 排序也称排序算法(Sort Algorithm)，排序是将一组数据，依指定的顺序进行排列的过程。 排序的分类： 1)内部排序： 指将需要处理的所有数据都加载到内部存储器内存中进行排序。 2)外部排序法： 数据量过大，无法全部加载到内存中，需要借助外部存储文件进行排序。 3)常见的排序算法分类（见下图）： 算法的时间复杂度 度量一个程序（算法）执行时间的两种方法 1)事后统计的方法这种方法可行，但是有两个问题：一是要想对设计的算法的运行性能
排序算法--选择排序--详解及代码
lzzw的学习之路
07-31 5万+
选择排序： 选择排序（ Selection sort）是一种简单直观的排序算法。它的工作原理是每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，直到全部待排序的数据元素排完。 选择排序算法通过选择和交换来实现排序，其排序流程如下： （1）首先从原始数组中选择最小的1个数据，将其和位于第1个位置的数据交换。 （2）接着从剩下的n-1个数据中选择次小的...
排序算法 - 归并排序详解
张大安的博客
05-09 4456
基本介绍 归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。 基本思想 将序列中待排序数字分为若干组，最终每个数字分为一组。（默认长度为1的序列是有序的） 将若干个组两两合并，保证合并后的组是有序的。（俩个子序列头部进行比较大小） 重复第二步操作直到只剩下一组，排序完成。 归并排序思想示
排序代码-算法
03-03
排序算法可以和冒泡排序比较来学习，希望学习本资源的可以在越来越厉害
最快的排序算法 谁才是最强的排序算法：快速排序-归并排序-堆排序，排序算法数据结构
04-07
最快的排序算法 谁才是最强的排序算法：快速排序-归并排序-堆排序，排序算法数据结构
c++排序算法-冒泡排序
11-08
冒泡排序
生信算法7 - 核酸序列Fasta和蛋白PDB文件读写与检索
LittleComputerRobot的博客
06-03 336
核酸序列Fasta和蛋白PDB文件读写与检索
回溯之分割回文串
JINbigXIA的博客
06-04 135
思路：直接看回溯函数的内容，首先我们是取段的，如果这一段不行那就往后面加1，直到加道循环结束。如果可以取端，并且取到了最后一段，也就是开始的startIndex大于等于size那么就代表这一条都是回文字符串。然后需要一个判断函数，判断字符串是否为回文字符串，如果是往path里面加。学到的新函数：array.substr( a ,b) a表示字符串的开始，b表示数量 含义：选取字符串array从a开始往后的b个数。难点：这里用到一个很取段的思路，其实和取点的内容差不多，但是取端更难理解。
Python插入排序
youyouxiong的博客
06-05 105
插入排序是一种简单的排序算法，它通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后向前扫描过程中，需要移动元素以腾出空间。插入排序的时间复杂度是O(n^2)，其中n是数组的长度。在最好的情况下（输入数组已经是排序的），时间复杂度是O(n)。插入排序对于小数据集或基本有序的数据集来说效率很高，但对于大数据集，效率较低。
N叉树的层序遍历-力扣
最新发布
why_12134的博客
06-05 187
本题同样是二叉树的层序遍历的扩展，只不过二叉树每个节点的子节点只有左右节点，而N叉树的子节点是一个数组，层序遍历到一个节点时，需要将这个节点的子节点数组的每个节点都入队。
嵌套循环算法时间复杂度？排序-合并算法时间复杂度？
05-17
1. 嵌套循环算法的时间复杂度是 O(n^2)，其中 n 表示数据规模，因为嵌套循环会对数据进行 n * n 次操作。 2. 排序-合并算法的时间复杂度是 O(n log n)，其中 n 表示数据规模，因为排序算法的时间复杂度是 O(n log n)，而合并算法的时间复杂度也是 O(n log n)。因此，整个排序-合并算法的时间复杂度是 O(n log n)。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值