4种编程中常考的排序方法(选择，冒泡，快速，二路归并)_排序编程

---

1丶选择排序

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小(或最大)的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
我们来看一下代码：

void SelectionSort(int arr[]) {
	for (int i = 0; i < 9; i++) {
		for (int j = i + 1; j < 10; j++) {
			if (arr[i] > arr[j]) {
				int tmp = arr[i];
				arr[i] = arr[j];
				arr[j] = tmp;
			}

		}
	}
}
1
2
3
4
5
6
7
8
9
10
11
12

我们来看一个实例：

#include <stdio.h>
#include <string.h>
void SelectionSort(int arr[]) {
	for (int i = 0; i < 9; i++) {
		for (int j = i + 1; j < 10; j++) {
			if (arr[i] > arr[j]) {
				int tmp = arr[i];
				arr[i] = arr[j];
				arr[j] = tmp;
			}

		}
	}
}
int main() {
	int arr[10] = { 7,6,4,2,1,7,9,6,4,6 };
	for (int i = 0; i < 10; i++) {
		printf("%d", arr[i]);   //打印排序前的数组
	}
	printf("\n");
	SelectionSort(arr);
	for(int i = 0; i < 10; i++) {
		printf("%d",arr[i]);   //打印排序后的数组
	}
	




	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

我们来看一下运行结果：

打印前是乱序，打印后是有序的，说明我们的算法没问题。

2丶冒泡排序

冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个排序之前的文章写过，下面为原文链接：

   [冒泡排序](https://blog.csdn.net/weixin_63257947/article/details/123186460)
1

3丶快速排序

快速排序(Quicksort)是对冒泡排序的改进，它的基本思想是:通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

代码：

void quickSort(int a[], int left, int right)    //start和end都是指下标
{
	if (left > right)          //如果左边下标比右边大，是不合法的
		return;
    int base = a[left];      //保存基准数
    int i = left;
    int j = right;
	while (i != j)
	{
		while (a[j] >= base && i < j) {
			j--;
		}
		while (a[i] <= base && i < j) {
			i++;
		}
		if (j > i) {
			int tmp = a[i];        //i和j都停下，交换i和j的元素
			a[i] = a[j];
			a[j] = tmp;
		}
	}
	a[left] = a[i];
	a[i] = base;       //把基准数赋值给相遇位置的元素
	quickSort(a, left, i - 1);  //左边递归进行快速排序
	quickSort(a, j+1, right);   //右边递归进行快速排序
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

实例：

4丶归并排序

归并排序是建立在归并操作上的一种有效，稳定的排序算法，该算法是采用分治法(Divide and Conquer)的一个非常典型的应用。
代码：

void Emergesort(int arr[],int left,int right) {
	if (left >= right)
		return ;
	int mid = (left + right) / 2;
	int* temp = (int*)malloc(sizeof(int) * (right - left + 1));
	if (temp == NULL)
		return;
	Emergesort(arr, left, mid);    //左边归并
	Emergesort(arr, mid + 1, right); //右边归并
	 int i = left;
	 int j = mid+1;
	 int k = 0;
	 while (i <= mid && j <= right) {
		 if (arr[i] < arr[j])
			 temp[k++] = arr[i++];
		 else
		 temp[k++] = arr[j++];   //有序放入辅助数组
	 }
	 while (i <= mid) {
		 temp[k++] = arr[i++];
	 }
	 while (j <= right) {
		 temp[k++] = arr[j++];
	 }
	 for (i = 0; i <= right - left; i++) {
		 arr[left+i] = temp[i];   //辅助数组给原数组赋值
	 }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

实例：


排序成功