一篇博客读懂排序

这篇具有很好参考价值的文章主要介绍了一篇博客读懂排序。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一、常见的排序

二、冒泡排序 

2.1基本思想:

2.2代码:

三、插入排序

3.1基本思想:

3.2思路讲解:

3.3代码:

3.4时间复杂度:

四、希尔排序

4.1基本思路:

4.2思路讲解:

4.3代码:

4.4时间复杂度:

五、选择排序

5.1基本思路:

5.2思路讲解:

5.3代码:

5.4时间复杂度:

六、堆排序

6.1基本思路:

6.2思路讲解:

6.3代码:

6.4时间复杂度:

七、快速排序(hoare版本)

7.1基本思路:

7.2思路讲解:

7.3代码:

7.4时间复杂度:

八、快速排序(挖坑法和前后指针版本)

8.1挖坑法

8.1.1挖坑法讲解

8.1.2代码:

 8.2前后指针版本

8.1.1前后指针讲解

8.1.2代码: 

九、归并排序 

9.1基本思路:

9.2思路讲解:

9.3代码:

9.4时间复杂度:


一、常见的排序

一篇博客读懂排序,C语言,数据结构,数据结构

二、冒泡排序 

2.1基本思想:

冒泡排序,何为冒泡,即把数据最大的每次都排到最后一个位置,像冒泡一样。

2.2代码:

void BubbleSort(int* a, int n)
{
	int i = 0;
	
	for (; i < n; i++)
	{
		int j = 1;
		for (; j < n - i; j++)
		{
			if (a[i - 1] > a[i])
				Swap(&a[i - 1], &a[i]);
		}
	}
}

三、插入排序

3.1基本思想:

  把待排序的数据逐个插入到一个已经排好序的有序序列中,直到所有的记录插入完为止,得到一个新的有序序列 。

3.2思路讲解:

一篇博客读懂排序,C语言,数据结构,数据结构

以上图数据、升序为例。
为了便于理解,我们分为两大阵营,已排和未排。我们在没排序之前,这些数据全都是未排阵营,接着我们开始比较,由于已排阵营没有数据,所以9就是第一个。然后拿未排阵营的33和9比较,33放在9之后。
接着就是10和33比较,10放在33前;10和9排序,10放在9后,此趟结束。
一篇博客读懂排序,C语言,数据结构,数据结构

46和33比较,46放在33后,此趟结束。
一篇博客读懂排序,C语言,数据结构,数据结构

23和46比较,放在46前;23和33比较,放在33前;23和10比较,放在10后,此趟结束。一篇博客读懂排序,C语言,数据结构,数据结构

我相信说了这几趟,大家就能基本明白,插入排序就是把没排序的和已排序的从后向前依次比较然后找到不满足条件的位置把自己放进去。

3.3代码:

首先,我们先完成单趟排序。
然后,我们介绍一下需要新引入的变量:
一篇博客读懂排序,C语言,数据结构,数据结构
其中,因为我们需要把数组看成两部分,所以我们引入end作为两者的分界点;当挪动数据时,我们用前一个数据覆盖后一个数据,所以需要tmp记录被覆盖元素的值,即当前插入的元素。
当我们的插入元素不满足条件时,即它在前后两个元素之间,此时end移动到了前一个元素,所以后来我们需要把end+1赋值为插入的数值:一篇博客读懂排序,C语言,数据结构,数据结构

void InsertSort(int arr[], int n)
{
	int end = 0;
	int tmp = arr[end + 1];
	
	while (end >= 0)
	{
		if (arr[end] > tmp)
		{
			arr[end + 1] = arr[end]; 
			end--;
		}
		else
		{
			break;
		}
	}
	arr[end + 1] = tmp;
}

我们把end作为了已排数列的最后一个元素的位置,由此可知我们的整套排序,end从0到n-1:

void InsertSort(int arr[], int n)
{
	int i = 0;
	for (; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;

	}
}

3.4特点:

时间复杂度:

最坏情况:O(N^2) —— 逆序
最坏情况:O(N) —— 顺序有序

空间复杂度:

O(1)

稳定性:

稳定

什么是稳定性?

保证排序前相同的两个数的相对位置在排序后仍保持不变。 

四、希尔排序

4.1基本思路:

1.预排序:取间隔的数,为一组,对每一组进行插入排序
2.插入排序:对整体进行插入排序

4.2思路讲解:

一篇博客读懂排序,C语言,数据结构,数据结构

4.3代码:

我们把插入排序的单趟间隔从1改为gap,完成希尔排序的第一步:

void ShellSort(int arr[], int n)
{
	int end = 0;
	int gap = 3;
	int tmp = arr[end + 1];

	while (end >= 0)
	{
		if (arr[end] > tmp)
		{
			arr[end + gap] = arr[end];
			end -= gap;
		}
		else
		{
			break;
		}
	}
	arr[end + gap] = tmp;
}

把以上操作重复gap次即为所求代码: 

void ShellSort(int arr[], int n)
{
	int gap = 3;
	for (int j = 0; j < gap; j++)
	{
		for (int i = j; i < n - gap; i += gap)
		{
			int end = i;
			int tmp = arr[end + 1];

			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

 我们可以对上述代码进行优化,让它变为gap组同时排序:

void ShellSort(int arr[], int n)
{
	int gap = 3;
	
	for (int i = 0; i < n - gap; i++)
	{
		int end = i;
		int tmp = arr[end + gap];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + gap] = arr[end];
				end -= gap;
			}
			else
			{
				break;
			}
		}
		arr[end + gap] = tmp;
	}
}

我们这还只是完成了第一步,接下来我们要进行插入排序:

void ShellSort(int arr[], int n)
{
	int gap = 3;
	
	for (int i = 0; i < n - gap; i++)
	{
		int end = i;
		int tmp = arr[end + gap];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + gap] = arr[end];
				end -= gap;
			}
			else
			{
				break;
			}
		}
		arr[end + gap] = tmp;
	}
	int i = 0;
	for (; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];

		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				arr[end + 1] = arr[end];
				end--;
			}
			else
			{
				break;
			}
		}
		arr[end + 1] = tmp;
	}
}

学到这里,其实这些分布的并非是真正的希尔排序,gap到底取多少的值?真的要分成两步?其实希尔排序的gap是随时变换的,最后gap的值为1时,才正好进行最后的插入排序,但gap的取值官方也未说明何时最好,我们只需要保证最后一次排序gap的值刚好为1即可:

void ShellSort(int arr[], int n)
{
	int gap = n;
	while (gap > 1)
	{
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = arr[end + gap];

			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					arr[end + gap] = arr[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			arr[end + gap] = tmp;
		}
	}
}

4.4特点:

希尔排序的复杂度分析是个复杂的问题,它的计算还涉及到数学领域中尚未解决的难题,但有人指出当n在特定范围时,其复杂度接近O(n^1.3),当n->无穷大时,可以减少到O(n*(logn)^2)

时间复杂度:O(n^1.3)

空间复杂度:O(1)

稳定性:不稳定

五、选择排序

5.1基本思路:

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

5.2思路讲解:

选择排序其实没有什么难点,就是挨个比较然后将最小的换到首位,但其实我们可以同时找最大和最小值,然后让其找到对应的位置后再继续找次大的和次小的。

但是有一点需要注意,那就是当最后我们交换时,如果begin位置和maxi位置重合,那么先交换mini和begin的话,就无法找到正确的maxi值,反之同理,所以我们要多加一层判断来确保。

5.3代码:

首先我们先看一下我们需要新添加的变量:
1.标记交换最小值位置的begin和交换最大值位置的end,当一次选择完成后,他们标记的位置就会向后和向前挪动1个单位。
2.标记最大值最小值位置的maxi和mini,我们要记录当前最大值与最小值的元素下标,当每趟结束后与先前记录的begin和end交换。

void SelectSort(int arr[], int n)
{
	int begin = 0;
	int end = n - 1;
	
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin; i <= end; i++)
		{
			if (arr[i] < arr[mini])
			{
				mini = i;
			}
			if (arr[i] > arr[maxi])
			{
				maxi = i;
			}
		}
		Swap(&arr[mini], &arr[begin]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		Swap(&arr[maxi], &arr[end]);
		begin++;
		end--;
	}
}

5.4特点:

时间复杂度:

最好的情况:O(n^2)
最坏的情况:O(n^2)

空间复杂度:O(1)

稳定性:不稳定

六、堆排序

6.1基本思路:

利用大堆或小堆,每次找到一个最大值或最小值作为根结点并输出,再次进行堆排序,找到次大或次小值,重复上述操作。

6.2思路讲解:

一篇博客读懂排序,C语言,数据结构,数据结构
一篇博客读懂排序,C语言,数据结构,数据结构

6.3代码:

void AdjustUp(int* a, int child)
{
	while (child > 0)
	{
		int parent = (child - 1) / 2;
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			child = parent;
		}
		else
		{
			return;
		}
	}
}
void AdjustDown(int* a, int size, int parent)
{
	//假设左孩子小
	int child = parent * 2 + 1;
	while (child < size)
	{
		if (child + 1 < size && a[child] < a[child + 1])
		{
			child = child + 1;
		}
		if (a[parent] < a[child])
		{
			Swap(&a[parent], &a[child]);
			parent = child;
			child = child * 2 + 1;
		}
		else
		{
			return;
		}
	}
}
//升序
void HeapSort(int* a, int n)
{
	//建大堆
	for (int i = 1; i < n; i++)
	{
		AdjustUp(a, i);
	}
	int end = n - 1;
	while (end > 0)
	{
		Swap(&a[0], &a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}

6.4特点:

时间复杂度:O(N*logN)

空间复杂度:O(1)

稳定性:不稳定

七、快速排序(hoare版本)

7.1基本思路:

任取待排序元素序列中 的某元素作为基准值,按照该排序码将待排序集合分割成两子序列,左子序列中所有元素均小于基准值,右子序列中所有元素均大于基准值,然后最左右子序列重复该过程,直到所有元素都排列在相应位置上为止

7.2思路讲解:

我们需要用两个指针,一个从前走,一个从后走,依次筛选满足条件的值,若不满足条件则交换。
还有一个小细节:我们要让右边指针先走,这样左右指针相遇时永远指向比key小的值,这样让left和key交换才能完成排序。

下面我们先来完成单趟,选用一个key值作为基准值,小的排在左边,大的排在右边,这样一次可以把整个数组分为两部分,然后我们还要进行基准值位置的调整,此时的left位置就是key应在的位置。

然后我们再分别对左右两边进行同样的步骤,即递归,当只剩下一个元素时就可以结束我们的递归操作,此时我们的数组也全部排序完成。

7.3代码:

首先我们来看新加变量,left和right指针,负责分别从两侧检索,keyi为此次所选的基准值的下标,但是需要注意的是,我们的left指针和keyi指针不能指向一个位置,我们的keyi指向的元素是不能和right指向的值进行交换的!

void QuickSort(int* a, int n)
{
	int right = n - 1;
	int keyi = 0;
	int left = keyi + 1;
	while (left < right)
	{
		//右边找小 
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		//左边找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
}

完成了单趟排序以后,我们要进行递归调用,所以此时我们函数体引用不便再使用n作为区间标记,而是需要改用begin和end作为区间的分割点,使我们调用函数更加准确,然后递归调用的区间就是[begin,keyi-1] key [key+1,end]

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;
	int keyi = begin;
	int right = end;
	int left = begin;//left和begin位置需要一样 坑一
	while (left < right)
	{
		//右边找小 
		while (left < right && a[right] >= a[keyi])//前面条件 坑二 后面条件=号 坑三
		{
			right--;
		}
		//左边找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	keyi = left;
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

7.4特点:

时间复杂度:O(N*logN)
空间复杂度:O(N)
稳定性:不稳定

八、快速排序(挖坑法和前后指针版本)

8.1挖坑法

8.1.1挖坑法讲解

一篇博客读懂排序,C语言,数据结构,数据结构

一篇博客读懂排序,C语言,数据结构,数据结构一篇博客读懂排序,C语言,数据结构,数据结构
这个方法我原称其为左右横跳方法。这个坑一直在左右横跳,当左右指针相遇时,把Key值填入即可。而且我们可以发现左右指针的规律,没有指向坑的指针走。


8.1.2代码:

我们先把QuickSort的代码改一改,让它能更方便的测试我们的三个方法:
 

//hoare版本
int PartSort1(int* a, int begin, int end)
{
	
	int keyi = begin;
	int right = end;
	int left = begin;
	while (left < right)
	{
		//右边找小 
		while (left < right && a[right] >= a[keyi])
		{
			right--;
		}
		//左边找大
		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}
		Swap(&a[left], &a[right]);
	}
	Swap(&a[keyi], &a[left]);
	return left;
}

void QuickSort(int* a, int begin, int end)
{
	if (begin >= end)
		return;

	int keyi = PartSort1(a, begin, end);
	QuickSort(a, begin, keyi - 1);
	QuickSort(a, keyi + 1, end);
}

我们再来看挖坑法:我们使用数组额外的新变量key来直接控制基准值,我认为这比用数组的某个下标控制更加稳定,然后每次都把坑用key的值填上也是为了更加稳定的控制:

//挖坑法
int PartSort2(int* a, int begin, int end)
{
	int hole = begin;
	int key = a[begin];
	while (begin < end)
	{
		if (begin != hole)
		{
			while (begin < end && a[begin] <= key)
			{
				begin++;
			}
			a[end] = a[begin];
			a[begin] = key;
			hole = begin;
		}
		if (end != hole)
		{
			while (begin < end && a[end] >= key)
			{
				end--;
			}
			a[begin] = a[end];
			a[end] = key;
			hole = end;
		}
	}
	return hole;
}

 8.2前后指针版本

8.1.1前后指针讲解

一篇博客读懂排序,C语言,数据结构,数据结构一篇博客读懂排序,C语言,数据结构,数据结构

其实画图把整个流程完整的走一遍我们就可以知道我们的目的是为了让prev和cur指针中间的值都是比key大的值,然后prev++负责记录下一个大的值,cur负责记录比key小的值,每次找到就交换,最后再把prev的值变为key即可。
如果看不懂,建议自己画一遍实操一下即可。

8.1.2代码: 

//前后指针版本
int PartSort3(int* a, int begin, int end)
{
	int key = a[begin];
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		if (a[cur] < key)
		{
			prev++;
			Swap(&a[cur], &a[prev]);
		}
		cur++;
	}
	Swap(&a[prev], &a[begin]);
	return prev;
}

 我们也可以在第一个大while循环中把if换成while:

int PartSort3(int* a, int begin, int end)
{
	int key = a[begin];
	int prev = begin;
	int cur = begin + 1;
	while (cur <= end)
	{
		while (cur <= end && a[cur] > key)
		{
			cur++;
		}
		if (cur <= end)
		{
			prev++;
			Swap(&a[prev], &a[cur]);
			cur++;
		}
	}
	Swap(&a[prev], &a[begin]);
	return prev;
}

九、归并排序 

9.1基本思路:

归并排序是建立在归并操作上的一种有效的排序算法,该算法是采用分治法的一个非常典型的应用。将已有序的子序列合并,得到完全有序的序列;
即先使每个子序列有序,再使子序列段间有序。若将两个有序表合并成一个有序表,称为二路归并。

9.2思路讲解:

我们的归并排序是运用分治法的一个排序,下面是分的过程:
一篇博客读懂排序,C语言,数据结构,数据结构

 我们看到了控制分停止的条件就是begin>=end,下面我们看合的过程:
一篇博客读懂排序,C语言,数据结构,数据结构

每次合都会把合到一起的几个元素排序,因为我们是数组, 所以我们还需要一个新数组负责挪动数据。 

9.3代码:

根据思路讲解,我们先来看分的过程:

if (begin >= end)
		return;
	//分
	int mid = (begin + end) / 2;
	MergeSort(a, begin, mid, tmp);
	MergeSort(a, mid + 1, end, tmp);

然后我们只需要完成一次合的过程:

    //合
	int begin1 = begin;
	int end1 = mid;

	int begin2 = mid + 1;
	int end2 = end;
	
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2 )
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}

最后把tmp复制到我们正式的数组上即可:文章来源地址https://www.toymoban.com/news/detail-823491.html

memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
void MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;
	//分
	int mid = (begin + end) / 2;
	MergeSort(a, begin, mid, tmp);
	MergeSort(a, mid + 1, end, tmp);
	
	//合
	int begin1 = begin;
	int end1 = mid;

	int begin2 = mid + 1;
	int end2 = end;
	
	int i = begin;
	while (begin1 <= end1 && begin2 <= end2 )
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}
	memcpy(a + begin, tmp + begin, sizeof(int) * (end - begin + 1));
}

9.4特点:

时间复杂度:O(N*logN)
每层的时间复杂度是O(N),因为二分,一共有logN层。
空间复杂度:O(N)
稳定性:
一篇博客读懂排序,C语言,数据结构,数据结构

到了这里,关于一篇博客读懂排序的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • [数据结构 -- 手撕排序算法第六篇] 递归实现快速排序(集霍尔版本,挖坑法,前后指针法为一篇的实现方法,很能打)

    目录 1、常见的排序算法 1.1 交换排序基本思想 2、快速排序的实现方法 2.1 基本思想 3 hoare(霍尔)版本 3.1 实现思路 3.2 思路图解 3.3 为什么实现思路的步骤2、3不能交换 3.4 hoare版本代码实现 3.5 hoare版本代码测试 4、挖坑法 4.1 实现思路 4.2 思路图解 4.3 挖坑法代码实现 4.4 挖坑

    2024年02月16日
    浏览(44)
  • 数据结构——排序算法(C语言)

    本篇将详细讲一下以下排序算法: 直接插入排序 希尔排序 选择排序 快速排序 归并排序 计数排序 排序的概念 排序:所谓排序,就是使一串记录,按照其中的某个或某写的大小,按照递增或递减0排列起来的操作。 稳定性的概念 假定在待排序的记录序列中,存在多个

    2024年02月08日
    浏览(62)
  • 【C语言】数据结构——排序三(归并与计数排序)

    💗个人主页💗 ⭐个人专栏——数据结构学习⭐ 💫点击关注🤩一起学习C语言💯💫 我们在前面学习了排序,包括直接插入排序,希尔排序,选择排序,堆排序,冒泡排序和快排。 今天我们来讲一讲归并排序和计数排序。 关注博主或是订阅专栏,掌握第一消息。 归并排序的

    2024年01月19日
    浏览(55)
  • 『初阶数据结构 • C语言』⑥ - 插入排序&希尔排序

    学习目标 写在前面 1.插入排序 2.插入排序实战  3.插入排序的实现  4.插入排序的效率 5.平均情况 6.希尔排序 7.希尔排序的实现 8.希尔排序的效率 9.总结   之前我们衡量一个算法的效率时,都是着眼于它在最坏情况下需要多少步。原因很简单,连最坏的情况都做足准备了,其

    2024年02月15日
    浏览(40)
  • 常见排序集锦-C语言实现数据结构

    目录 排序的概念 常见排序集锦      1.直接插入排序      2.希尔排序      3.选择排序      4.堆排序      5.冒泡排序      6.快速排序             hoare              挖坑法             前后指针法             非递归      7.归并排序             非递归 排序实现

    2024年02月12日
    浏览(47)
  • 数据结构与算法——排序(C语言实现)

    ✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅✅ ✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨✨ 🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿🌿 🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟🌟 🌟🌟 追风赶月莫停留 🌟🌟 🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀🍀 🌟🌟 平芜尽处是春山

    2024年04月09日
    浏览(55)
  • 数据结构——C语言实现常见排序(插入排序、希尔排序、选择排序、堆排序、冒泡排序)

    现在是北京时间2023年6月23日13点19分,度过了一个非常愉快的端午节。由于刚从学校回家,一下子伙食强度直升了个两三个档次。这也导致我的肠胃不堪重负,我也准备等会去健身房消耗一下盈余的热量。回到家陪伴爷爷走人生最后的阶段才是我这个暑假最重要的事情。自从

    2024年02月10日
    浏览(49)
  • 『初阶数据结构 • C语言』④ - 冒泡排序

      本文内容借鉴一本我非常喜欢的书——《数据结构与算法图解》。学习之余,我决定把这本书精彩的部分摘录出来与大家分享。      本章内容 写在前面 1.冒泡排序 2.冒泡排序实战 3.冒泡排序的实现 4.冒泡排序的效率 5.二次问题 6.线性解决 7.总结     大 O记法能客观地衡量

    2024年02月16日
    浏览(44)
  • 『初阶数据结构 • C语言』⑤ - 选择排序

    本文内容借鉴一本我非常喜欢的书——《数据结构与算法图解》。学习之余,我决定把这本书精彩的部分摘录出来与大家分享。     目录 写在前面 1.选择排序 2.选择排序实战 3.选择排序的实现 4.选择排序的效率 5.忽略常数 6.大O的作用 7.总结     大 O 是一种能够比较算法效

    2024年02月14日
    浏览(43)
  • 内部排序算法比较-数据结构C语言课设

    名称: 内部排序算法比较 内容: 在教科书中,各种内部排序算法的时间复杂的分析结果只给出了算法执行时间的阶,或大概执行时间。试通过随机数据比较各种算法的比较次数和移动次数,以取得直观感受。 任务: (1)对以下7中常会用的内部排序算法进行比较

    2024年02月12日
    浏览(53)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包