快速排序与归并排序递归与非递归c语言实现详解

快速排序

         快排基本逻辑：

void Quict_sort(int* dat, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int index=Getmid(dat, left, right);
	Swap(dat[left], dat[index]);
	int begin = left;
	int end = right;
	int pivot = begin;
	int core = dat[pivot];
	while (begin < end)
	{
		while (begin<end && dat[end]>core)//小值
		{
			end--;
		}
		dat[pivot] = dat[end];
		pivot = end;
		while (begin < end && dat[begin] < core)//大值
		{
			begin++;
		}
		dat[pivot] = dat[begin];
		pivot = begin;
	}
	pivot = begin;
	dat[pivot] = core;
	Quict_sort(dat, left, pivot - 1);//递归左半部分
	Quict_sort(dat, pivot + 1, right);//递归右半部分1
}

 三位取中增加效率

int Gitmid(int* dat, int left, int right)
{
	assert(dat);
	int mid = (left + right) >> 1;
	if (dat[left] < dat[mid])
	{
		if (dat[mid] < dat[right])
		{
			return mid;
		}
		else if (dat[left] > dat[right])
		{
			return left;
		}
		else
			return right;
	}
	else
	{
		if (dat[mid] > dat[right])
		{
			return mid;
		}
		else if (dat[left] < dat[right])
		{
			return left;
		}
		else
			return right;
	}
}

 下述类似于挖坑法，通过前后比较得出key应该放的位置

//左右指针法
void Quict_sort(int* a, int left, int right)
{
	if (left >= right)
	{
		return;
	}
	int index=Gitmid(a, left, right);
	Swap(a[left], a[index]);
	int key = left;
	int pre = left;  int cur = left + 1;
	while (cur <= right)
	{
		if (a[cur] < a[key] && ++pre!=cur)
		{
			Swap(a[pre], a[cur]);
		}
		++cur;
	}
	Swap(a[key], a[pre]);
	int pivot = pre;
	Quict_sort(a, left, pivot - 1);//递归左半部分
	Quict_sort(a, pivot + 1, right);//递归右半部分
}

快排的非递归 

归并排序 

void MergSort_(int* dat, int left, int right, int* tmp)
{
	if (left >= right)
	{
		return;
	}
	int mid = (left + right) >> 1;
	//假设有序，进行分治递归
	MergSort_(dat, left, mid , tmp);
	MergSort_(dat, mid + 1, right, tmp);
	//定义变量
	int begin1 = left; int end1 = mid;
	int begin2 = mid + 1; int end2 = right;
	int index = left;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (dat[begin1] < dat[begin2])
		{
			tmp[index++] = dat[begin1++];
		}
		else
		{
			tmp[index++] = dat[begin2++];
		}
	}
	while (begin1 <= end1)//考虑到比较完可能有剩余值直接放入数组即可
	{
		tmp[index++] = dat[begin1++];
	}
	while (begin2 <= end2)
	{
		tmp[index++] = dat[begin2++];
	}
	for (int i = left; i <= right; i++)
	{
		dat[i] = tmp[i];
	}
}

void MergeSort(int* dat, int num)
{
	int* tmp = (int*)malloc(num * sizeof(int));
	MergSort(dat, 0, num - 1, tmp);
	free(tmp);
}

上述则为归并排序 

 归并非递归

void MergeSort(int* dat, int num)
{
	int* tmp = (int*)malloc(num * sizeof(int));
	int gap = 1;
	while (gap < num)
	{
		for (int i = 0; i < num; i += 2 * gap)
		{
			int begin1 = i; int end1 = i + gap - 1;
			int begin2 = i + gap; int end2 = i + 2 * gap - 1;
			int index = i;
			if (begin2 >= num)//防止越界
				break;
			if (end2 >= num)//防止剩一个数时越界
				end2 = num - 1;
			while (begin1 <= end1 && begin2 <= end2)
			{
				if (dat[begin1] < dat[begin2])
				{
					tmp[index++] = dat[begin1++];
				}
				else
				{
					tmp[index++] = dat[begin2++];
				}
			}
			while (begin1 <= end1)
			{
				tmp[index++] = dat[begin1++];
			}
			while (begin2 <= end2)
			{
				tmp[index++] = dat[begin2++];
			}
			for (int i = 0; i <= end2; i++)
			{
				dat[i] = tmp[i];
			}
		}
		gap *= 2;//每次间隙翻两倍
	}
	free(tmp);
}

 以上就是较重要的两大排序，请多多支持，点赞+转发，感激不尽