经典排序算法总结

最新推荐文章于 2024-08-19 15:21:18 发布
最新推荐文章于 2024-08-19 15:21:18 发布
阅读量1k 收藏 5
点赞数 1
分类专栏： 1. 算法 -------1.3. 算法研究 文章标签： 排序算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010416101/article/details/85220189
版权

排序算法总结

Author: Sean / Date:2018-12-11

排序的算法的分类标准有很多，最简单的事根据复杂度进行划分。分为简单排序和复杂排序。

简单排序
  • 简单选择排序
  • 简单插入排序
  • 冒泡排序
复杂排序
  • 希尔排序
  • 堆排序
  • 归并排序
  • 快速排序
应用实例
  • 应用实例1: Colletions.sort()方法实现
  • 应用实例2: 数据库Order By方法实现

当然，还有梳排序、计数排序、桶排序、基数排序等排序算法。后面的几种排序算法，使用不多，暂时概不提及。

简单排序

  • 简单选择排序(Selection Sort)

简单选择排序的思想是，每次从N-K+1个数中，选择最大/最小的数字放入第K个位置上。

排序细节:

原始数字: 6 5 3 1 8 7 2 4

(K=1 排列第1位) （1) 5 3 6 8 7 2 4

(K=2 排列第2位) (1 2) 3 6 8 7 5 4

(K=3 排列第3位) (1 2 3) 6 8 7 5 4

(K=4 排列第4位) (1 2 3 4) 8 7 5 6

(K=5 排列第5位) (1 2 3 4 5) 7 8 6

(K=6 排列第6位) (1 2 3 4 5 6) 8 7

(K=7 排列第7位) (1 2 3 4 5 6 7) 8

(K=8 排列第8位) (1 2 3 4 5 6 7 8)

### 伪代码

for i <- 1 to length(A)
   min <- i
   for j <- i + 1 to length(A){
   		if (A[min]>A[j]){
   			min <- j
   		}
   		j <- j + 1
   }

	// 选择排序
	public static boolean selectionSort(int array[]){
		boolean flag = false;  
		if(null != array && array.length > 0){
			// 每次确定array[i]的最终数字
			for(int i=0; i<array.length ; i++){
				int min = i;
				for(int j = i+1; j<array.length;j++){
					if(array[j]<array[min]){
						min = j;
					}
				}
			}
			flag = true;
		}
		return flag;
	}

最好情况:比较N-1,…1次，总计(N)(N-1)/2次,不用交换。

最坏情况:比较N-1,…1次，总计(N)(N-1)/2次,交换(N-1)次。

平均复杂度: 比较O(N^2)，交换O(N).

评价:不稳定排序，最好情况和最坏情况基本一致。复杂度O(N^2).复杂度和冒泡一致，但是基本上还是优于冒泡排序。

参考文献

[1] Wiki - selection sort

[2]

简单(直接)选择排序的稳定性？

举个栗子:(要求从小到大排序)
8 5 8 7 9
简单选择排序:
第二次外循环8和8的相对顺序就发生了改变,违反了稳定性的定义,故不稳定;

朴素的直接选择排序是不稳定的，这毫无疑问。当然可以写成稳定的版本。
稳定的排序：直接插入排序、冒泡排序、归并排序
不稳定的排序：希尔排序、直接选择排序、堆排序、快速排序

简单(直接)选择排序的稳定性？

  • 简单插入排序(Insertion Sort)

insertion-sort-gif

从第一个数字开始排序，每次让前K个数字变得有序。对于K+1个数字，依次与前K个数字进行比较，决定第K+1个数字的位置。

排序细节:

原始数字: 6 5 3 1 8 7 2 4

(K=1 排列数字6) 6

(K=2 排列数字5) 5 6

(K=3 排列数字3) 3 5 6

(K=4 排列数字1) 1 3 5 6

(K=5 排列数字8) 1 3 5 6 8

(K=6 排列数字7) 1 3 5 6 7 8

(K=7 排列数字2) 1 2 3 5 6 7 8

(K=8 排列数字4) 1 2 3 4 5 6 7 8

### 伪代码

for i ← 1 to length(A)
    j ← i
    while j > 0 and A[j-1] > A[j]
        swap A[j] and A[j-1]
        j ← j - 1


### Java代码

// 选择排序
	public static boolean insertionSort(int array[]){
		boolean flag = false;  
		if(null != array && array.length > 0){
			// 从array[0]开始排起，每次添加array[i]作为新元素插入
			for(int i=0;i<array.length;i++){
				int j = i;
				while(j > 0 && array[j] < array[j-1]){
					swap(array,j,j-1);
					j--;
				}
			}
			flag = true;
		}
		return flag;
	}

最好情况:比较N次，不用交换。复杂度O(N),交换O(N).

最坏情况:比较1,2,3 … N-2次,总计(N-1)(N-2)/2次。复杂度O(N2)，交换O(N2).

平均复杂度: 比较O(N2)，交换O(N2).

评价:同样O(N^2)的时间复杂度，直接插入排序比冒泡和选择排序性能稍微好一点。

  • 冒泡排序(Bubble Sort)

冒泡排序思想:两两比较相邻纪录的关键字。排序过程中，最小的数字像气泡一样慢慢浮上来，由此得名。冒泡排序的核心在于相邻的数字两两比较。自上而下的冒泡算法和自下而上的冒泡算法都可以。

buddle-sort-gif

排序细节:

原始数字: 6 5 3 1 8 7 2 4

(K=1) 5 6 3 1 8 7 2 4

(K=1) 5 3 6 1 8 7 2 4

(K=1) 5 3 1 6 8 7 2 4

(K=1) 5 3 1 6 8 7 2 4

(K=1) 5 3 1 6 7 8 2 4

(K=1) 5 3 1 6 7 2 8 4

(K=1) 5 3 1 6 7 2 4 8

bubble-sort

### 伪代码

for i <- 1 to length(A)
    for j <- 1 to length(A)-i-1
    	// 为了让j+1不越界(j+1 < length(A)-i) -> (j < length(A)-i-1)
    	if(A[j]>A[j+1]){swap(j,j+1)}
    	j++;

### Java代码
	// 冒泡排序
	public static boolean bubbleSort(int array[]){
		boolean flag = false;  
		if(null != array && array.length > 0){
			// 每次确定array[i]的最终数字
			for(int i=0; i<array.length ; i++){
				int j = 0;
				for(; j<array.length-i-1;j++){
					if(array[j]>array[j+1]){
						swap(array, j, j+1);
					}
				}
			}
			flag = true;
		}
		return flag;
	}
  • 希尔排序(Shell Sort)

希尔排序是按照不同的步长进行插入排序。初始时，元素无序时，步长较大，每组内元素较少，速度很快。当元素基本有序时，步长较小，元素较多，但是元素基本有序，插入排序对于基本有序的序列效率较高。(插入排序是稳定的，但是希尔排序相当于多次插入排序，所以是不稳定的。)

shell-sort

WIKI
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-lCgkG8ob-1591086681525)(https://upload.wikimedia.org/math/9/8/a/98a5e472f889c0db4a6bdae9f56ed052.png)]
如上图我们去d1=5，d2=3，d3=1

d=5时，分组为 (a1, a6, a11), (a2, a7, a12), (a3, a8), (a4, a9), (a5, a10)，对组内的元素进行分别插入排序，得到第二排数组

d=3时，分组为(a1, a4, a7, a10), (a2, a5, a8, a11), (a3, a6, a9, a12)，对其分组插入排序，得到第三排数组。

d=1时，分组为 (a1,…, a12)，进行插入排序，得到结果。

# 伪代码数组默认从1开始计算
array 数组; 
length 数组长度; 
step步长(通常取值为length/2);

for (step =length/2; step >= 1; step=step/2){
	// 内嵌插入排序
	for(j=d+1;j <= length;j++){
		// 注意此处的j-d不要越界
		int tmpJ = j; 
		while((tmpJ-d)>=1 & a[tmpJ] < a[tmpJ-d]){
			swap(array, tmpJ, tmpJ-d);
			tmpJ = tmpJ-d;
		}
	}
}

#Java代码
/**
 * 希尔排序
 * 1. 选择j,将a[0] a[0+j] a[0+2j]分成一组进行插入排序
 * 2. 缩小j j--
 * 3. 重复1,2步骤，直到循环结束(j=1)
 * */
public class ShellSortAlgorithm {
	public static boolean sort(int array[]){
		boolean flag=false;
		if(null != array && array.length > 0){
			for(int j = array.length/2; j>=1 ;j=j/2){
				// 内嵌插入排序
				for(int i=j;i<array.length;i++){
					int tmp = i;
					while(tmp >= j && array[tmp] < array[tmp-j]){
						tmp = tmp-j;
						SortUtil.swap(array,i,tmp);
					}
				}
			}
			flag = true; 
		}
		return flag;
	}
	
	public static void main(String[] args) {
//		int array1[] = {4,2,3,6,1,2};
		int array1[] = {4,2,3,6,1,2,2,312,23,32,3,2,1,14,5,2,1,132,4};

		SortUtil.print(array1);
		ShellSortAlgorithm.sort(array1);
		SortUtil.print(array1);
	}

}

平均复杂度: 比较O(N * log2N).

评价:希尔排序是第一种将复杂度低于O(N^2)的算法。对于步长(Step)的选择可以根据数据集的大小进行决定。(具体的时间复杂度证明可以查看参考文献4与5)

希尔排序是对于插入排序的一种改善。希尔排序是按照不同的步长进行插入排序。初始时，元素无序时，步长较大，每组内元素较少，速度很快。当元素基本有序时，步长较小，元素较多，但是元素基本有序，插入排序对于基本有序的序列效率较高。

参考文献

[1] 《Thinking in Algorithm》12.详解十一种排序算法

[2] 百度经验: 希尔排序

[3] 图解排序算法(二)之希尔排序

[4] 数据结构基础 希尔排序 之 算法复杂度浅析

[5] 希尔排序&选择排序&时间复杂度分析

[6] 希尔排序 时间复杂度 证明

  • 归并排序(Merge Sort)-2路归并

merge-sort-gif

归并排序的核心在于分冶法。先使用分冶将排序的元素分成间隔为1的个体，然后合并成2/4/8/…步长的合集。

merge-sort-svg

分冶

merge-sort

归并
merge-sort-2

# 伪代码

void mergeSort(int []array,int begin,int end){
	if(begin<end){
		int mid = (begin+end)/2;
		// 分冶
		mergeSort(array,begin,mid);
		mergeSort(array,mid+1,end);	
		//归并
		merge(array,begin,end);
	}	
}


#Java代码

/**
 * 归并排序 (将集合先分离，在合并)
 * 1. 将集合从中间分离
 * 2. 将集合合并
 * 3. 重复步骤1，2直到循环结束
 * */
public class MergeSortAlgorithm {
	public static boolean sort(int array[]){
		boolean flag = false;
		if(null != array && array.length > 0){
			// 拷贝一个一样大小都array数组作为辅助
			int []tmpArray = array.clone();
			sort(array,0,array.length-1,tmpArray);
			flag = true;
		}
		return flag;
	}
	
	public static void sort(int array[],int front,int second,int []tmpArray){
		if(front < second){
			int mid = (front+second)/2;
			sort(array,front,mid,tmpArray);
			sort(array,mid+1,second,tmpArray);
			merge(array, front, second, tmpArray);
		}
	}
	
	public static void merge(int array[],int front,int second,int []tmpArray){
		int mid = (front+second)/2;
		int tmpFront = front;
		int tmpSecond = mid+1;
		int tmpIndex = 0;
		while(tmpFront <= mid && tmpSecond <= second ){
			if(array[tmpFront] < array[tmpSecond]){
				tmpArray[tmpIndex++] = array[tmpFront++];
			}else{
				tmpArray[tmpIndex++] = array[tmpSecond++];
			}
		}
		while(tmpFront <= mid){
			tmpArray[tmpIndex++] = array[tmpFront++];
		}
		while(tmpSecond <= second){
			tmpArray[tmpIndex++] = array[tmpSecond++];
		}
		tmpFront = front;
		tmpIndex = 0;
		while(tmpFront <= second){
			array[tmpFront++] = tmpArray[tmpIndex++];
		}
	}
	
	public static void main(String[] args) {
//		int array1[] = {4,2,3,6,1,2};
		
		int array1[] = {4,2,3,6,1,2,2,312,23,32,3,2,1,14,5,2,1,132,4};

		SortUtil.print(array1);
		MergeSortAlgorithm.sort(array1);
		SortUtil.print(array1);
	}
}

归并排序是稳定排序，它也是一种十分高效的排序，能利用完全二叉树特性的排序一般性能都不会太差。java中Arrays.sort()采用了一种名为TimSort的排序算法，就是归并排序的优化版本。从上文的图中可看出，每次合并操作的平均时间复杂度为O(n)，而完全二叉树的深度为|log2n|。总的平均时间复杂度为O(nlogn)。而且，归并排序的最好，最坏，平均时间复杂度均为O(nlogn)。

个人理解: 归并排序主要应用了分冶法，通过递归和迭代将2-4-8-16-…元素变成有序序列。由于用到了完全二叉树，所以平均复杂度为O(N * logN)。因为排序时为进行大量的相互变换，所以是一种稳定排序。速度比快速排序要差，但是算法较为稳定。

参考文献
[1] 图解排序算法(四)之归并排序
[2] 《Thinking in Algorithm》12.详解十一种排序算法
[3] wiki-merge sort
[4] 百度经验-归并排序

  • 堆排序(Heap Sort)

堆是一种树形结构。堆排序的主要过程就是不读构建堆结构(大顶堆/小顶堆)，随后不断替换第一个和最后一个元素，再重复构建堆结构，使最后一个元素有序的过程。

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-iDKEl5Lr-1591086681533)(https://upload.wikimedia.org/wikipedia/commons/4/4d/Heapsort-example.gif)]

heap-sor

#Java 代码
/**
 * 堆排序
 * 1. 初始化堆
 * 2. 将堆a[0]与a[back]互换
 * 3. 重新构建堆
 * 4. 重复2,3步骤直到循环停止
 * 
 * */
public class HeapSortAlgotitm {
	public static boolean sort(int []array){
		boolean flag = false;
		if(null !=array && array.length > 0){
			// first set heap 
			for(int i = (array.length/2)-1;i>=0;i--){
				adjustHeap(array,i,array.length);
			}	
			// other sort
			for(int j=array.length; j > 0;j--){
				SortUtil.swap(array,0,j-1);
				adjustHeap(array, 0, j);
			}
			flag=true;
		}
		return flag;
	}
	
	public static void adjustHeap(int []array,int root,int length){
		int tmp = array[root];
		for(int i=root*2+1;(i+1)<length;i=i*2+1){
			// a[i*2+1] 与 a[i*2+2]的比较
			if(array[i] < array[i+1]){
				i=i+1;
			}
			// array[root]与array[i]比较
			if(tmp >= array[i]){
				break;
			}else{
				array[root] = array[i];
				// swap(array,root,i);
				root =  i; // 是变化的最后变成array[root]的值的地方
			}
		}
		array[root] = tmp;	
	}
	
	public static void main(String[] args) {
		int array1[] = {4,2,3,6,1,2};
		SortUtil.print(array1);
		HeapSortAlgotitm.sort(array1);
		SortUtil.print(array1);
	}

}

参考文献:
[1]

  • 快速排序(Quick Sort)

快速排序的思路是：选择一个中间值，把小于中间值的都排列在左边，大于中间值的都排列在右边。然后不断迭代。

quick-sort

#伪代码
QUICKSORT(A, p, r)
 1 if p < r
 2    then q ← PARTITION(A, p, r)
 3         QUICKSORT(A, p, q - 1)
 4         QUICKSORT(A, q + 1, r)

#Java代码
package com.yanxml.algorithm.classical.sort;

/**
 * 快速排序
 * 1. 选取中间值K,比K大的都排右边，比K小的都排左边。
 * 2. 重复1步骤直到循环结束
 * */
public class QuickSortAlgorithm {

	public static boolean sort(int []array){
		boolean flag = false;
		if(null != array && array.length >0 ){
			sort(array,0,array.length-1);
			flag = true;
		}
		return flag;
	}
	
	public static void sort(int []array,int front,int second){
		if(front < second){
//			int mid = partition(array, front, second);
			int mid = partition2(array, front, second);
			sort(array, front, mid-1);
			sort(array, mid+1, second);
		}else{
//			break;
		}
	}
	
	// 交换法
	public static int partition(int []array,int front,int second){
		// 选取中间值
		int tmp = array[front];
		int index = front;
		
		int tmpFront = front;//前指针
		int tmpBack = second;//后指针
		
		while(tmpFront < tmpBack){
			// 前和后都优先扫描顺序不太好判断
			// 这段代码写在前和后得到都结果完全不同
			while(array[tmpBack] >= tmp && tmpFront < tmpBack){
				tmpBack--;
			}
			while(array[tmpFront] <= tmp && tmpFront < tmpBack){
				tmpFront++;	
			}
			SortUtil.swap(array,tmpFront,tmpBack);
		}
		index = tmpFront;
		SortUtil.swap(array,front,index);
		return index;
	}
	
	// 占坑法
	public static int partition2(int []array,int front,int second){
		// 选取中间值
		int tmp = array[front];
		int index = front;
		
		int tmpFront = front;//前指针
		int tmpBack = second;//后指针
		
		while(tmpFront < tmpBack){
			while(array[tmpBack] > tmp && tmpFront < tmpBack){
				tmpBack--;
			}
			array[tmpFront] = array[tmpBack];
			while(array[tmpFront] <= tmp && tmpFront < tmpBack){
				tmpFront++;	
			}
			array[tmpBack] = array[tmpFront];
		}
		index = tmpFront;
		array[index] = tmp;
		return index;
	}
	
	public static void main(String[] args) {
//		int array1[] = {4,2,3,6,1,2};
		
		int array1[] = {4,2,3,6,1,2,2,312,23,32,3,2,1,14,5,2,1,132,4};

		SortUtil.print(array1);
		QuickSortAlgorithm.sort(array1);
		SortUtil.print(array1);
	}
}

快速排序是当前速度最快的排序方式，时间复杂度为O(N*logN)。取中值时，可以选择中间值作为中值。(即三数取中法)

参考文献

[1] 图解排序算法(五)之快速排序——三数取中法
[2] 快速排序(三种算法实现和非递归实现)

Others

[1] 《Thinking in Algorithm》12.详解十一种排序算法

[2] 图解排序算法

[3] Arrays.sort和Collections.sort实现原理解析

[4] MySQL排序内部原理探秘

[5] MySQL order by实现原理分析和Filesort优化

[6] MySQL排序原理与案例分析

[7] [经典排序算法][集锦]

[8] 十大经典排序算法（动图演示）

[9] 字符串 模式匹配

在风中的意志
关注
专栏目录
排序算法总结
拾人牙慧
05-28 263
文章目录简单排序冒泡排序选择排序插入排序高级排序希尔排序划分快速排序基数排序 本文对各种排序算法进行了原理描述，分析了优缺点及适应场景。基于 《Java数据结构和算法（第二版）》， 作者： Robert Lafore 译者：计晓云 赵研 曾希 狄小菡 目标：把一组棒球队队员按身高排序（从左至右从矮到高）。 简单排序 冒泡排序 实行方法： 从队列的最左边开始，比较和第一个和第二个队员，如果第一个比...
十大经典排序算法详细总结(含JAVA代码实现)
热门推荐
Java学习之道
11-06 3万+
文章目录十大经典排序算法详细总结(含JAVA代码实现)0、排序算法说明1、冒泡排序（Bubble Sort）2、选择排序（Selection Sort）3、插入排序（Insertion Sort）4、希尔排序（Shell Sort）5、归并排序（Merge Sort）6、快速排序（Quick Sort）7、堆排序（Heap Sort）8、计数排序（Counting Sort）9、桶排序（Bucke...
常见的排序算法汇总（详解篇）
最新发布
m0_73634434的博客
08-19 1553
所谓排序，就是使一串记录，按照其中的某个或某些关键字的大小，递增或递减的排列起来的操作。稳定性 ：假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中， r[i]=r[j] ，且 r[i] 在 r[j] 之前，而在排序后的序列中， r[i] 仍在 r[j] 之前，则称这种排序算法是稳定的；否则称为不稳定的。数据元素全部放在内存中的排序。数据元素太多不能同时放在内存中，根据排序过程的要求不能在内外存之间移动数据的排序。
各种经典算法总结
阳光岛主
05-31 4181
<br />二分排序<br /> <br />/* 二分查找  <br />  * 算法思想：1、将数组排序(从小到大)；2、每次跟中间的数mid比较，如果相等可以直接返回，  <br />  * 如果比mid大则继续查找大的一边，否则继续查找小的一边。  <br />  <br />   输入：排序好的数组 - sSource[]，数组大小 - array_size，查找的值 - key  <br />   返回：找到返回相应的位置，否则返回-1  <br /> */   <br /> in
算法之排序算法
jwlai的专栏
06-30 732
1. 概述 排序算法是计算机技术中最基本的算法，许多复杂算法都会用到排序。尽管各种排序算法都已被封装成库函数供程序员使用，但了解排序算法的思想和原理，对于编写高质量的软件，显得非常重要。 本文介绍了常见的排序算法，从算法思想，复杂度和使用场景等方面做了总结。 2. 几个概念 （1）排序稳定：如果两个数相同，对他们进行的排序结果为他们的相对顺序不变。例如A={1,2,1,2,1}这里排序之后
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
七大经典排序算法总结详解
12-29
本文将详细讲解七大经典排序算法，帮助你深入理解它们的工作原理、优缺点以及适用场景。 1. 冒泡排序（Bubble Sort） 冒泡排序是最基础的排序算法之一，通过重复遍历数组，比较相邻元素并交换位置来实现排序。如果...
C、C++经典排序算法总结.pdf
10-14
【C、C++经典排序算法总结】 排序算法是计算机科学中的重要组成部分，尤其在处理大量数据时，高效的排序算法能够显著提升程序性能。本篇主要介绍两种基础且经典的排序算法：选择排序和直接插入排序。 1. **稳定...
八大经典排序算法总结和源代码
09-18
八大经典排序算法总结和源代码 在计算机科学中，排序算法是最基本也是最重要的算法之一。排序算法的性能直接影响到整个系统的性能。今天，我们将总结八大经典排序算法，并提供C++实现的源代码。 一、稳定排序和...
经典排序算法
Luna_ll的博客
09-04 653
一.算法的分类 相关概念： 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。 不稳定：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。 时间复杂度：对排序数据的总的操作次数。反映当n变化时，操作次数呈现什么规律。 空间复杂度：是指算法在计算机内执行时所需存储空间的度量，它也是数据规模n的函数。 二.冒泡排序（BubbleSort） 冒泡排序是...
经典算法总结
Alice_whj的博客
12-22 851
二分查找算法 可以用循环或递归 分治算法 把一个复杂的问题分成两个或更多的相同或相似的子问题，再把子问题分成更小的子问题……直到最后子问题可以简单的直接求解，原问题的解即子问题的解的合并。 分治算法可以求解的一些经典问题 二分搜索 大整数乘法 棋盘覆盖 合并排序 快速排序 线性时间选择 最接近点对问题 循环赛日程表 汉诺塔 分治法在每一层递归上都有三个步骤： 分解：将原问题分解为若干个规模较小，相互独立，与原问题形式相同的子问题 解决：若子问题规模较小而容易被解决则直接解，否则递归地解各个子问题 合并：将各
排序算法总结（一）
十年磨一剑，沉淀……
06-10 1812
【前言】 前一阵子直在学习算法，通过不断的总结我也发现了算法的魅力。虽然只是简单的排序算法，但是每一次自己动手去画图，去排列对比，看一些相关小视频的时候，感触就会越来越深，从刚开始的只不过简简单单的排序到后来升华成算法的艺术，需要自己慢慢去体会这个过程。 排序主要分为内排序和外排序，如果待排序的记录比较少，整个过程的所有记录都可以存在内存中，这样的排序叫做“内排序”。...
经典排序算法汇总
thxiong1234的博客
09-18 165
1、冒泡排序： 每次遍历数组，把最大的数放在最后一个index再从index-1开始往前遍历。 def maopao(num_list): for j in range(1, len(num_list)): for i in range(len(num_list) - j): if num_list[i] &gt; num_list[len(num...
排序法总结与比较
feifei
08-16 853
排序：对一序列对象根据某个关键字进行排序； 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；             例如：插入排序、冒泡排序、归并排序、计数排序、基数排序、桶排序 不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；                 例如：选择排序(5 8 5 2 9)、快速排序、堆排序 内排序：不占用额外内
十大经典排序算法
weixin_64600209的博客
06-23 5763
在上面的代码中，我们首先找出了待排序数组中的最大值，以便确定数字的位数，然后依次对每个数字位上的值进行排序。接着，我们根据桶中元素的前缀和，计算出每个数字位上的值在排序后的数组中的结束位置，从而将待排序数组中的元素依次存放到新数组中。每次从未排序部分的第一个元素开始，扫描整个未排序部分，找到其中的最小元素，然后将它和未排序部分的第一个元素交换位置，以此将最小元素移到已排序部分的末尾。接着，我们将待排序数据放入对应的桶中，对每个桶中的数据进行排序，最后将所有桶中的数据按顺序合并起来，得到排序后的数组。
C语言实现七大经典排序算法总结
本文档是一篇关于七大经典排序算法的总结，以C语言描述，作者是Vincent，发表于2018年11月9日的博客园。主要内容分为以下几个部分： 1. 交换排序：这是基于比较元素之间大小关系来调整位置的排序方法。 - **冒泡...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值