【排序算法二】冒泡选择插入希尔归并排序算法（C++）

最新推荐文章于 2024-11-06 18:34:45 发布

大橙学iOS

最新推荐文章于 2024-11-06 18:34:45 发布

阅读量147

点赞数

文章标签：排序算法堆排序

本文链接：https://blog.csdn.net/qq_40641491/article/details/104495877

版权

各种排序算法的思想不在详细介绍，直接看代码（不唯一）
文章底部有各种排序算法的时间复杂度

冒泡排序算法

void bubble_sort(int arr[],int len)//len为数组a的元素个数
{
	int i,j,temp;
	//一定进行len-1轮比较
	for (i=0;i<len-1;i++)
	//每一轮比较前len-1-i个，即已排序好的最后i个不用进行比较
		for (j=0;j<len-1-i;j++)
			if ( arr[j] > arr[j+1] )
			{
				temp = arr[j];
				arr[j] = arr[j+1];
				arr[j+1] = temp;
			}
}

选择排序算法

void selection_sort(int arr[], int len)
{
	int i,j,temp;
	for (i=0;i<len;i++)
		for (j=i+1;j<len;j++)
			if ( arr[j] < arr[i] )
			{
				temp = arr[i];
				arr[i] = arr[j];
				arr[j] = temp;
			}
}

插入排序

void insertion_sort(int arr[], int len)
{

	int i,j ,temp;
	for( i=1; i<len; i++)
	{
		temp = arr[i];
		for (j=i;j>0 ;j--)   //多理解一下
			if( arr[j-1] > temp)
				arr[j] = arr[j-1];
			else
				break;  //一定要想明白为什么可以用break
		arr[j] = temp;
	}	
}

希尔排序

void shell_sort(int arr[], int len) 
{
    int gap, i, j;
    int temp;
    for (gap = len >> 1; gap > 0; gap = gap >> 1)
        for (i = gap; i < len; i++) 
        {
            temp = arr[i];
            for (j = i - gap; j >= 0 && arr[j] > temp; j -= gap)
                arr[j + gap] = arr[j];
            arr[j + gap] = temp;
        }
}

归并排序

void merge_sort_recursive(int arr[], int reg[], int start, int end) {
    if (start >= end)
        return;
    int len = end - start, mid = (len >> 1) + start;
    int start1 = start, end1 = mid;
    int start2 = mid + 1, end2 = end;
    merge_sort_recursive(arr, reg, start1, end1);
    merge_sort_recursive(arr, reg, start2, end2);
    int k = start;
    while (start1 <= end1 && start2 <= end2)
        reg[k++] = arr[start1] < arr[start2] ? arr[start1++] : arr[start2++];
    while (start1 <= end1)
        reg[k++] = arr[start1++];
    while (start2 <= end2)
        reg[k++] = arr[start2++];
    for (k = start; k <= end; k++)
        arr[k] = reg[k];
}

void merge_sort(int arr[],  int len)
 {
    int *reg = (int *)malloc(sizeof(int)*len);
    merge_sort_recursive(arr, reg, 0, len - 1);
}

时间复杂度分析

排序方法	平均时间	最好时间	最坏时间
冒泡排序（稳定）	O（n²）	O（n）	O(n²)
选择排序（不稳定）	O（n²）	O（n²）	O（n²）
插入排序（稳定）	O（n²）	O（n）	O（n²）
希尔排序（不稳定）	O（n^1.25）
堆排序（不稳定）	O（n logn）	O（n logn)	O（n logn)
快速排序（不稳定）	O（n logn)	O（n logn)	O（n²）