十大经典排序算法

已于 2024-08-31 21:58:40 修改
阅读量600 收藏 16
点赞数 17
文章标签： 排序算法 算法
于 2024-03-15 15:44:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62982862/article/details/136741836
版权

十大经典排序算法

参考网站

1.十大排序——最全最详细，一文让你彻底搞懂-CSDN博客

2.【十大经典排序算法（C语言描述）】https://www.bilibili.com/video/BV1nN4y1M7JK?p=6&vd_source=57dbe1b7ae720516dd577f4132a0370e

分类

1.交换类

1.冒泡排序(一个基于交换的数组,每一轮搜索这个序列的最大值,并将这个最大值放在序列的尾部)
  • 优化前
#include<stdio.h>`
#include<stdlib.h>
#include<time.h>
`//自定义数组最大长度`

`#define MAXSIZE 10`

`//取随机数`
`void initArr(int arr[], int length) {`
	`for (int i = 0; i < length;i++) {`
		`arr[i] = rand() % 20;//20以内的随机数`
	`}`
`}`

`//打印随机数`
`void showArr(int arr[],int length) {`
	`for (int i = 0; i < length; i++) {`
		`printf("%d  ", arr[i]);`
	`}`
	`printf("\n------------------------------------------------\n");`
`}`
`//给随机数排序`
`void bubSort(int arr[],int length) {`
	`while (length--) {`
		`for (int i = 0; i < length; i++) {`
			`if (arr[i] > arr[i + 1]) {`
				`int temp = arr[i];`
				`arr[i] = arr[i + 1];`
				`arr[i + 1] = temp;`
			`}`
		`}`
	`}`
`}`

`int main() {`
	`srand((unsigned int)time(NULL));//设置随机数种子,不然每次随机到的数都是一样的`
	`int arr[MAXSIZE];`
	`initArr(arr,MAXSIZE);`
	`showArr(arr,MAXSIZE);`
	`bubSort(arr,MAXSIZE);`
	`showArr(arr,MAXSIZE);`
	`return 0;`
`}`
  • 优化后(加入flag后,最大值和之前一样排到最后,但是之前的序列已经完成排序,就可以不用再进行循环)
    `#include<stdio.h>`
`#include<stdlib.h>`
`#include<time.h>`

`//自定义数组最大长度`
`#define MAXSIZE 10`

`//取随机数`
`void initArr(int arr[], int length) {`
	`for (int i = 0; i < length;i++) {`
		`arr[i] = rand() % 20;//20以内的随机数`
	`}`
`}`

`//打印随机数`
`void showArr(int arr[],int length) {`
	`for (int i = 0; i < length; i++) {`
		`printf("%d  ", arr[i]);`
	`}`
	`printf("\n------------------------------------------------\n");`
`}`
`//给随机数排序`
`void bubSort(int arr[],int length) {`

     `int flag=1;`

	`while (length--&&flag) {`

       `flag=0;`

		`for (int i = 0; i < length; i++) {`

            `flag=1;`

			`if (arr[i] > arr[i + 1]) {`
				`int temp = arr[i];`
				`arr[i] = arr[i + 1];`
				`arr[i + 1] = temp;`
			`}`
		`}`
	`}`
`}`

`int main() {`
	`srand((unsigned int)time(NULL));//设置随机数种子,不然每次随机到的数都是一样的`
	`int arr[MAXSIZE];`
	`initArr(arr,MAXSIZE);`
	`showArr(arr,MAXSIZE);`
	`bubSort(arr,MAXSIZE);`
	`showArr(arr,MAXSIZE);`
	`return 0;`
`}`
2.快速排序(冒泡排序的优化版本,核心思想:使用轴,每一轮左右递归后,把轴放在中间,使轴左边都比轴小,右边都比轴大,当所有的递归都结束以后就自然排好序了)
  • 优化前:不适用于单链表,只适用于顺序存储
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MAXSIZE 10

//获取随机数
void initArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 100;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n--------------------------------------\n");
}

//快速排序
void quickSort(int arr[],int left,int right) {
	if (left>=right) {return;}//函数出口
	int i = left;
	int j = right;
	int pviot = arr[i];//轴的初始值
	while(i<j){
	  while (i<j&&arr[j]>pviot) {
		  j--;
	  }//先从右往左找比轴大的值
	  arr[i] = arr[j];//找到以后j暂时代替轴的位置
	  while (i<j&&arr[i]<pviot) {
		  i++;
	  }//从左往右找比轴小的值
	  arr[j] = arr[i];//找到以后赋值给j的位置
	}
	arr[i] = pviot;
	quickSort(arr,left,i-1);//轴左边开始递归
	quickSort(arr,i+1,right);//轴右边开始递归
}


int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	quickSort(arr,0,MAXSIZE-1);
	showArr(arr, MAXSIZE);
	return 0;
}

  • ;优化后:适用于链式存储

    #include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MAXSIZE 10

//获取随机数
void initArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 100;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n--------------------------------------\n");
}

//交换
void swap(arr[],int i,int j){
    int temp=arr[i];
    arr[i]=arr[j];
    arr[j]=temp;
}

//快速排序
void quickSort(int arr[],int left,int right) {
	if (left>=right) {return;}//函数出口,函数出口一般放在函数开头
	int pviot = arr[left];//轴的初始值
    int i = left + 1;
	int j = right + 1 ;
	while(j<=right){
        if(arr[j]<pviot){
            swap(arr,i,j);
            i++;
        }
        j++;
    }
	swap(arr,left,i-1);
	quickSort(arr,left,i-2);//轴左边开始递归
	quickSort(arr,i,right);//轴右边开始递归
}


int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	quickSort(arr,0,MAXSIZE-1);
	showArr(arr, MAXSIZE);
	return 0;
}

2.分配类

1.计数排序(统计原来数组的数据,并将数据转换成下标存储在一个临时的空间中,然后变量临时空间把对应的下标值放回原数组,当遍历临时空间完成后,原来的数组就是排好序了)
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<assert.h>

#define MAXSIZE 10

//随机获取序列
void initArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 20;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d  ", arr[i]);
	}
	printf("\n----------------------------------------\n");
}

void swap(int arr[], int i, int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

int temp[100];//偷懒写法:临时数组
void countSort(int arr[],int length) {
	for (int i = 0; i < length;i++) {
		temp[arr[i]]++;//把arr[i]的数值当作temp的下标
	}
	for (int i = 0, j = 0; i < 100;i++) {
		while (temp[i]--) {
			arr[j++] = i;
		}
	}
}

int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	countSort(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}
2.基数排序(统计序列数的最大位数,第一轮从100开始,第二轮从101开始,以此类推,统计每轮相应位数的最大值,并放在最前面,直到最后)
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<assert.h>

#define MAXSIZE 10

//随机获取序列
void initArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 20;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d  ", arr[i]);
	}
	printf("\n----------------------------------------\n");
}

void swap(int arr[], int i, int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}

int temp[10][100];
void redixSort(int arr[],int length) {
	for (int k = 10; k < 10000;k*=10) {
		for (int i = 0; i < length;i++) {
			int j = 0;
			int pos = (arr[i] % k) / (k / 10);
			while (temp[pos][j]) {
				j++;
			}
			temp[pos][j] = arr[i];
		}
		int pos = 0;
		for (int i = 0; i < 10;i++) {
			for (int j = 0; j < length&& temp[i][j] != 0;j++) {
					arr[pos++] = temp[i][j];
					temp[i][j] = 0;
			}
		}
	}
}

int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	redixSort(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}

3.选择类

1.选择排序(快速排序是在冒泡排序的基础上,每一轮找到序列中的最小值后和第一个元素进行交换,以此类推)
`#include<stdio.h>`

`#include<stdlib.h>`

`#include<time.h>`

`define MAXSIZE 10`

`//取随机数`
`void initArr(int arr[],int length) {`
	`for (int i = 0; i < length; i++) {`
		`arr[i] = rand() % 20;`
	`}`
`}`
`//打印随机数`
`void showArr(int arr[], int length) {`
	`for (int i = 0; i < length;i++) {`
		`printf("%d  ",arr[i]);`
	`}`
	`printf("\n----------------------------------------\n");`
`}`

`//给序列排序`
`void selectSort(int arr[],int length) {`
	`for (int i = 0; i < length - 1;i++) {`
		`int k = i;`
		`for (int j = i + 1; j < length;j++) {`
			`if(arr[k]>arr[j]) {`
				`k = j;`
			`}`
		`}`
		`int temp = arr[i];`
		`arr[i] = arr[k];`
		`arr[k] = temp;`
	`}`
`}`

`int main() {`
	`srand((unsigned int)time(NULL));`
	`int arr[MAXSIZE];`
	`initArr(arr, MAXSIZE);`
	`showArr(arr, MAXSIZE);`
	`selectSort(arr, MAXSIZE);`
	`showArr(arr, MAXSIZE);`
	`return 0;`
`}`
2.堆排序(本质上就是一个完全二叉树,每一个节点的存储都是连续的)
  • 大顶堆
    • 父亲的权值比左右子树的权值大
  • 小顶堆
    • 父亲的权值比左右子树的权值小

当前下标为current

  • 从0开始计数

    • 左子树–>2*current+1
    • 右子树–>2*current+2

  • 从1开始计数

    • 左子树–>2*current
    • 右子树–>2*current+1

  • 外堆

    • 需要一段和原来数组长度大小的内存空间,这段内存空间是用来存储堆结构的(用小顶堆)
#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<assert.h>

#define MAXSIZE 10

//随机获取序列
void initArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 20;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d  ", arr[i]);
	}
	printf("\n----------------------------------------\n");
}

void swap(int arr[], int i, int j) {
	int temp = arr[i];
	arr[i] = arr[j];
	arr[j] = temp;
}
//堆结构
typedef struct Heap {
	int* root;
	int length;
}Heap;

//入堆申请内存
Heap* creatHeap(int length) {
	Heap* heap = (Heap*)malloc(sizeof(Heap));
	assert(heap);
	heap->length = 0;
	heap->root = (int*)malloc(sizeof(int) * length);
	assert(heap->root);
	return heap;
}

//入堆
void pushHeap(Heap* heap,int data) {
	int current = heap->length++;
	int parent = current / 2;//求父亲下标
	heap->root[current] = data; 
	while (parent != current) {
		if (heap->root[current] < heap->root[parent]) {
			swap(heap->root, current, parent);
			current = parent;
			parent = current / 2;
		}
		else 
			break;
	}
}

//出堆
int popHeap(Heap* heap) {
	int val = heap->root[0];
	int current = 0;
	int rchild = 2 * current+2;
	int small;
	heap->root[0] = heap->root[--heap->length];
	while (rchild <= heap->length) {
		small = heap->root[rchild - 1] < heap->root[rchild] ? rchild - 1 : rchild;
		if (heap->root[small] < heap->root[current]) {
			swap(heap->root, small, current);
			current = small;
			rchild = 2 * current + 2;
		}
		else
			break;
	}
	return val;
}

//堆排序
void heapSort(int arr[],int length) {
	Heap* heap = creatHeap(MAXSIZE);
	for (int i = 0; i < MAXSIZE; i++) {
		pushHeap(heap, arr[i]);
	}
	for (int i = 0; i < MAXSIZE; i++) {
		arr[i] = popHeap(heap);
	}
}

int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	heapSort(arr,MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}
  • 内堆
    • 不需要重新申请内存,直接在原来的数组上排序(用大顶堆)
void heapify(int arr[], int length, int current) {
	int rchild = 2 * current + 2;
	int large;
	while (rchild <= length) {
		large = rchild == length ? rchild - 1 : (arr[rchild - 1] > arr[rchild] ? rchild - 1 : rchild);
		if (arr[large] > arr[current]) {
			swap(arr, large, current);
			current = large;
			rchild = current * 2 + 2;
		}
		else
			break;
	}
}


//内堆
void heapSort2(int arr[], int length) {
	int current = length / 2;
	while (current >= 0) {
		heapify(arr, length, current);
		current--;
	}
	while (length) {
		swap(arr, 0, --length);
		heapify(arr, length, 0);
	}
}

4.归并类

归并排序(基于分而治之的思想,拿两个已经有序的序列重新组合成一个有序的新序列)
  • 优化前
#include<stdio.h>
#include<time.h>
#include<stdlib.h>

#define MAXSIZE 10

//随机获取序列
void initArr(int arr[],int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 20;
	}
}

//打印序列
void showArr(int arr[],int length) {
	for (int i = 0; i < length;i++) {
		printf("%d  ",arr[i]);
	}
	printf("\n----------------------------------------\n");
}

//归并排序
//默认a和b数组都是有序的
void mergeSort(int a[], int alen,int b[],int blen,int* temp) {
	int i = 0;//a下标初始化
	int j = 0;//b下标初始化
	int k = 0;//新数组下标初始化
	while (i < alen && j < blen) {
		if (a[i]<b[j]) {
			temp[k] = a[i];
			i++;
			k++;
		}
		else {
			temp[k] = b[j];
			j++;
			k++;
		}
	}
	while (i < alen) {
		temp[k] = a[i];
		i++;
		k++;
	}
	while (j < blen) {
		temp[k] = b[j];
		j++;
		k++;
	}
}

//手动输入序列
void scanfArr(int arr[]) {
	printf("Please add arr:");
	for (int i = 0; i < MAXSIZE;i++) {
		scanf_s("%d", &arr[i]);
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main() {
	int arr1[5] = { 1,3,5,7,9 };//序列a
	int arr2[5] = { 2,4,6,8,10 };//序列b
	int temp[10];//新序列
	mergeSort(arr1, 5, arr2, 5, temp);
	showArr(temp,10);
	return 0;
}

#include<stdio.h>
#include<time.h>
#include<stdlib.h>
#include<assert.h>

#define MAXSIZE 10

//随机获取序列
void initArr(int arr[],int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 20;
	}
}

//打印序列
void showArr(int arr[],int length) {
	for (int i = 0; i < length;i++) {
		printf("%d  ",arr[i]);
	}
	printf("\n----------------------------------------\n");
}

//归并
void merge(int arr[],int low,int mid,int height,int* temp) {
	int i = low;
	int j = mid + 1;
	int k = low;
	while (i<=mid&&j<=height) {
		temp[k++] = arr[i] < arr[j] ? arr[i++] : arr[j++];
	}
	while (i <= mid) {
		temp[k++] = arr[i++];
	}
	while (j <= height) {
		temp[k++] = arr[j++];
	}
	//重新排列
	for (i = low; i <= height;i++) {
		arr[i] = temp[i];
	}
}

//划分序列
void merge_sort(int arr[],int low,int height,int* temp) {
	if (low>=height) {
		return;
	}
	int mid = low + (height - low) / 2;//求mid
	merge_sort(arr, low, mid, temp);//划分小的部分
	merge_sort(arr, mid+1, height, temp);//划分大的部分
	merge(arr, low, mid, height, temp);//合并序列
}

//最终归并的函数
void mergeSort(int arr[],int length) {
	int* temp = (int*)malloc(sizeof(int) * length);//申请空间
	assert(temp);
	merge_sort(arr, 0, length - 1, temp);
	free(temp);
}


int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	mergeSort(arr,MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}

5.插入类

1.插入排序(优点是序列已经基本有序时,再将一个新的数据插入进来比较方便,效率较高)
#include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MAXSIZE 10

//随机获取序列
void initArr(int arr[],int length) {
	for (int i = 0; i < length; i++) {
		arr[i] = rand() % 20;
	}
}

void showArr(int arr[],int length) {
	for (int i = 0; i < length;i++) {
		printf("%d  ",arr[i]);
	}
	printf("\n----------------------------------------\n");
}

//插入排序
void insertSort(int arr[],int length) {
	for (int i = 1; i < length;i++) {
		for (int j = i; j > 0 && arr[j] < arr[j-1];j--) {
			int temp = arr[j];
			arr[j] = arr[j - 1];
			arr[j - 1] = temp;
		}
	}
}

//手动输入序列
void scanfArr(int arr[]) {
	printf("Please add arr:");
	for (int i = 0; i < MAXSIZE;i++) {
		scanf_s("%d", &arr[i]);
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int main() {
	int arr[MAXSIZE];
	srand((unsigned int)time(NULL));
	/*initArr(arr,MAXSIZE);
	showArr(arr, MAXSIZE);*/
	scanfArr(arr);
	insertSort(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}
2.希尔排序(优化版的插入排序,原数组很大的情况适用.如果插入排序步长是1,那么希尔排序步长可以更大,然后逐渐减小直到1形成插入排序)

  • 优化前(步数是自己定义的,需要自己计算)

    #include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MAXSIZE 1000

//获取随机数
void initArr(int arr[],int length) {
	for (int i = 0; i < length;i++) {
		arr[i] = rand() % 100;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n--------------------------------------\n");
}

//希尔排序
void shellSort(int arr[], int length) {
	int h = 4;
	while(h>=1)
	{
	  for (int i = h; i < length;i++) 
	  {
		 for (int j = i; j >= h && arr[j] < arr[j - 1];j-=h) 
		 {
			 int temp = arr[j];
			 arr[j] = arr[j - h];
			 arr[j - h] = temp;
		 }
	  }
	  h /= 2;
    }
}

int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	shellSort(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}

  • 优化后(步数是自动计算的,根据3*n+1来算需要的步数)

    理想的希尔排序序列为:1,4,10,…,3*n+1.

    #include<stdio.h>
#include<stdlib.h>
#include<time.h>

#define MAXSIZE 1000

//获取随机数
void initArr(int arr[],int length) {
	for (int i = 0; i < length;i++) {
		arr[i] = rand() % 100;
	}
}

//打印序列
void showArr(int arr[], int length) {
	for (int i = 0; i < length; i++) {
		printf("%d ", arr[i]);
	}
	printf("\n--------------------------------------\n");
}

//希尔排序
void shellSort(int arr[], int length) {
	int h = 1;//初始化h
	int t = length / 3;//根据经典的希尔排序(3*n+1),来使其靠近这个数值
	while (h < t) {
		h = 3 * h + 1;//经典希尔排序序列,循环到最适合的h
	}
	while(h>=1)
	{
	  for (int i = h; i < length;i++) 
	  {
		 for (int j = i; j >= h && arr[j] < arr[j - 1];j-=h) 
		 {
			 int temp = arr[j];
			 arr[j] = arr[j - h];
			 arr[j - h] = temp;
		 }
	  }
	  h /= 3;//前面有3*n,所以要除以3
    }
}

int main() {
	int arr[MAXSIZE];
	srand((unsigned)time(NULL));
	initArr(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	shellSort(arr, MAXSIZE);
	showArr(arr, MAXSIZE);
	return 0;
}
X......X
关注
  • 17
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
十大经典排序算法（动图演示） - 一像素 - 博客园.mhtml
04-10
通过学习十大经典排序算法（动图演示），你可以了解C语言中的排序方法，对C语言的程序设计会有很大帮助，有助于今后的工作和学习
十大经典排序算法总结.docx
08-24
《十大经典排序算法总结》 排序算法是计算机科学的基础，其设计思想和效率对软件的性能有着直接影响。本文主要探讨了十种经典的排序算法，包括它们的设计思路、优缺点以及适用场景，帮助我们理解排序算法的核心。 ...
十大经典排序算法-归并排序算法详解
热门推荐
qq_35344198的博客
06-19 12万+
一、什么是归并排序 1.概念 归并排序（Merge sort）是建立在归并操作上的一种有效的排序算法，归并排序对序列的元素进行逐层折半分组，然后从最小分组开始比较排序，合并成一个大的分组，逐层进行，最终所有的元素都是有序的 2.算法原理 这是一个无序数列：4、5、8、1、7、2、6、3，我们要将它按从小到大排序。按照归并排序的思想，我们要把序列逐层进行拆分 序列逐层拆分如下 然后从下往上逐层合并，首先对第一层序列1（只包含元素4）和序列2（只包含元素5）进行合并 创建一个大序列，序列长度为两个小序列长度
算法学习总结（2）——温故十大经典排序算法
科技D人生
08-29 5万+
一、什么是排序算法 1.1、排序定义 对一序列对象根据某个关键字进行排序。 1.2、排序术语 稳定：如果a原本在b前面，而a=b，排序之后a仍然在b的前面；不稳定：如果a原本在b的前面，而a=b，排序之后a可能会出现在b的后面；内排序：所有排序操作都在内存中完成；外排序：由于数据太大，因此把数据放在磁盘中，而排序通过磁盘和内存的数据传输才能进行；时间复杂度：一个算法执行所耗费的时间。空间...
Python实现十大经典排序算法
涛哥聊Python
06-30 582
更多Python学习内容：ipengtao.com排序算法是计算机科学中的基本算法之一，广泛应用于数据处理和分析。本文将详细介绍用Python实现十大经典排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。通过具体的示例代码，全面掌握这些基础算法。冒泡排序冒泡排序（Bubble Sort）是一种简单的交换排序算法，通过重复地遍历要排序的数组...
十大经典排序算法（Java实现）
qq_43794633的博客
12-04 2万+
为了加深对这十种算法的理解，固写此文。首先可用如下表来简单概括这十种算法： 目录1、冒泡排序2、选择排序3、插入排序4、希尔排序5、归并排序6、快速排序7、堆排序8、计数排序9、桶排序10、基数排序 十大经典排序算法 平均时间复杂度 最好时间复杂度 最坏时间复杂度 空间复杂度 排序方式 稳定性 冒泡排序 O\OmicronO(n2) O\OmicronO(n) O\OmicronO(n2) O\OmicronO(1) In-place 稳定 选择排序 O\OmicronO(n2) O\O
十大经典排序算法——java语言
weixin_56781779的博客
11-11 6282
一、冒泡排序 二、选择排序 三、插入排序 四、希尔排序 五、归并排序 六、快速排序 七、堆排序 八、计数排序 九、桶排序 十、基数排序
十大经典排序算法总结（Java实现+动画）
meibenxiang的博客
06-19 5万+
最近在梳理《数据结构与算法》的内容，在网上看了几篇不错的文章，现在根据自己的理解重新整理一下十大经典排序算法。实际生产中，最好的算法一定是结合数据集本身的特点（大小，长度，是否已经基本有序等等）来选择的，不要拘泥于算法本身。 我参考的文章有：https://www.cnblogs.com/guoyaohua/p/8600214.html，https://blog.csdn.net/liang_g...
数据结构-十大经典排序算法
qq_64010161的博客
12-09 3735
数据结构-十大经典排序算法（冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序、基数排序）
十大经典排序算法(超详细)
脑袋空空的博客
01-26 944
排序是我们数据结构中不可或缺的算法，也是面试官HR最爱问的问题之一，所以要清楚排序就要明白排序的核心思想是什么，什么样的排序时间和空间复杂度更低，什么情况下用什么样的排序会更优。最常见的就是十大经典排序：冒泡排序、选择排序、堆排序、插入排序、希尔排序、快速排序、归并排序、基数排序、计数排序和桶排序。
头歌-十大经典排序算法
SXXYNHHXX的博客
03-14 2884
桶排序是计数排序的升级版。第i=1,..,n−1趟排序从当前无序区R[i−1,n−1]中选出最小的元素R[k]，并将它与无序区的第1个记录R[i−1]交换，则R[0,i−1]变为元素个数增加1的新有序区，R[i,n−1]变为元素个数减少1的新无序区；选择排序是一种简单直观的排序算法，首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。平台将自动编译补全后的代码，并生成若干组测试数据，接着根据程序的输出判断程序是否正确。
十大经典排序算法.pdf
12-08
十大经典排序算法是数据结构与算法领域中的基础，它们包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数排序、桶排序和基数排序。这些算法分别适用于不同的场景，具有各自的时间复杂度...
十大经典排序算法.docx
01-31
### 十大经典排序算法详解 #### 一、概述 排序算法是计算机科学中的一个基础概念，也是数据处理中常用的技术之一。它主要用于将一系列无序的数据按照特定规则（如数值大小、字母顺序等）进行排列。根据不同的应用...
十大经典排序算法，附带动画演示效果，超硬核
12-30
《十大经典排序算法》是一部深入浅出的教程，旨在帮助计算机专业的学生更好地理解数据结构与算法。本教程涵盖了十大经典排序算法，包括冒泡排序、选择排序、插入排序、希尔排序、归并排序、快速排序、堆排序、计数...
希尔排序
最新发布
shylyly_的博客
09-06 1075
先选定一个整数gap，把待排序文件中所有记录分成个组，按照所有距离为整数gap的记录分在同一组内，并对每一组内的记录进行排序。然后，通过整数gap逐渐变小，重复上述分组和排序的工作。当整数gap变小到达=1时，也就是执行插入排序，这样所有记录在统一组内就排好序了。
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 881
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
C语言：刷题笔记
weixin_45930573的博客
09-04 410
c语言刷题记录
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 661
四、实验结果。
Python实战：LeetCode十大经典排序算法详解
在本文档中，我们将深入探讨Python实现的十大经典排序算法，结合LeetCode案例，帮助读者理解和掌握这些算法。以下是每个部分的主要知识点： 1. **引言** - 问题需求：本文着重解决实际编程中的问题，即对整数数组...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值