给出几种排序总结

1.冒泡及其稍微优化

#include<assert.h>
void Bubbsort(int a[],int len)
{
	assert(a);
	for (int i = 0; i < len - 1; i++)
	{
		int tmp = 0;//标志状态
		for (int j = 0; j < len - i - 1; j++)
		{
			if (a[j]>a[j + 1])
			{
				swap(a[j],a[j+1]);
				tmp = 1;
			}
		}
		if (tmp == 0)//等于0的话说明上面那个if语句没进去说明已经有序
			break;
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8,10 };
	int len = sizeof(arr) / sizeof(arr[0]);
	Bubbsort(arr,len);
	system("pause");
	return 0;
}

2.选择排序

(1)   普通代码

#include<assert.h>
void SelectSort(int *arr,int len)
{
	assert(arr);
	for (int i = 0; i < len; i++)
	{
		int k = i;
		for (int j = i + 1; j < len; j++)
		{
			if (arr[j]<arr[k])
			{
				k = j;
			}
		}
		swap(arr[k],arr[i]);
	}
}
int main()
{
	int arr[] = {1,3,5,7,9,2,4,6,8,10};
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr,len);
	return 0;
}

（2）优化代码

#include<assert.h>
void SelectSort(int *arr,int len)
{
	assert(arr);
	for (int i = 0; i < len; i++)
	{
		int m = len - 1 - i;//放在最后那个元素的下标
		int min = i;
		int max = m;
		for (int j = i + 1; j < len-i; j++)//len-i是避免找过的元素重复被找
		{
			if (arr[j]<arr[min])
			{
				min = j;
			}
		}
		for (int j = i; j < len-1-i; j++)//len-1-i是最后元素的下标不停往前移动
		{
			if (arr[j]>arr[max])
			{
				max = j;
			}
		}
		swap(arr[min],arr[i]);
		if (max == i)
			swap(arr[min], arr[m]);
		else
			swap(arr[max],arr[m]);
	}
}
int main()
{
	int arr[] = {10,3,5,7,9,2,4,6,8,1};
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr,len);
	return 0;
}

（3）插入排序

#include<assert.h>
void SelectSort(int arr[],int len)
{
	assert(arr);
	for (int i = 1; i < len; i++)
	{
		int end = i - 1;
		int tmp = arr[i];
		if (end >= 0)
		{
			while (arr[end]>tmp)//注意这是tmp比较
			{
				arr[end+1] = arr[end];
				end--;
			}
		}
		arr[end + 1] = tmp;
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr,10);
}

（4）堆排序

void AdjustDown(int *a,int n,int parent)//向下调整
{
	assert(a);
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1<n&&a[child + 1]>a[child])
		{
			++child;
		}
		if (a[child]>a[parent])
		{
			swap(a[child], a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
			break;
	}
}
void SortHeap(int *a,int len)
{
	int i = (len - 2) / 2;//建大堆
	for (; i >= 0; i--)
	{
		AdjustDown(a, len, i);
	}
	int end = len - 1;
	while (end >= 0)
	{
		swap(a[0],a[end]);
		AdjustDown(a, end, 0);
		end--;
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 10 };
	SortHeap(arr, 10);
}

（5）快速排序（挖坑法）

void QuickSort(int *a, int l,int r)
{
	assert(a);
	
	if (l < r)
	{
		int k = a[l];
		int i = l;
		int j = r;
		while(i<j)
		{
			while (i<j&&a[j] > k)
			{
				j--;
			}
			if (i < j)
			{
				a[i] = a[j];
				i++;
			}
			while (i<j&&a[i] <= k)
			{
				i++;
			}
			if (i < j)
			{
				a[j] = a[i];
				j--;
			}
			
		}
		a[i] = k;
		QuickSort(a, l, i - 1);
		QuickSort(a, i + 1, r);
		
	}
}
int main()
{
	int a[10] = {1,3,5,7,9,2,4,6,8,10};
	QuickSort(a,0,9);
}

在排序时间复杂度上冒泡，选择，插入都是O（N^2），冒泡与堆排序是O(N*lg(N))