基本的几种排序算法详解

已于 2023-02-05 16:03:05 修改
阅读量217 收藏 1
点赞数 1
文章标签： 排序算法 数据结构 算法
于 2022-12-22 18:16:22 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_65743593/article/details/128395489
版权

目录

排序的定义

插入排序

折半插入排序

希尔排序

冒泡排序：

快速排序

选择排序

基本选择排序

堆排序

归并排序

排序的定义

排序是将一个集合按照元素关键字的大小重新排列成有序序列的操作。主要目的是便于查找和筛选。

插入排序

通过将未排序部分的元素逐个按其关键字大小插入已排序部分的恰当位置，最终实现全部元素有序排列。

算法思想

首先，将原始一个无序表看成两个子表，前一个子表为有序表，后一个子表为无序表，开始将第一个元素看为有序子表，其余元素为无序子表；

每趟排序按照关键字的大小将无序表的一个元素插入到有序表的恰当位置；

直至整个数据表有序。

void InsertSort(SqList *L)	//升序 
{
	int i,j;
	for(i=2;i<=L->len;i++)	//从第二个元素开始一一插入到前面 
	{
		L->list[0]=L->list[i];	//监视哨 
		j=i-1;
		while(L->list[0].key<L->list[j].key)	//从有序表后往前查找插入位置 
		{
			L->list[j+1]=L->list[j];
			j--;    //继续向前查找
		}
		L->list[j+1]=L->list[0];    //插入
	}	
}

示例

算法分析：

稳定性：稳定的。

空间复杂度：O(1)。

时间复杂度：最坏的情况为O(n*n)，最好的情况为O(n)。

L->list[0]有两个作用：一是保存待插入元素L->list[i]的值，一面在后移过程中被覆盖丢失；二是作为“监视哨”。

折半插入排序

折半插入排序又称为二分插入排序，是对直接插入排序的一种改进方法。

算法思想

和直接插入排序思想类似。

void BinarySort(SqList* L)    //升序
{
	cout << "调用折半插入排序" << endl;
	int i, j, low, high, mid;
	for (i = 2; i <= L->len; i++)
	{
		L->list[0] = L->list[i];
		low = 0;
		high = i - 1;
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (L->list[0].key < L->list[mid].key)
				high = mid - 1;
			else
				low = mid + 1;
		}	//折半查找结束，位置为low 
		for (j = i - 1; j >= low; j--)	//元素一一后移 
			L->list[j + 1] = L->list[j];
		L->list[low] = L->list[0];
	}

算法分析：

稳定性：稳定的。

空间复杂度：O(1)。

时间复杂度：O(n*n)。

注意：由于在有序表中查找元素插入位置时采用二分查找实现，折半插入排序只能应用于顺序存储结构。

希尔排序

设计思路：

直接插入排序在元素个数较少且基本有序时，效率很高。所以如果能实现1>减少待排序数据表元素个数，2>排序的数据表基本有序，则可以排序效率提高。

算法思想：

先取一个正整数d1(d1<n)作为第一个增量，将全部n个记录分成d1个组，把所有距离为d1倍数的记录放在同一组中，在各组内进行直接插入排序。这样一次分组和排序过程称为一趟希尔排序；

取新的增量d2<d1，重复1) 的分组和排序操作:直至所取的增量di=1为止，即所有记录放进一个组中排序为止。

示例：

设待排序记录关键字分别是 39 80 76 41 13 29 50 78 30 11 100 7 41 86 。增量序列取值依次为 5 ， 3 ， 1 

void ShellSort(SqList* L, int d[])	//d数组存放每趟的增量 
{
	cout << "调用希尔排序" << endl;
	int i, j, k, h;
	k = 0;
	do
	{
		h = d[k];	//取增量 
		for (int i = h + 1; i <= L->len; i++)	//i为待查热元素的下标 
		{
			L->list[0] = L->list[i];
			j = i - h;	//查看待插入元素的前一个元素 
			while (L->list[0].key < L->list[j].key && j>0)
			{
				L->list[j + h] = L->list[j];
				j = j - h;
			}
			L->list[j + h] = L->list[0];
		}
		k++;
	} while (h != 1);	//当增量为1时结束 
}

 算法分析：

稳定性：不稳定。

空间复杂度：依赖于步长银子序列的选取。介于O(nlog2(n))和O(n*n)之间。

冒泡排序：

算法思想：

将待排序的n个记录看作按纵向排列，每趟排序时自下至上对排序范围中每对相邻元素进行比较，若次序不符合要求就交换。
每趟排序都能使待排序范围内关键字最小的元素像气泡一样“冒”到待排序范围最上端。 
void BubbleSort(SqList* L)
{
	cout << "调用冒泡排序" << endl;
	int i, j, k, n = L->len;
	int t;
	for (i = 1; i < n; i++)
		for (j = n; j > i; j--)
			if (L->list[j].key < L->list[j - 1].key)
			{
				t = L->list[j].key;
				L->list[j].key = L->list[j - 1].key;
				L->list[j - 1].key = t;
			}
}

示例

从图中可以看出，第四趟已经全部有序了，但是算法并没有提前结束。

解决方案：

在冒泡排序算法中加入一个flag标志变量控制在数据表已经有序的情况下提前结束排序。

flag=1，表名数据表无序，下一趟排序仍需进行。

flag=0，表明数据表有序，排序过程应结束。

void BubbleSort_1(SqList* L)
{
	cout << "调用冒泡函数优化版" << endl;
	int i, j, k, n = L->len, flag;
	DataType t;
	i = 1;
	flag = 1;
	while ((i < n) && (flag == 1))
	{
		for (j = n; j > i; j--)
			if (L->list[j].key < L->list[j - 1].key)
			{
				flag = 1;
				t = L->list[j];
				L->list[j] = L->list[j - 1];
				L->list[j - 1] = t;
			}
		i++;
	}
}

算法分析

时间复杂度：O(n*n)。

空间复杂度：O(1)。

稳定性：稳定的

快速排序

算法思想：

任取待排序序列中的某个元素作为基准(一般取第一个元素)，将待排序元素分为左右两个子表，左子表中元素的关键字值均小于或等于基准元素的关键字值，右子表中元素的关键字值均大于或等于基准元素的关键字值;
对得到的子表继续划分，直至每个子表只有一个元素或为空为止。 
int QuickPass(SqList* L, int low, int high)
{
	int i, j;
	i = low;    //i从最左端开始
	j = high;   //j从最右端开始
	L->list[0] = L->list[i];    //L->list[0]存放基准元素
	while (i != j)    //重复左右交替扫描，直至i和j重合
	{
		while ((L->list[j].key >= L->list[0].key) && (i < j))    //从右向左扫描
			j--;
		if (i < j)    //若发现小于基准关键字的元素，将其放在左子表中并改变扫描方向
		{
			L->list[i] = L->list[j];
			i++;
		}
		while ((L->list[i].key <= L->list[0].key) && (i < j))    //从左向右扫描
			i++;
		if (i < j)    //若发现大于基准关键字的元素，将其放在右子表中并改变扫描方向
		{
			L->list[j] = L->list[i];
			j--;
		}
	}
	L->list[i] = L->list[0];
	return i;    //返回划分点位置
}
void QuickSort(SqList* L, int s, int t)
{
	cout << "调用快速排序" << endl;
	int i;
	if (s < t)    //只要排序区间中的元素超过1个，仍然继续进行快排
	{
		i = QuickPass(L, s, t);    //对范围进行一次划分
		QuickSort(L, s, i - 1);    //递归调用，分别对划分得到的两个子表进行快速排序
		QuickSort(L, i + 1, t);
	}
}

算法分析

空间复杂度：最好O(log2(n))，最坏O(n)。

时间复杂度：最好O(nlog2(n))，最坏O(n*n)。平均情况：O(nlog2(n))。

稳定性：不稳定。

选择排序

基本选择排序

算法思想：

第一趟排序时从待排序的n个记录中选择出关键字最小(大)的记录,将其与第1个记录交换；
第二趟，从第二个记录开始的n-1个记录中选择出关键字最小（大）的记录,将其与第2个记录交换；
如此下去，通过n-1趟操作，整个数据表就排列有序。 
void SelectSort(SqList* L)
{
	cout << "调用选择排序" << endl;
	int i, j, k, n;
	DataType temp;
	n = L->len;
	for (i = 1; i <= n - 1; i++)
	{
		k = i;	//记录当前最小元素的下标 
		for (j = i + 1; j <= n; j++)	//寻找待排序范围的最小元素 
			if (L->list[j].key < L->list[k].key)
				k = j;
		if (k != j)	//将待排序范围内找到的最小元素与表前端对应位置上的元素进行交换 
		{
			temp = L->list[i];
			L->list[i] = L->list[k];
			L->list[k] = temp;
		}
	}
}

示例

时间复杂度：O(1)。

空间复杂度：O(n*n)。

稳定性：不稳定。

其性能与初始状态无关。 

堆排序

堆排序局势二叉树形选择排序法。堆分为大根堆和小根堆。

若有n个元素的排序码k1，k2，...，kn，满足如下条件：

大根堆和小根堆

调整大根堆的原理和过程如下示例

堆调整函数(用于创建初始堆及重新调整堆)

void HeapAdjust(SeqList *L,int low,int high)
{
	int i,j;
	i=low;
	j=2*i;
	L->list[0]=L->list[i]; 
	for(;j<=high;j*=2)	//自顶向下对节点进行调整 
	{
		if(j<high&&L->list[j].key<L->list[j+1].key)	//找出i号结点左右孩子较大的一个 
			j++;
		if(L->list[0].key>=L->list[j].key)	//j号结点与其双亲进行比较
			break;
		else
		{
			L->list[i]=L->list[j];
			i=j;	//j这个位置成为新的待定的，调整继续向下层结点进行 
		} 
	}
	L->list[i]=L->list[0];	//把最初被调整的结点放在合适的位置 
}

堆创建函数(堆创建的过程的过程就是，就是反复调用HeapAdjust函数，从后从前依次将以每个非叶子结点为根节点的子树调整为大顶堆的过程)

void HeapCreate(SeqList *L)
{
	int i,n;
	n=L->len;
	for(i=n/2;i>0;i--)
	{
		HeapAdjust(L,i,n);
	}
}

堆排序

void HeapSort(SqList* L)
{
	cout << "调用堆排序" << endl;
	int i, n = L->len;
	HeapCreate(L);    //创建最大堆
	for (i = n; i > 1; i--)
	{
		L->list[0] = L->list[1];
		L->list[1] = L->list[i];
		L->list[i] = L->list[0];
		HeapAdjust(L, 1, i - 1);    //将表前面i-1个元素重新调整为堆
	}
}

算法分析：

空间复杂度：O(1)。

时间复杂度：O(nlog2(n))。

稳定性：不稳定。

归并排序

算法思想：

首先将待排序的n个元素看作n个长度为1的有序子表，然后从第一个子表开始，对相邻的子表进行两两合并；

接着在对合并后的有序子表继续进行两两合并，重复以上过程，直至得到一长度为n的有序表。

void Merge(SeqList *sr,int s,int m,int t,SeqList *tr)
{
	int i,j,k;
	i=s;	//i保存sr前面子表当前元素位置
	j=m+1;	//j保存后面子表中当前元素位置
	k=s;	///k保存归并后tr对应的顺序表中的当前元素位置
	while((i<=m)&&(j<=t)	//若前后两个子表中的元素均未全部合并
	{
		if(sr->list[i].key<=sr->list[j].key)	//两个子表中关键字较小元素存入tr中
			tr->list[k]=sr->list[i++];
		else
			tr->list[k]=sr->list[j++];
		k++; 
	}
	while(i<=m)	//将sr所对应的前面子表中的剩余元素放入tr对应的顺序表中
		tr->list[k++]=sr->list[i++];
	while(j<=t)	 //将sr所对应的后面子表中的剩余元素放入tr对应的顺序表中
		tr->list[k++]=sr->list[j++];
}
void MergeSort(SqList* sr, SqList* tr, int s, int t)
{	//sr,tr分别指向排序前后的顺序表；s和t分别用于存放sr所指向的待排序顺序表区间的左右端点 
	cout << "调用堆排序" << endl;
	int m;
	SqList temp;	//temp为暂存的辅助顺序表 
	if (s == t)	//若到排序区间仅有一个元素 
		tr->list[s] = sr->list[s];
	else
	{
		m = (s + t) / 2;	//将排序区间一分为二，m保存中间位置 
		MergeSort(sr, &temp, s, m);	//递归调用对前面的子表进行归并排序 
		MergeSort(sr, &temp, m + 1, t);	//递归调用堆后面的子表进行归并排序 
		Merge(&temp, s, m, t, tr);	//堆前后两个表进行合并 
	}
	tr->len = sr->len;
}

算法分析：

时间复杂度：O(nlog2(n))。

空间复杂度：O(n)。

稳定性：稳定的。

 最后给出测试代码

#include<iostream>
using namespace std;
#define MAXLEN 1000
typedef struct
{
	int key;
}DataType;
typedef struct
{
	int len;
	DataType list[MAXLEN+1];
} SqList;
void InsertSort(SqList* L)	//升序 
{
	cout << "调用直接插入排序" << endl;
	int i, j;
	for (i = 2; i <= L->len; i++)	//从第二个元素开始一一插入到前面 
	{
		L->list[0] = L->list[i];	//监视哨 
		j = i - 1;
		while (L->list[0].key < L->list[j].key)	//从有序表后往前查找插入位置 
		{
			L->list[j + 1] = L->list[j];
			j--;    //继续向前查找
		}
		L->list[j + 1] = L->list[0];    //插入
	}
}
void InitSqList(SqList* L)
{
	//cout << "请输入元素个数" << endl;
	//int x;
	//cin >> x;
	//L->len = x;
	//while (x != 0)
	//	cin >> L->list[x--].key;
	L->len = 8;
	L->list[1].key = 15;
	L->list[2].key = 47;
	L->list[3].key = 26;
	L->list[4].key = 58;
	L->list[5].key = 25;
	L->list[6].key = 29;
	L->list[7].key = 50;
	L->list[8].key = 99;
	
}
void Print(SqList& L)
{
	int i = 1;
	while (i <= L.len)
	{
		cout << L.list[i++].key << " ";
	}
	cout << endl;
}
void BinarySort(SqList* L)    //升序
{
	cout << "调用折半插入排序" << endl;
	int i, j, low, high, mid;
	for (i = 2; i <= L->len; i++)
	{
		L->list[0] = L->list[i];
		low = 0;
		high = i - 1;
		while (low <= high)
		{
			mid = (low + high) / 2;
			if (L->list[0].key < L->list[mid].key)
				high = mid - 1;
			else
				low = mid + 1;
		}	//折半查找结束，位置为low 
		for (j = i - 1; j >= low; j--)	//元素一一后移 
			L->list[j + 1] = L->list[j];
		L->list[low] = L->list[0];
	}
}

void ShellSort(SqList* L, int d[])	//d数组存放每趟的增量 
{
	cout << "调用希尔排序" << endl;
	int i, j, k, h;
	k = 0;
	do
	{
		h = d[k];	//取增量 
		for (int i = h + 1; i <= L->len; i++)	//i为待查热元素的下标 
		{
			L->list[0] = L->list[i];
			j = i - h;	//查看待插入元素的前一个元素 
			while (L->list[0].key < L->list[j].key && j>0)
			{
				L->list[j + h] = L->list[j];
				j = j - h;
			}
			L->list[j + h] = L->list[0];
		}
		k++;
	} while (h != 1);	//当增量为1时结束 
}

void BubbleSort(SqList* L)
{
	cout << "调用冒泡排序" << endl;
	int i, j, k, n = L->len;
	DataType t;
	for (i = 1; i < n; i++)
		for (j = n; j > i; j--)
			if (L->list[j].key < L->list[j - 1].key)
			{
				t = L->list[j];
				L->list[j] = L->list[j - 1];
				L->list[j - 1] = t;
			}
}
void BubbleSort_1(SqList* L)
{
	cout << "调用冒泡函数优化版" << endl;
	int i, j, k, n = L->len, flag;
	DataType t;
	i = 1;
	flag = 1;
	while ((i < n) && (flag == 1))
	{
		for (j = n; j > i; j--)
			if (L->list[j].key < L->list[j - 1].key)
			{
				flag = 1;
				t = L->list[j];
				L->list[j] = L->list[j - 1];
				L->list[j - 1] = t;
			}
		i++;
	}
}
int QuickPass(SqList* L, int low, int high)
{
	int i, j;
	i = low;    //i从最左端开始
	j = high;   //j从最右端开始
	L->list[0] = L->list[i];    //L->list[0]存放基准元素
	while (i != j)    //重复左右交替扫描，直至i和j重合
	{
		while ((L->list[j].key >= L->list[0].key) && (i < j))    //从右向左扫描
			j--;
		if (i < j)    //若发现小于基准关键字的元素，将其放在左子表中并改变扫描方向
		{
			L->list[i] = L->list[j];
			i++;
		}
		while ((L->list[i].key <= L->list[0].key) && (i < j))    //从左向右扫描
			i++;
		if (i < j)    //若发现大于基准关键字的元素，将其放在右子表中并改变扫描方向
		{
			L->list[j] = L->list[i];
			j--;
		}
	}
	L->list[i] = L->list[0];
	return i;    //返回划分点位置
}
void QuickSort(SqList* L, int s, int t)
{
	cout << "调用快速排序" << endl;
	int i;
	if (s < t)    //只要排序区间中的元素超过1个，仍然继续进行快排
	{
		i = QuickPass(L, s, t);    //对范围进行一次划分
		QuickSort(L, s, i - 1);    //递归调用，分别对划分得到的两个子表进行快速排序
		QuickSort(L, i + 1, t);
	}
}
void SelectSort(SqList* L)
{
	cout << "调用选择排序" << endl;
	int i, j, k, n;
	DataType temp;
	n = L->len;
	for (i = 1; i <= n - 1; i++)
	{
		k = i;	//记录当前最小元素的下标 
		for (j = i + 1; j <= n; j++)	//寻找待排序范围的最小元素 
			if (L->list[j].key < L->list[k].key)
				k = j;
		if (k != j)	//将待排序范围内找到的最小元素与表前端对应位置上的元素进行交换 
		{
			temp = L->list[i];
			L->list[i] = L->list[k];
			L->list[k] = temp;
		}
	}
}
void HeapAdjust(SqList* L, int low, int high)
{
	int i, j;
	i = low;
	j = 2 * i;
	L->list[0] = L->list[i];
	for (; j <= high; j *= 2)	//自顶向下对节点进行调整 
	{
		if (j < high && L->list[j].key < L->list[j + 1].key)	//找出i号结点左右孩子较大的一个 
			j++;
		if (L->list[0].key >= L->list[j].key)	//j号结点与其双亲进行比较
			break;
		else
		{
			L->list[i] = L->list[j];
			i = j;	//j这个位置成为新的待定的，调整继续向下层结点进行 
		}
	}
	L->list[i] = L->list[0];	//把最初被调整的结点放在合适的位置 
}
void HeapCreate(SqList* L)
{
	int i, n;
	n = L->len;
	for (i = n / 2; i > 0; i--)
	{
		HeapAdjust(L, i, n);
	}
}
void HeapSort(SqList* L)
{
	cout << "调用堆排序" << endl;
	int i, n = L->len;
	HeapCreate(L);    //创建最大堆
	for (i = n; i > 1; i--)
	{
		L->list[0] = L->list[1];
		L->list[1] = L->list[i];
		L->list[i] = L->list[0];
		HeapAdjust(L, 1, i - 1);    //将表前面i-1个元素重新调整为堆
	}
}
void Merge(SqList* sr, int s, int m, int t, SqList* tr)
{
	int i, j, k;
	i = s;	//i保存sr前面子表当前元素位置
	j = m + 1;	//j保存后面子表中当前元素位置
	k = s;	///k保存归并后tr对应的顺序表中的当前元素位置
	while ((i <= m) && (j <= t))	//若前后两个子表中的元素均未全部合并
	{
		if (sr->list[i].key <= sr->list[j].key)	//两个子表中关键字较小元素存入tr中
			tr->list[k] = sr->list[i++];
		else
			tr->list[k] = sr->list[j++];
		k++;
	}
	while (i <= m)	//将sr所对应的前面子表中的剩余元素放入tr对应的顺序表中
		tr->list[k++] = sr->list[i++];
	while (j <= t)	 //将sr所对应的后面子表中的剩余元素放入tr对应的顺序表中
		tr->list[k++] = sr->list[j++];
}
void MergeSort(SqList* sr, SqList* tr, int s, int t)
{	//sr,tr分别指向排序前后的顺序表；s和t分别用于存放sr所指向的待排序顺序表区间的左右端点 
	cout << "调用堆排序" << endl;
	int m;
	SqList temp;	//temp为暂存的辅助顺序表 
	if (s == t)	//若到排序区间仅有一个元素 
		tr->list[s] = sr->list[s];
	else
	{
		m = (s + t) / 2;	//将排序区间一分为二，m保存中间位置 
		MergeSort(sr, &temp, s, m);	//递归调用对前面的子表进行归并排序 
		MergeSort(sr, &temp, m + 1, t);	//递归调用堆后面的子表进行归并排序 
		Merge(&temp, s, m, t, tr);	//堆前后两个表进行合并 
	}
	tr->len = sr->len;
}
int main()
{
	SqList L;
	InitSqList(&L);
	// ===插入排序
	//InsertSort(&L);
	// ===折半插入排序
	//BinarySort(&L);
	// ===希尔排序
	//int d[3] = { 5,3,1 };
	//ShellSort(&L, d);
	// ===冒泡排序
	//BubbleSort(&L);
	// ===冒泡排序优化
	//BubbleSort_1(&L);
	// ===快速排序
	//QuickSort(&L, 1, L.len);
	// ===选择排序
	//SelectSort(&L);
	// ===堆排序
	//HeapSort(&L);
	//SqList LL;
	//MergeSort(&L, &LL, 0, L.len);
	//Print(LL);
	//Print(L);
	return 0;
}

小谢%同学
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
java排序算法
09-10
java实现的常用的几种基本排序算法，插入、交换、选择、归并
排序算法之快速排序
热门推荐
青鬆下的ミ坚躯 的个人博客
03-04 1万+
高快省的排序算法 有没有既不浪费空间又可以快一点的排序算法呢？那就是“快速排序”啦！光听这个名字是不是就觉得很高端呢。 假设我们现在对“6  1  2 7  9  3  4  5 10  8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比...
各种排序算法的总结
weixin_43657022的博客
07-17 178
总结各种常见的排序算法，参考leetcode912题 一、简单排序算法 1.选择排序 任何情况下都要遍历n²次，效率低下。 vector<int> sortArray(vector<int>& nums) { //选择排序 selectionSort(nums,nums.size()); return nums; } void selectionSort(vector<int>& nums,
八大排序算法
柒七的博客
02-04 1249
八大排序算法1.冒泡排序 冒泡排序是一种交换排序, 就是两两比较待排序的元素, 若次序不满足要求则交换, 知道整个数组有序 基本思想 : 每次找到最大或最小值, 然后放到首位或最后一位 对于长度为n 的数组, 因为只需要找到n-1个数的位置, 最后一个就已经确定了. 所以我们外部循环需要从0 ~ n-2. 内部循环从 n-1到 i+1, 内部循环每次将最大值或最小值推到i的位置(即选出第i小或第i大的数). 往复n-1次, 就完成了排序 public void bubbleSort(int[...
各种排序算法
qq_41716261的博客
10-07 893
1、插入排序 遍历所有的值，每一个都插入到之前已经排好的队列中的合适位置 对于基本有序的数列排序，性能比较好 2、希尔排序（插入排序的改良版） 在插入排序之前，先按照一定的步长，把数列用插入排序排好，再逐渐减少步长，直到步长为1。 比插入排序多的步骤主要是为了，先初步排一下序，方便最后的插入排序。 对于基本有序的数列排序，性能比较好 3、冒泡排序 重复地走访过要排序的数列，一次比较两个元素，如果它们的顺序错误就把它们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算.
基本的排序算法
断了的弦的博客
08-14 532
我们通常所说的排序算法往往指的是内部排序算法，即数据记录在内存中进行排序。 排序算法大体可分为两种： 一种是比较排序，时间复杂度O(nlogn) ~ O(n^2)，主要有：冒泡排序，选择排序，插入排序，归并排序，堆排序，快速排序等。 另一种是非比较排序，时间复杂度可以达到O(n)，主要有：计数排序，基数排序，桶排序等。 常见比较排序算法的性能如下： 冒泡排序： 依次比较相邻两个元素...
常用的排序算法(java实现)，附带一个PPT动画演示、详解了其中三种
06-29
1. 一个PPT 用动画演示了 插入排序，直接插入排序，希尔排序，附带讲解。 2. 附带其他几种常用排序的java实现的源码。 3. PPT 还是简洁、美观的，可用作模板。
机器学习10大经典算法详解
12-25
C4.5算法是机器学习算法中的一种分类决策树算法,其核心算法是ID3算法. C4.5算法继承了ID3算法的优点，并在以下几方面对ID3算法进行了改进：  1)用信息增益率来选择属性，克服了用信息增益选择属性时偏向选择取值多...
各种排序方法分析详解
05-19
几种排序算法介绍与性能分析 插入排序 希尔排序 冒泡排序 选择排序 快速排序
PHP利用二叉堆实现TopK-算法的方法详解
12-20
但只要量特别大是根本不可能完成这个任务的，比如在一个数组或者文本文件里有几亿个数，这样是根本无法全部读入内存的，所以利用排序解决这个问题并不是最好的，所以我们这里就用php去实现一个小顶堆来解决这个问题....
排序算法总结｜基本思路
lemonade13的博客
01-11 592
本文参考bobo老师的教学视频。 O(n^2)的算法 1. 选择排序 每次选最小的元素，放到前面排序部分的最后一个位置 2. 插入排序 每次从未排序部分取第一个元素，不断向前面排好序里的元素比大小+交换，直到插入合适位置 缺点：频繁交换位置，交换操作耗时 改进：前面排序部分后移，直到找到合适位置再将元素放入 优点：在近乎有序的时候，插入效果近似O(n) 3. 希尔排序（插入的改进） 出发点：插入在近乎有序的时候很快，所以希尔先在大跨度上排序，然后逐渐减小步长 4. 冒...
排序算法详细讲解（超酷）
qq_51419787的博客
03-30 1万+
排序算法作为数据结构中重要的部分，是必须要掌握的知识之一。 目录 前言 一、插入类排序 1.直接插入排序 2.折半插入排序 3.希尔排序 二、交换类排序 1.冒泡排序（相邻比序法） 2.快速排序 三、选择类排序 1.简单选择排序 2.树形选择排序 3.堆排序 四、归并排序 五、分配类排序 1.多关键字排序 2.链式基数排序 3.计数排序 总结 前言 在进行数据处理时，经常需要对数据进行查找，为了查的更快，通常要求数据有序排列。根据排序时......
基本排序算法
qq_51302219的博客
07-18 427
基本排序算法
快速排序在数组有序和无序情况下的时间复杂度
coder_wangYang的博客
07-15 4628
快速排序简单分区算法双指针分区算法benchmark测试 快速排序有两点要注意： 一、partition分区算法的选择： 简单分区算法：选择一个基数，遍历数组元素和基数比较，如果元素nums[left]比基数大，就和数组nums[right]交换，right–，如果元素nums[left]比基数小，left++ 双指针分区算法：从left和right分别定义一个指针，如果元素nums[left]比基数大，暂停遍历，如果元素nums[left]比基数小，left++；如果元素nums[right]比基数小，
算法：数组基本有序如何排序/找出topk 数组，思想一致
m0_37780420的博客
09-12 3361
1.已知一个几乎有序的数组，几乎有序是指，如果把数组排好顺序的话，每个元素移动的距离可以不超过k，并且k相对于数组来说比较小。请选择一个合适的排序算法针对这个数据进行排序。   思路1：数组若是基本有序的话，最好是插入排序，时间复杂度为O(NK),N为数组长度，K是需要移动的数的最远距离不超过K。 参考多个数组排序一节 思路2：另外堆排序也可以用，选择堆起始大小为k的最小堆排序算法，每个元...
相对有序排序算法
weixin_34187822的博客
11-08 179
使用场景： 当需要对一批数据进行逐个筛选，并将筛选后的数据存入一个容器中，当取出来进行第二次操作时，需要取出的数据是按一定的规则排序的时候。 drools加载并执行规则的时候，会去创建执行网络（Rete算法），用的排序方式就是这个算法。 public class RelativeOrderAlgorithm { pr...
几乎有序数组的排序方法
weixin_43923436的博客
05-08 3446
题目描述 已知一个几乎有序的数组，几乎有序指的是，如果把数组排好序的话，每个元素移送的距离不超过k，也就是说，所有元素都与它最终排序后的位置相距不到k，请选择一个时间复杂度最低的排序算法对此问题排序。 思路分析 排序算法，常见的效率比较高的，快排，不过，对于基本有序的数据，快排效率反而很低，排除掉。对于冒泡排序，有哨兵一说，如何已经有序，能直接返回，但是，此题只是在附近k的位置内，并不是说已经有部分有序，因此，也不符合。 因此，分析此题的特殊情况，每个数都在其最终位置k步以内，也就是说，最小值的话，最终排序
排序算法 排序算法总结
不远远方
03-15 442
转自：http://www.cnblogs.com/end/archive/2011/10/22/2221034.html 1.按平均时间将排序分为四类： （1）平方阶(O(n2))排序 　一般称为简单排序，例如直接插入、直接选择和冒泡排序； （2）线性对数阶(O(nlgn))排序 　如快速、堆和归并排序； （3）O(n1+￡)阶排序 　￡是介于0和1之间...
算法、排序（2）
微软新技术
02-20 1287
排序（sort）或分类     　所谓排序，就是要整理文件中的记录，使之按关键字递增(或递减)次序排列起来。其确切定义如下： 　　输入：n个记录R1，R2，…，Rn，其相应的关键字分别为K1，K2，…，Kn。 　　输出：Ril，Ri2，…，Rin，使得Ki1
java几种排序算法
最新发布
09-16
这些排序算法各有优缺点，具体选择哪种算法应根据具体情况来决定。 <span class="em">1</span><span class="em">2</span><span class="em">3 #### 引用[.reference_title] - *1* *2* *3* [详解Java常用排序算法（10...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

小谢%同学

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

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

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

打赏作者

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

抵扣说明：

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

余额充值