数据结构排序2-希尔，快速，归并排序

最新推荐文章于 2023-04-03 16:16:17 发布

chde2Wang

最新推荐文章于 2023-04-03 16:16:17 发布

阅读量223

点赞数 1

分类专栏：数据结构 C，C++数据结构

本文链接：https://blog.csdn.net/weixin_38383877/article/details/91506258

版权

数据结构同时被 2 个专栏收录

24 篇文章 0 订阅

订阅专栏

C，C++数据结构

24 篇文章 0 订阅

订阅专栏

希尔排序

希尔排序是对插入排序的改进。增加了分组

分组插入排序降低元素个数，然后对每组分别进行插入排序
利用分组增量遍历，因为最后必须全部排序一次，然后分别对每组插入排序。把每组的第一个数作为有序序列，
要比较的第一个基准数就是第二个

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<random>
#include<time.h>
#include<sys/timeb.h>
using namespace std;
#define MAX 50000

long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;  //毫秒
}

void printArr(int arr[], int length)
{
	for (int i = 0; i < length; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}
//插入排序
void insertSort(int arr[], int length)
{
	int j;
	for (int i = 1; i < length; i++)  //从第二个数开始是无序队列。第一个数为有序队列
	{
		if (arr[i]<arr[i - 1])
		{
			int temp = arr[i];  //将满足条件的元素缓冲到temp中
			for (j = i - 1; j >= 0 && temp < arr[j]; j--)  //将有序数列分别遍历
			{
				arr[j + 1] = arr[j];
			}
			arr[j + 1] = temp;  //填补坑
		}
	}
}
//错误
void shellSortme(int arr[], int length)
{
	int increasement = length;
	//确定分组的增量
	increasement = increasement /3+1;
	int i, j, k;
	for (i = 0; i < increasement; i++)  //外层分组循环，最后等于1时全部再一起排列一次
	{
		for (j = i + increasement; j < length; j += increasement)  //从i+creasement是无序的第一个数
		{
			if (arr[i + increasement] < arr[i])
			{
				int temp=arr[i];
				for (k = i + increasement; k < j && arr[k] < temp; k -= increasement)
				{
					arr[k] = arr[k + 1];
				}
				arr[k + 1] = temp;
			}
		}
	}
}

void shellSort(int arr[], int length)
{
	int increasement = length;
	
	int i, j, k;
	do {
		//确定分组的增量
		increasement = increasement / 3 + 1;
		//外层分组循环，最后等于1时全部再一起排列一次
		for (i = 0; i < increasement; i++)  
		{
			//从i+creasement是无序的第一个数
			for (j = i + increasement; j < length; j += increasement)  
			{
				if (arr[j] < arr[j - increasement])
				{
					int temp = arr[j];
					//temp如果大于arr[k]的话，就不需要移动元素。
					//只有temp小于arr[k]即有序数组的其中一个数，才需要继续往前移动
					for (k = j - increasement; k >= 0 && temp<arr[k]; k -= increasement)
					{
						arr[k + increasement] = arr[k];  //将满足条件有序的元素往后移动
					}
					arr[k + increasement] = temp;
				}
			}
		}
	} while (increasement > 1);
}

int main()
{
	int arr[MAX];
	srand((unsigned int)time(NULL));  //种子
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	//printf("未排序数组为：");
	//printArr(arr, MAX);
	long t_start = getSystemTime();
	shellSort(arr, MAX);
	long t_end = getSystemTime();
	//printf("希尔排序后数组为：");
	//printArr(arr, MAX);
	printf("希尔排序%d个元素，所需时间：%1d\n", MAX, t_end - t_start);
	system("pause");
	return 0;
}

运行结果：

快速排序

分治法加挖坑填数
找一个基准，小于放左边，大于放右边。一直遍历。填坑。
一般将第一数作为基准数。第一个数下标为i.挖坑。最后一个下标为j，从右边找一个数填坑。找到小于基准数的然后填坑。则此时j的位置就是坑了，此时从左往右找比基准数大的然后填坑。。。。此时i的地方为坑，继续一直循环下去，直到i==j时，把基准数填i位置的坑。然后此时i的位置是正确的，然后将i的左边和右边分别进行相同的操作。所以用到了递归i<j就是递归结束条件>

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<random>
#include<time.h>
#include<sys/timeb.h>
using namespace std;
#define MAX 50000

long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;  //毫秒
}

void printArr(int arr[], int length)
{
	for (int i = 0; i < length; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}


void quickSortme(int arr[], int start, int end)
{
	int mid = (start + end) / 2;
	int temp = arr[start];
	int i = start;
	int j = end;
	
	if (i >= j)
	{
		//从后往前比较，找一个比基准数小的数，放前面
		if (arr[j] < temp)
		{
			arr[i] = arr[j];
			arr[j] = temp;
			j--;
		}
		//从前往后比较，找一个比基准数大的数，放后面
		if (arr[i] > temp)
		{
			arr[i] = arr[j];
			arr[i] = temp;
			i++;
		}

	}
}
//快速排序，从小到大
void quickSort(int arr[], int start, int end)
{	
	int i = start;
	int j = end;
	int temp = arr[start];  //作为基准数
	if (i < j)
	{
		while (i<j)
		{
			//从右向左比较，找一个比基准数小的元素，放左边
			while (i < j && arr[j] >= temp)  //从右往左遍历，寻找满足小于基准数的元素
			{
				j--;
			}
			if (i<j) 
			{
				arr[i] = arr[j];  //填左边坑
				i++;
	
			}
			//从左往右比较，找一个比基准数大的数，放右边
			while (i < j && arr[i] <= temp)  //从左往右遍历，寻找满足大于基准数的元素
			{
				i++;
			}
			if (i<j)
			{
				arr[j] = arr[i];  //填右边坑
				j--;
			}
		}
		//把基准数放到i位置
		arr[i] = temp;
		//对左半部分进行快速排序
		quickSort(arr,start, i - 1);
		//对右半部分进行快速排序
		quickSort(arr, i+1, end);
		

	}
}


int main()
{
	int arr[MAX];
	srand((unsigned int)time(NULL));  //种子
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	//printf("未排序数组为：");
	//printArr(arr, MAX);
	long t_start = getSystemTime();
	quickSort(arr, 0,MAX-1);
	long t_end = getSystemTime();
	//printf("冒希尔排序后数组为：");
	//printArr(arr, MAX);
	printf("快速排序%d个元素，所需时间：%1d\n", MAX, t_end - t_start);
	system("pause");
	return 0;
}

结果：

归并排序

分组，然后排序，然后存到数组，然后覆盖原来

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<random>
#include<time.h>
#include<sys/timeb.h>
using namespace std;
#define MAX 50000

long getSystemTime()
{
	struct timeb tb;
	ftime(&tb);
	return tb.time * 1000 + tb.millitm;  //毫秒
}

void printArr(int arr[], int length)
{
	for (int i = 0; i < length; i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
}

int* CreateArr()
{
	srand((unsigned int)time(NULL));  //种子
	int* arr =(int *)malloc(sizeof(int)*MAX);
	for (int i = 0; i < MAX; i++)
	{
		arr[i] = rand() % MAX;
	}
	return arr;
}
//合并算法  从小到大 
void merge(int arr[], int start, int end, int mid, int *temp)
{
	
	int i_start = start;
	int i_end = mid;
	int j_start = mid + 1;
	int j_end = end;
	//表示辅助空间有多少个元素
	int length = 0;
	//合并两个有序序列
	while (i_start <= i_end && j_start <= j_end)
	{
		if (arr[i_start] < arr[j_start])
		{
			temp[length] = arr[i_start];
			length++;
			i_start++;
		}
		else
		{
			temp[length] = arr[j_start];
			length++;
			j_start++;
		}
	}
	//i这个序列
	while (i_start <= i_end)
	{
		temp[length] = arr[i_start];
		length++;
		i_start++;
	}
	//j这个序列
	while (j_start <= j_end)
	{
		temp[length] = arr[j_start];
		length++;
		j_start++;
	}

	//将辅助空间数据覆盖原空间
	for (int i = 0; i < length; i++)
	{
		arr[start+i]=temp[i];
	}
}

//归并排序，将两个有序序列合并成一个有序序列   不会写
void mergeSort(int arr[], int start,int end,int *temp)
{
	if (start >= end)
	{
		return;
	}
	int mid = (start + end) / 2;
	//左半边
	mergeSort(arr, start, mid, temp);
	//右半边
	mergeSort(arr, mid+1, end, temp);

	//合并
	merge(arr, start, end, mid, temp);

}


int main()
{
	int *arr = CreateArr();
	long t_start = getSystemTime();
	//申请辅助空间
	int* temp = (int *)malloc(sizeof(int)*MAX);
	mergeSort(arr, 0, MAX - 1,temp);
	long t_end = getSystemTime();
	printf("归并排序%d个元素，所需时间：%1d\n", MAX, t_end - t_start);
	/*free(temp);
	free(arr);*/
	system("pause");
	return 0;
}

运行结果：