排序代码实现

void swap(int* a, int* b)
{
	int s = *a;
	*a = *b;
	*b = s;
}

//升序
void Heap_Sort(int* arr, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		int parent = i;
		int child = parent * 2 + 1;
		//构建大堆
		while (child < n)
		{
			if (arr[child + 1] > arr[child])
			{
				child++;
			}

			if (child + 1 < n && arr[child] > arr[parent])
			{
				swap(&arr[child], &arr[parent]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
				break;
		}
	}

	int end = n;
	while (end > 0)
	{
		swap(&arr[0], &arr[end - 1]);
		end--;
		int parent = 0;
		int child = parent * 2 + 1;
		while (child < end)
		{
			if (child + 1 < end && arr[child + 1] > arr[child])
			{
				child++;
			}

			if (arr[child] > arr[parent])
			{
				swap(&arr[child], &arr[parent]);
				parent = child;
				child = parent * 2 + 1;
			}
			else
				break;
		}
	}
}

void Insert_Sort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tmp = arr[end + 1];
		while (end >= 0)
		{
			if (arr[end] > tmp)
			{
				swap(&arr[end], &arr[end + 1]);
				end--;
			}
			else
				break;
		}
	}
}

void Shell_Sort(int* arr, int n)
{
	int gap = n;
	int gap1 = n;
	while (gap > 0)
	{
		gap /= 3 + 1;
		printf("gap /= 3 + 1 : %d \n", gap);
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int tmp = arr[end + gap];
			while (end >= 0)
			{
				if (arr[end] > tmp)
				{
					swap(&arr[end], &arr[end + gap]);
					end -= gap;
				}
				else
					break;
			}
		}
	}
}

void Select_Sort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int pi = i;
		for (int j = i + 1; j < n; j++)
		{
			if (arr[j] < arr[pi])
			{
				pi = j;
			}
		}
		swap(&arr[i], &arr[pi]);
	}
}

void Bubble_Sort(int* arr, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		for (int j = 0; j < n - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				swap(&arr[j], &arr[j + 1]);
			}
		}
	}
}

void Quick_Sort1(int* arr, int l, int r)
{
	if (l >= r)return;

	int begin = l, end = r;
	int tmp = arr[l];
	while (begin < end)
	{
		while (begin < end && arr[end] >= tmp)
		{
			end--;
		}
		while (begin < end && arr[begin] <= tmp)
		{
			begin++;
		}
		swap(&arr[end], &arr[begin]);
	}
	swap(&arr[l], &arr[begin]);
	Quick_Sort1(arr, l, begin - 1);
	Quick_Sort1(arr, begin + 1, r);
}

void Quick_Sort2(int* arr, int l, int r)
{
	if (l >= r)return;

	int begin = l, end = r, tmp = arr[l], pi = l;
	while (begin < end)
	{
		while (begin < end && arr[end] >= tmp)
		{
			end--;
		}
		while (begin < end && arr[begin] <= tmp)
		{
			begin++;
		}
		if (pi <= begin)
		{
			arr[pi] = arr[end];
			pi = end;
		}
		else
		{
			arr[pi] = arr[begin];
			pi = begin;
		}
	}
	arr[pi] = tmp;
	Quick_Sort2(arr, l, begin - 1);
	Quick_Sort2(arr, begin + 1, r);
}

void Quick_Sort3(int* arr, int l, int r)
{
	if (l >= r)return;
	int tmp = arr[l];
	int prev = l;
	int cur = l + 1;
	while (cur <= r)
	{
		if (arr[cur] <= tmp)
		{
			prev++;
			swap(&arr[prev], &arr[cur]);
			cur++;
		}
		else
		{
			cur++;
		}
	}
	swap(&arr[prev], &arr[l]);
	Quick_Sort3(arr, l, prev - 1);
	Quick_Sort3(arr, prev + 1, r);
}

void Quick_Sort4(int* arr, int l, int r)
{
	STNode stl;
	STNode str;
	STInit(&stl);
	STInit(&str);

	STPush(&stl, l);
	STPush(&str, r);

	while (!STEmpty(&stl) && !STEmpty(&str))
	{
		int l1 = STTop(&stl);
		int r1 = STTop(&str);
		int begin = l1;
		int end = r1;
		STPop(&stl);
		STPop(&str);
		int tmp = arr[l1];
		while (begin < end)
		{
			while (begin < end && arr[end] >= tmp)
			{
				end--;
			}
			while (begin < end && arr[begin] <= tmp)
			{
				begin++;
			}
			swap(&arr[begin], &arr[end]);
		}
		swap(&arr[l1], &arr[begin]);
		if (l1 < r1)
		{
			STPush(&stl, begin + 1);
			STPush(&stl, l1);
			STPush(&str, r1);
			STPush(&str, begin - 1);
		}
	}
}

void merge_Sort(int* arr, int* brr, int l, int r)
{
	if (l >= r)return;
	int mid = (l + r) / 2;
	merge_Sort(arr, brr, l, mid);
	merge_Sort(arr, brr, mid + 1, r);
	int i = l, j = mid + 1 , k = 0;
	while (i <= mid && j <= r)
	{
		if (arr[i] <= arr[j])
		{
			brr[k++] = arr[i++];
		}
		else
			brr[k++] = arr[j++];
	}
	while (i <= mid) brr[k++] = arr[i++];
	while (j <= r)brr[k++] = arr[j++];
	for (i = l, j = 0; i <= r; i++, j++)
	{
		arr[i] = brr[j];
	}

}

void merge_Sort1(int* arr, int l, int r)
{
	int* brr = (int*)malloc(sizeof(int)*(r-l+1));
	if (brr == NULL)
	{
		perror("merge_Sort1::malloc(brr)");
		exit(1);
	}
	merge_Sort(arr, brr, l, r);
	free(brr);
}

void merge_Sort2(int* arr, int l, int r)
{
	int* brr = (int*)malloc(sizeof(int) * (r - l + 1));
	int gap = 1;
	int n = r - l + 1;
	int begin1 = 0, begin2 = 0, end1 = 0, end2 = 0;
	while (gap < n)
	{
		for (int b = 0; b < n; b += 2 * gap)
		{
			begin1 = b;
			end1 = begin1 + gap - 1;
			if (end1 >= n)
			{
				end1 = begin2 = end2 = n - 1;
			}
			else
			{
				begin2 = end1 + 1;
				if (begin2 >= n)
				{
					begin2 = end2 = n - 1;
				}
				else
				{
					end2 = begin2 + gap - 1;
					if (end2 >= n)
					{
						end2 = n - 1;
					}
				}
			}

			int l1 = begin1;
			int l2 = begin2;
			int r2 = end2;
			int r1 = end1;
			int k = 0;
			while (l1 <= r1 && l2 <= r2)
			{
				if (arr[l1] <= arr[l2])
				{
					brr[k++] = arr[l1++];
				}
				else
				{
					brr[k++] = arr[l2++];
				}
			}
			
			while (l1 <= r1) brr[k++] = arr[l1++];
			while (l2 <= r2) brr[k++] = arr[l2++];
			for (l1 = begin1, k = 0; l1 <= end2; l1++,k++) arr[l1] = brr[k];
		}
		gap = 2 * gap;
	}
}