常见排序算法实现

最新推荐文章于 2024-07-13 18:41:46 发布
最新推荐文章于 2024-07-13 18:41:46 发布
阅读量1.1k 收藏 29
点赞数 40
分类专栏： C++ 文章标签： 排序算法 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xiang2992/article/details/135609569
版权

  目录

  1. 冒泡排序
  2. 插入排序
  3. 希尔排序
  4. 选择排序
  5. 堆排序
  6. 快速排序
  7. 归并排序
  8. 计数排序

一.冒泡排序

算法思路：

通过多次遍历 不断比较并交换相邻的元素，直到所有元素有序。

交换过程

代码如下：

// 冒泡排序 
void BubbleSort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		bool exchange = false;
		for (int i = 1; i < n-j; i++)
		{
			if (a[i - 1] > a[i])
			{
				swap(a[i - 1], a[i]);
				exchange = true;
			}
		}

		if (exchange == false)
			break;
	}
}

复杂度分析：

时间复杂度最坏情况：O(n^2)

时间复杂度最好情况：当排序元素本身极度接近或有序时 只需遍历一遍 O(n^2）  

空间复杂度：O(1)

二.插入排序

算法思路：

把待排序的元素按其大小逐个插入到一个已经排好序的有序序列中，直到所有的元素插入完为止，得到一个新的有序序列 。

交换过程

代码如下：

// 插入排序
void InsertSort(int* a, int n)
{
	// [0, end] end+1
	for (int i = 0; i < n-1; ++i)
	{
		int end = i;
		int tmp = a[end + 1];
		while (end >= 0)
		{
			if (tmp > a[end])
			{
				a[end + 1] = a[end];
				--end;
			}
			else
			{
				break;
			}
		}

		a[end + 1] = tmp;
	}
}

时间复杂度分析：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高

2. 时间复杂度：O(N^2)

3. 空间复杂度：O(1)，它是一种稳定的排序算法

三.希尔排序

算法思路：

先选定一个小于N的整数gap，将所有距离为gap的元素分在同一组内，并对每一组内的元素进行直接插入排序。重复上述分组和排序的工作。当gap=1时，排序完成。

交换过程

代码如下：

// 希尔排序
void ShellSort(int* a, int n)
{
	int gap = n;

	// gap > 1时是预排序，目的让他接近有序
	// gap == 1是直接插入排序，目的是让他有序
	while (gap > 1)
	{
		//gap = gap / 2;
		gap = gap / 3 + 1;

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

 复杂度分析：

希尔排序的时间复杂度由于gap的取值不同以及牵扯一些数学上未被证明的问题，无法严格证明，目前一般认为O(n^1.3)。

 四.选择排序

算法思路：

每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的 数据元素排完 。实际上，一趟选出最大值和最小值，将其放在序列开头和末尾，可使选择排序的效率快一倍。

交换过程

代码如下：

// 选择排序
void SelectSort(int* a, int n)
{
	int begin = 0, end = n - 1;

	while (begin < end)
	{
		int mini = begin, maxi = begin;
		for (int i = begin + 1; i <= end; ++i)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}

			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

		swap(a[begin], a[mini]);
		if (maxi == begin)
		{
			maxi = mini;
		}
		swap(a[end], a[maxi]);

		++begin;
		--end;
	}
}

复杂度分析：

直接选择排序思考非常好理解，但是效率不是很好。实际中很少使用。

时间复杂度：O(N^2)

空间复杂度：O(1)

 五.堆排序

算法思路：

堆排序是指利用堆这种数据结构所设计的一种排序算法，它是选择排序的一种。它是通过堆来进行选择数据。需要注意的是排升序要建大堆，排降序建小堆。

交换过程

代码如下：

// 堆排序

void down(int u)
{
    int t = u;
    if (2 * u <= mySize && h[t] > h[2 * u])
        t = 2 * u;
    if (2 * u + 1 <= mySize && h[t] > h[2 * u + 1])
        t = 2 * u + 1;
    if (u != t)
    {
        swap(h[u], h[t]);
        down(t);
    }
}

int main()
{
    //排出n个数中最小(大)的前m个数
    cin >> n >> m;
    mySize = n;
    for (int i = 1; i <= n; i++)
        scanf("%d", &h[i]);
    for (int i = n / 2; i; i--)
        down(i);

    while (m--)
    {
        cout << h[1] << " ";
        h[1] = h[mySize--];
        down(1);
    }

    return 0;
}

复杂度分析：

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

空间复杂度：O(1)

  六.快速排序

算法思路：

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

交换过程

1.单趟排序

2.整体过程

代码如下：


// hoare
int PartSort1(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	swap(a[midi], a[begin]);

	int left = begin, right = end;
	int keyi = 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[left], a[keyi]);

	return left;
}

// 挖坑法
int PartSort2(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	swap(a[midi], a[begin]);

	int key = a[begin];
	int hole = begin;
	while (begin < end)
	{
		// 右边找小，填到左边的坑
		while (begin < end && a[end] >= key)
		{
			--end;
		}

		a[hole] = a[end];
		hole = end;

		// 左边找大，填到右边的坑
		while (begin < end && a[begin] <= key)
		{
			++begin;
		}

		a[hole] = a[begin];
		hole = begin;
	}

	a[hole] = key;
	return hole;
}

// 前后指针法
int PartSort3(int* a, int begin, int end)
{
	int midi = GetMidi(a, begin, end);
	swap(a[midi], a[begin]);
	int keyi = begin;

	int prev = begin;
	int cur = prev + 1;
	while (cur <= end)
	{
		if (a[cur] < a[keyi] && ++prev != cur)
			Swap(&a[prev], &a[cur]);

		++cur;
	}

	swap(a[prev], a[keyi]);
	keyi = prev;
	return keyi;
}

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

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

// 快速排序 栈优化 非递归
void QuickSortNonR(int* a, int begin, int end)
{
	ST s;
	STInit(&s);
	STPush(&s, end);
	STPush(&s, begin);

	while(!STEmpty(&s))
	{
		int left = STTop(&s);
		STPop(&s);
		int right = STTop(&s);
		STPop(&s);

		int keyi = PartSort3(a, left, right);
		// [left, keyi-1] keyi [keyi+1, right]
		if (left < keyi - 1)
		{
			STPush(&s, keyi - 1);
			STPush(&s, left);
		}

		if (keyi + 1 < right)
		{
			STPush(&s, right);
			STPush(&s, keyi+1);
		}
	}

	STDestroy(&s);
}

复杂度分析：

快速排序整体的综合性能和使用场景都是比较好的，所以才敢叫快速排序

空间复杂度：O(NlogN)

时间复杂度：O(logN）

 七.归并排序

算法思路：

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

交换过程

代码如下：

//归并排序
void _MergeSort(int* a, int begin, int end, int* tmp)
{
	if (begin >= end)
		return;

	int mid = (begin + end) / 2;
	// [begin, mid][mid+1, end]
	_MergeSort(a, begin, mid, tmp);
	_MergeSort(a, mid+1, end, tmp);

	// [begin, mid][mid+1, end]归并
	int begin1 = begin, end1 = mid;
	int begin2 = mid + 1, 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));
}

void MergeSort(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}

	_MergeSort(a, 0, n - 1, tmp);

	free(tmp);
}


// 归并排序 非递归 循环写法
void MergeSortNonR(int* a, int n)
{
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc fail");
		return;
	}

	int gap = 1;
	while (gap < n)
	{
		//printf("gap:%2d->", gap);
		for (size_t i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i, end1 = i + gap - 1;
			int begin2 = i + gap, end2 = i + 2 * gap - 1;
			// [begin1, end1][begin2, end2] 归并
			//printf("[%2d,%2d][%2d, %2d] ", begin1, end1, begin2, end2);

			// 边界的处理
			if (end1 >= n || begin2 >= n)
			{
				break;
			}

			if (end2 >= n)
			{
				end2 = n - 1;
			}

			//printf("[%2d,%2d][%2d, %2d] ", begin1, end1, begin2, end2);

			int j = begin1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] < a[begin2])
				{
					tmp[j++] = a[begin1++];
				}
				else
				{
					tmp[j++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tmp[j++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tmp[j++] = a[begin2++];
			}
            //一定注意memcpy 位置
			memcpy(a + i, tmp + i, sizeof(int) * (end2-i+1));
		}

		printf("\n");

		gap *= 2;
	}


	free(tmp);
}

复杂度分析：

归并的缺点在于需要O(N)的空间复杂度，归并排序的思考更多的是解决在磁盘中的外排序问题。

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

空间复杂度：O(N)

 八.计数排序

算法思路：

计数排序是一种非比较性的排序算法，它通过统计数组中每个元素出现的次数，然后根据元素的值和出现次数重新构建排序后的数组。

交换过程

代码如下：

// 计数排序
void CountSort(int* a, int n)
{
	int min = a[0], max = a[0];
	for (int i = 1; i < n; i++)
	{
		if (a[i] < min)
			min = a[i];

		if (a[i] > max)
			max = a[i];
	}

	int range = max - min + 1;
	int* count = (int*)calloc(range, sizeof(int));
	if (count == NULL)
	{
		printf("calloc fail\n");
		return;
	}

	// 统计次数
	for (int i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}

	// 排序
	int i = 0;
	for (int j = 0; j < range; j++)
	{
		while (count[j]--)
		{
			a[i++] = j + min;
		}
	}
}

复杂度分析：

计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。

时间复杂度：O(MAX(N,范围))

空间复杂度：O(范围)

Xiang2992
关注
  • 40
    点赞
  • 踩
  • 29
    收藏
    觉得还不错? 一键收藏
  • 7
    评论
专栏目录
php实现的常见排序算法汇总
10-25
主要介绍了php实现的常见排序算法汇总,包括插入排序、选择排序、冒泡排序、快速排序、归并排序与堆排序,并附有对排序算法的详细说明,需要的朋友可以参考下
python 常见的排序算法实现汇总
09-16
本文将深入探讨几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、希尔排序、快速排序和归并排序。这些算法主要分为比较类排序，它们通过元素之间的比较来决定顺序。 1. **冒泡排序**：冒泡...
八大排序算法（C语言实现）
2021dragon的博客
05-16 8万+
文章目录插入排序插入排序希尔排序选择排序选择排序堆排序交换排序冒泡排序快速排序并归排序并归排序 插入排序 插入排序 希尔排序 选择排序 选择排序 堆排序 交换排序 冒泡排序 快速排序 并归排序 并归排序 ...
js实现常见排序算法
m0_46312541的博客
08-20 1417
用js实现了常见的排序算法，并且通过对数器对实现的排序算法进行了比较。冒泡排序，插入排序，选择排序，希尔排序，归并排序，快速排序
常见排序算法汇总
夜槿笙歌的博客
04-17 8270
整理一下之前学习的各种排序算法
常用十大排序算法
qq_51664685的博客
04-26 13万+
列举了常见的十大内部排序算法：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序，计数排序，桶排序。
十大排序算法
个人站点：javatv.net
08-20 2万+
冒泡排序 从数组头开始，比较相邻的元素。如果第一个比第二个大(小)，就交换它们两个 对每一对相邻元素作同样的工作，从开始第一对到尾部的最后一对，这样在最后的元素应该会是最大(小)的数 重复步骤1~2，重复次数等于数组的长度，直到排序完成 代码实现 对下面数组实现排序：{24, 7, 43, 78, 62, 98, 82, 18, 54, 37, 73, 9} 代码实现 public class BubbleSort { public static final int[] ARRAY = {2
Java常见排序算法
Meng
07-10 2373
目录1、归并排序2、堆排序3、基数排序4、冒泡排序5、希尔排序6、快速排序7、插入排序8、选择排序1、基本思想归并排序（MERGE-SORT）是利用归并的思想实现的排序方法，该算法采用经典的分治（divide-and-conquer）策略（分治法将问题分(divide)成一些小的问题然后递归求解，而治(conquer)的阶段则将分的阶段得到的各答案"修补"在一起，即分而治之)。2、代码实现1、基本思想堆排序是利用堆这种数据结构而设计的一种排序算法，堆排序是一种选择排序，它的最坏，最好，平均时间复杂度均为O(
C++实现五种常见排序算法
weixin_39318565的博客
06-20 5227
排序算法在工作和面试中都经常用到这里是常见的几种算法的C++实现
常见的7种排序算法
热门推荐
ispurs的博客
06-10 31万+
1、冒泡排序 最简单的一种排序算法。假设长度为n的数组arr，要按照从小到大排序。则冒泡排序的具体过程可以描述为：首先从数组的第一个元素开始到数组最后一个元素为止，对数组中相邻的两个元素进行比较，如果位于数组左端的元素大于数组右端的元素，则交换这两个元素在数组中的位置，此时数组最右端的元素即为该数组中所有元素的最大值。接着对该数组剩下的n-1个元素进行冒泡排序，直到整个数组有序排列。算法的时间复...
python实现常见的排序算法
缘来如此
05-07 2701
# coding: utf-8 """常见排序算法正序实现""" def bubble_sort(arr): """ 冒泡排序：稳定排序，最差和平均时间复杂度O(n^2)，最优情况是O(n)，即原数组是已排好序的情况，空间复杂度O(1)，即交换操作时使用的临时空间 实现：比较相邻元素，将较小的放在前面，重复执行，直到所有元素满足正序。 """ n = len(arr) for i in range(0, n): # 表示排序的轮次 is.
python实现五种常见排序算法
12-21
以下是用Python实现的五种常见排序算法： 1. 冒泡排序（Bubble Sort）： ```python def bubble_sort(arr): n = len(arr) for i in range(n): for j in range(0, n-i-1): if arr[j] > arr[j+1]: arr[j], arr[j+...
常见排序算法.docx
02-22
常见的排序算法包括冒泡排序、选择排序和快速排序，这些算法各有特点，适用于不同的场景。 【冒泡排序】 冒泡排序是一种简单直观的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把...
【排序 - 堆排序】
2302_80393814的博客
07-10 539
堆排序利用堆这种数据结构的特性，通过构建最大堆和不断调整堆的过程来实现排序。它的时间复杂度稳定在 O(n log n)，并且适用于大数据量的排序需求。通过本文，我们深入了解了堆排序的原理和实现方式，并通过C语言代码展示了如何实现堆排序算法。对于理解高效排序算法和算法设计有着重要的帮助。
排序之冒泡排序
最新发布
weixin_50960004的博客
07-13 271
lo,hi)，通过一个标志记录逆序的元素 ，该标志控制外层循环。
【排序 - 选择排序优化版（利用堆排序）】
2302_80393814的博客
07-10 448
结合选择排序和堆排序的思路，可以通过利用堆数据结构来优化选择排序的过程，使得排序算法更加高效。在这种结合中，我们利用堆的特性来快速定位和选择未排序部分的最小元素，避免了选择排序中每次线性搜索的开销。
36. Adam 算法详解
qq_41238579的博客
07-10 953
Adam（Adaptive Moment Estimation）是一种结合动量法和自适应学习率的优化算法，自2014年提出以来，迅速成为深度学习中最流行和常用的优化算法之一。Adam算法的核心思想是利用梯度的一阶动量和二阶动量来动态调整学习率，既保持了动量法的优点，又结合了RMSProp的自适应学习率特性。
函数模板与类模板
程序员_小兵
07-12 1541
/交换int数据a = b;b = temp;//交换char数据a = b;b = temp;//问题：如果我要交换double类型数据，那么还需要些一个double类型数据交换的函数//繁琐，写的函数越多，当交换逻辑发生变化的时候，所有的函数都需要修改，无形当中增加了代码的维护难度//如果能把类型作为参数传递进来就好了，传递int就是Int类型交换，传递char就是char类型交换//我们有一种技术，可以实现类型的参数化---函数模板。
常见排序算法java实现
07-12
常见的排序算法有许多种，以下是一些常见的排序算法的Java实现示例： 1. 冒泡排序（Bubble Sort）： ```java public void bubbleSort(int[] arr) { int n = arr.length; for (int i = 0; i < n - 1; i++) { for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j + 1]) { // 交换arr[j]和arr[j+1] int temp = arr[j]; arr[j] = arr[j + 1]; arr[j + 1] = temp; } } } } ``` 2. 插入排序（Insertion Sort）： ```java public void insertionSort(int[] arr) { int n = arr.length; for (int i = 1; i < n; ++i) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j + 1] = arr[j]; j = j - 1; } arr[j + 1] = key; } } ``` 3. 选择排序（Selection Sort）： ```java public void selectionSort(int[] arr) { int n = arr.length; for (int i = 0; i < n-1; i++) { int minIndex = i; for (int j = i+1; j < n; j++) { if (arr[j] < arr[minIndex]) { minIndex = j; } } // 交换arr[i]和arr[minIndex] int temp = arr[minIndex]; arr[minIndex] = arr[i]; arr[i] = temp; } } ``` 4. 快速排序（Quick Sort）： ```java public void quickSort(int[] arr, int low, int high) { if (low < high) { int pi = partition(arr, low, high); quickSort(arr, low, pi - 1); quickSort(arr, pi + 1, high); } } private int partition(int[] arr, int low, int high) { int pivot = arr[high]; int i = (low - 1); for (int j = low; j <= high - 1; j++) { if (arr[j] < pivot) { i++; // 交换arr[i]和arr[j] int temp = arr[i]; arr[i] = arr[j]; arr[j] = temp; } } // 交换arr[i+1]和arr[high] int temp = arr[i + 1]; arr[i + 1] = arr[high]; arr[high] = temp; return i + 1; } ``` 这些只是一些常见的排序算法的示例，还有其他排序算法，如归并排序、堆排序等。你可以根据需要选择适合的排序算法进行实现。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值