排序排序啦

void printarray(int* a, int n)
{
	for (int i = 0; i < n; i++)
	{
		printf("%d ", a[i]);
	}
	printf("\n");
}
void swap(int* p1, int* p2)
{
	int tem = *p1;
	*p1 = *p2;
	*p2=tem;
}

//插入排序
void insertsort(int* a, int n)
{
	for (int i = 0; i < n - 1; i++)
	{
		int end = i;
		int tem = a[i + 1];
		while(end>=0)
		{
			if (tem < a[end])
			{
				a[end + 1] = a[end];
				end--;
			}
			else
			{
				break;
			}
		}
		a[end + 1] = tem;
	}
}

//希尔排序
void shelltsort(int* a, int n)
{
	int gap = n;
	while(gap>1)
	{
		gap = gap/ 3 + 1;
		for (int j = 0; j < gap; j++)
		{
			for (int i = j; i < n -gap; i+= gap)
			{
				int end = i;
				int tem = a[i + gap];
				while (end >= 0)
				{
					if (tem < a[end])
					{
						a[end + gap] = a[end];
						end -= gap;
					}
					else
					{
						break;
					}
				}
				a[end + gap] = tem;
			}
		}
	}
}
int getminindex(int* a, int left, int right)
{
	int min = (left + right) / 2;
	if (a[left] < a[min])
	{
		if (a[min] < a[left])
		{
			return min;
		}
		else if (a[left] < a[right])
		{
			return right;
		}
		else
		{
			return left;
		}
	}
	else    //a[left] > a[min]
	{
		if (a[min] > a[right])
		{
			return min;
		}
		else if (a[left] < a[right])
		{
			return left;
		}
		else
		{
			return right;
		}
	}
}
//hoare版本
int partsort1(int* a, int left, int right)
{
	int min = getminindex(a, left, right);
	swap(&a[min], &a[left]);

	int keyi = left;
	while(left<right)
	{
		while(left < right && a[right] >= a[keyi])
		{
			right--;
		}

		while (left < right && a[left] <= a[keyi])
		{
			left++;
		}

		swap(&a[left], &a[right]);
	}
	swap(&a[left], &a[keyi]);
	return left;
}
//挖坑法
int partsort2(int* a, int left, int right)
{
	int min = getminindex(a, left, right);
	swap(&a[min], &a[left]);

	int hole = left;
	int key = a[left];
	while(left<right)
	{
		while(left < right&&a[left] < key)
		{
			left++;
		}

		a[hole] = a[left];
		hole = left;

		while(left < right & a[right] > key)
		{
			right--;
		}

		a[hole] = a[right];
		hole = right;
	}
	a[hole] = key;
	return hole;
}
//前后指针法
int partsort3(int* a, int left, int right)
{
	int min = getminindex(a, left, right);
	swap(&a[min], &a[left]);

	int prev = left;
	int cur = left+1;
	int keyi= left;

	while(cur<=right)
	{
		if (a[cur] <a[keyi])
		{
			prev++;
			swap(&a[cur], &a[prev]);
		}

			cur++;
	}
	swap(&a[keyi], &a[prev]);
	keyi = prev;
	return keyi;
}

void quicksort1(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	int keyi = partsort1(a, begin, end);

	quicksort1(a, begin, keyi - 1);
	quicksort1(a, keyi + 1, end);
}
void quicksort2(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	int keyi = partsort2(a, begin, end);

	quicksort2(a, begin, keyi - 1);
	quicksort2(a, keyi + 1, end );

}
void quicksort3(int* a,int begin,int end)
{
	if (begin >= end)
	{
		return;
	}
	int keyi=partsort3(a, begin,  end);

	quicksort3(a, begin, keyi-1);
	quicksort3(a, keyi+1, end );

}
//三路法
void quicksort4(int* a, int begin, int end)
{
	if (begin >= end)
	{
		return;
	}
	int left = begin;
	int right = end;
	int cur = left + 1;

	int min = getminindex(a, left, right);
	swap(&a[min], &a[left]);

	int key = a[left];
	while (cur <= right)
	{
		if (a[cur] < key)
		{
			swap(&a[cur], &a[left]);
			cur++;
			left++;
		}
		else if (a[cur] > key)
		{
			swap(&a[cur], &a[right]);
			right--;
		}
		else
		{
			cur++;
		}
	}

	quicksort4(a, begin, left-1);
	quicksort4(a, right+1, end);

}

void quicksortnonr(int* a, int begin, int end)
{
	Stack p;
	Stackinit(&p);
	Stackpush(&p, end);
	Stackpush(&p, begin);

	while (!isempty(&p))
	{
		int left= Stacktop(&p);
		Stackpop(&p);

		int right= Stacktop(&p);
		Stackpop(&p);

		int keyi = partsort1(a, left, right);
		//[left,keyi-1][keyi+1,right]
		if(keyi+1<right)
		{
			Stackpush(&p, right);
			Stackpush(&p, keyi+1);
		}

		if(left<keyi-1)
		{
			Stackpush(&p, keyi - 1);
			Stackpush(&p, left);
		}
	}

	Stackdestroy(&p);
}
//选择排序
void selectsort(int* a, int n)
{
	int begin = 0;
	int end = n -1;
	while (begin < end)
	{
		int mini = begin;
		int maxi = begin;
		for (int i = begin; i <=end; i++)
		{
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
			if (a[i] < a[mini])
			{
				mini = i;
			}
		}
		swap(&a[mini], &a[begin]);
		// 如果maxi和begin重叠，修正一下即可
		if (maxi == begin)
		{
			maxi = mini;
		}
		swap(&a[maxi], &a[end]);
		begin++;
		end--;
	}
}
//归并排序
void _mergesort(int* a, int begin, int end, int*tem )
{
	if (begin==end)
	{
		return;
	}
	//小区间优化
	if (end - begin+1 < 10)
	{
		insertsort(a, end - begin + 1);
		return;
	}
	int min = (begin + end) / 2;

	_mergesort(a, begin, min, tem);
	_mergesort(a, min+1,end, tem);

	int begin1 = begin; int end1 = min;
	int begin2 = min + 1; int end2 = end;

	int i = begin;
	while (begin1 <= end1 && begin2 <= end2)
	{
		if (a[begin1] <= a[begin2])
		{
			tem[i++] = a[begin1++];
		}
		else
		{
			tem[i++] = a[begin2++];
		}
	}

	while (begin1 <= end1)
	{
		tem[i++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tem[i++] = a[begin2++];
	}
	memcpy(a + begin, tem + begin, sizeof(int)*(end - begin + 1));
}
void mergesort(int* a, int n)
{
	int* tem = (int*)malloc(sizeof(int) * n);

	_mergesort(a, 0, n - 1, tem);

	free(tem);
}
//归并排序非递归--有缺陷
//void mergesortnonr(int* a, int n)
//{
//	int* tem = (int*)malloc(sizeof(int) * n);
//
//	int gap = 1;
//	while (gap < n)
//	{
//		int k = 0;
//		for (int i = 0; i < n; i += 2 * gap)
//		{
//			int begin1 = i; int end1 =i+gap-1;
//			int begin2 = i+gap; int end2 = i+2*gap-1;
//
//			while (begin1 <= end1 && begin2 <= end2)
//			{
//				if (a[begin1] <= a[begin2])
//				{
//					tem[k++] = a[begin1++];
//				}
//				else
//				{
//					tem[k++] = a[begin2++];
//				}
//			}
//
//			while (begin1 <= end1)
//			{
//				tem[k++] = a[begin1++];
//			}
//
//			while (begin2 <= end2)
//			{
//				tem[k++] = a[begin2++];
//			}
//		}
//		memcpy(a, tem, sizeof(int) * n);
//		gap *= 2;
//	}
//   free(tem);
//}

解决方法1
//void mergesortnonr(int* a, int n)
//{
//	int* tem = (int*)malloc(sizeof(int) * n);
//
//	int gap = 1;
//	while (gap < n)
//	{
//		int k = 0;
//		for (int i = 0; i < n; i += 2 * gap)
//		{
//			int begin1 = i; int end1 = i + gap - 1;
//			int begin2 = i + gap; int end2 = i + 2 * gap - 1;
//
//			
//			if (begin2 >= n && end1 < n)
//			{
//				begin2 = n;
//				end2 = n - 1;
//			}
//			if (end1 >= n && begin1 < n)
//			{
//				end1 = n - 1;
//				begin2 = n;
//				end2 = n - 1;
//			}
//			if (begin2 < n&&end2>=n)
//			{
//				end2 = n - 1;
//			}
//
//			/*if (end1 >= n)
//			{
//				end1 = n - 1;
//				begin2 = n;
//				end2 = n - 1;
//			}
//			else if (begin2 >= n)
//			{
//				begin2 = n;
//				end2 = n - 1;
//			}
//			else if(end2 >= n)
//			{
//				end2 = n - 1;
//			}*/
//
//			while (begin1 <= end1 && begin2 <= end2)
//			{
//				if (a[begin1] <= a[begin2])
//				{
//					tem[k++] = a[begin1++];
//				}
//				else
//				{
//					tem[k++] = a[begin2++];
//				}
//			}
//
//			while (begin1 <= end1)
//			{
//				tem[k++] = a[begin1++];
//			}
//
//			while (begin2 <= end2)
//			{
//				tem[k++] = a[begin2++];
//			}
//		}
//		memcpy(a, tem, sizeof(int) * n);
//		gap *= 2;
//	}
//	free(tem);
//}

//解决方法2
void mergesortnonr(int* a, int n)
{
	int* tem = (int*)malloc(sizeof(int) * n);

	int gap = 1;
	while (gap < n)
	{
		int k = 0;
		for (int i = 0; i < n; i += 2 * gap)
		{
			int begin1 = i; int end1 = i + gap - 1;
			int begin2 = i + gap; int end2 = i + 2 * gap - 1;

			if (end1 >= n || begin2 >= n)
			{
				break;
			}
			if (begin2 < n && end2 >= n)
			{
				end2 = n - 1;
			}

			while (begin1 <= end1 && begin2 <= end2)
			{
				if (a[begin1] <= a[begin2])
				{
					tem[k++] = a[begin1++];
				}
				else
				{
					tem[k++] = a[begin2++];
				}
			}

			while (begin1 <= end1)
			{
				tem[k++] = a[begin1++];
			}

			while (begin2 <= end2)
			{
				tem[k++] = a[begin2++];
			}
			memcpy(a + i, tem + i, sizeof(int) * (end2 - i + 1));
		}
		
		gap *= 2;
	}
	free(tem);
}
//计数排序
void countsort(int* a, int n)
{
	int maxi = 0;
	int mini = 0;

	for (int i = 0; i < n; i++)
	{
		if (a[i] > a[maxi])
		{
			maxi = i;
		}
		if (a[i] < a[mini])
		{
			mini = i;
		}
	}
	int tmpsize = (a[maxi] - a[mini])+1;
	int* tmp = (int*)malloc(sizeof(int) * tmpsize);
	memset(tmp, 0, sizeof(int) * tmpsize);

	int k = 0;
	while (k < n)
	{
		tmp[a[k++] - a[mini]]++;
	}

	/*for (int i = 0; i < n; i++)
	{
		tmp[a[i] - a[mini]]++;
	}*/
	int j = 0;
	for (int i = 0; i < tmpsize; i++)
	{
		while (tmp[i]--)
		{
			a[j++] = i+a[mini];
		}
	}

}
void adjuctdown(int* h, int n, int parent)
{
	assert(h);
	int child = parent * 2 + 1;
	while (child < n)
	{
		if ((child + 1) < n && h[child] <h[child + 1])
		{
			child++;
		}
		if (h[parent] < h[child])
		{
			swap(&h[parent], &h[child]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}
//堆排序
void heapsort(int* a, int n)
{
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		adjuctdown(a, n,i);
	}
	int end = n - 1;
	while(end)
	{
		swap(&a[end], &a[0]);
		adjuctdown(a, end--, 0);
	}
}

//冒泡排序
void bubblesort(int* a, int n)
{
	for (int j = 0; j < n; j++)
	{
		for (int i = 0; i < n - 1 - j; i++)
		{
			if (a[i] > a[i+1])
			{
				swap(&a[i], &a[i+1]);
			}
		}
	}
}