数据结构-C冒泡排序、合并排序、快速排序

C 排序分析

1 冒泡排序

1.1 算法基本思想分析

冒泡排序是典型的交换排序。交换排序就是通过元素的两两比较，判断是否符合要求，如果不符合就交换位置来达到排序的目的。
冒泡排序的基本思想就是利用比较交换，利用循环将第i小或者大的元素归位，归位操作利用对n个元素相邻的两个进行比较，如果顺序正确就不交换，如果顺序错误就进行位置的交换。通过重复的循环访问数组，知道没有可以交换的元素，那么整个排序就已经完成。

1.2 时间复杂度及稳定性

算法	最好时间	最坏时间	平均时间	额外空间	稳定性
冒泡排序	O(n)	O(n2)	O(n2)	1	稳定

1.3 代码实现

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

//时间复杂度为O（n2)平方

void BubbleSort(int *arr, int num)
{
	for (int i = 0; i < num - 1; i++)
	{
		for (int j = 0; j < num - i - 1; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j + 1];
				arr[j + 1] = arr[j];
				arr[j] = temp;
			}
		}
	}
	return;
}

int main()
{
	int number = 0;
	printf("请输入元素的个数：");
	scanf_s("%d",&number);
	int *array = (int *)malloc(number*sizeof(int));

	printf("请输入%d个元素：", number);
	for (int i = 0; i < number; i++)
	{
		scanf_s("%d", &array[i]);
	}

	BubbleSort(array, number);
	for (int i = 0; i < number; i++)
	{
		printf("%d ", array[i]);
	}

	return 0;
}

2 归并排序

2.1 算法基本思想分析

归并排序方法就是把一组n个数的序列，从中间分为两个序列，然后再把这两个序列一直分下去，一直分到n个长度为1的序列；然后两两按大小进行归并，如此反复，直到最后形成包含n个数的一个数组。
归并排序总时间=分解时间+子序列排序时间+合并时间

2.2 时间复杂度及稳定性

算法	最好时间	最坏时间	平均时间	额外空间	稳定性
归并排序	O(nlogn)	O(nlogn)	O(nlogn)	------	稳定

2.3 代码实现

#include <stdio.h>
#include <stdlib.h>
#define ArrLen 50


void Merge(int *arr, int start, int mid, int end)
{
	int result[ArrLen];
	int k = 0;
	int i = start;
	int j = mid + 1;
	while (i <= mid && j <= end)
	{
		if (arr[i] < arr[j])
		{
			result[k] = arr[i];
			k++;
			i++;
		}
		else {
			result[k] = arr[j];
			k++;
			j++;
		}
	}
	while (i <= mid)
	{
		result[k++] = arr[i++];
	}
	while (j <= end)
	{
		result[k++] = arr[j++];
	}

	for (i = start, j = 0; j < k; i++, j++)
	{
		arr[i] = result[j];
	}

}


void MergeSort(int *arr, int start, int end)
{
	if (start >= end) 
		return;
	int mid = (start + end) / 2;
	MergeSort(arr, start, mid);
	MergeSort(arr, mid + 1, end);
	Merge(arr,start, mid, end);
}


int main()
{
	int number = 0;
	printf("请输入元素的数量：");
	scanf_s("%d", &number);
	int *array = (int *)malloc(number * sizeof(int));

	// 50 10 90 30 70 40
	printf("请输入%d个元素：", number);
	for (int i = 0; i < number; i++)
	{
		scanf_s("%d", &array[i]);
	}

	MergeSort(array, 0, number - 1);
	printf("排序后的元素顺序为：");
	for (int i = 0; i < number; i++)
	{
		printf("%d ", array[i]);
	}

	return 0;
}

3 快速排序

3.1 算法基本思想分析

1.在数组中选一个基准书（通常为数组第一个）；
2.将数组中小于基准数的数据移到基准数左边，大于基准数的移到右边；
3.对于基准数左右两边的数组，不断重复以上两个过程，直到每个子集只有一个元素，即为全部有序。

3.2 时间复杂度及稳定性

算法	最好时间	最坏时间	平均时间	额外空间	稳定性
快速排序	O(nlogn)	O(n2)	O(nlogn)	------	非稳定

3.3 代码实现

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

void QuickSort(int *arr, int left, int right)
{
	if (left >= right)
		return;

	int i = left;
	int j = right;
	int key = arr[left];

	while (i < j)
	{
		while (i<j &&arr[j]>key)
		{
			j--;
		}
		arr[i] = arr[j];

		while (i < j&&arr[i] < key)
		{
			i++;
		}
		arr[j] = arr[i];
	}
	arr[i] = key;

	QuickSort(arr, left, i-1);
	QuickSort(arr, i + 1, right);
}

int main()
{
	int number = 0;
	printf("请输入元素的数量：");
	scanf_s("%d", &number);
	int *array = (int *)malloc(number * sizeof(int));

	// 50 10 90 30 70 40
	printf("请输入%d个元素：", number);
	for (int i = 0; i < number; i++)
	{
		scanf_s("%d", &array[i]);
	}

	QuickSort(array, 0, number - 1);
	printf("排序后的元素顺序为：");
	for (int i = 0; i < number; i++)
	{
		printf("%d ", array[i]);
	}

	free(array);

	return 0;
}