基本排序算法实现

1、冒泡

• 比较相邻的元素。如果第一个比第二个大，就交换它们两个；
• 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；
• 针对所有的元素重复以上的步骤，除了最后一个；
• 重复步骤1~3，直到排序完成。

void bubble_sort(vector<int>&vec)
{
	for (int i = vec.size() - 1; i >= 0;i--)
	{
		for (int j = 0; j < i; j++)
		{
			if (vec[j]>vec[j+1])
			{
				swap(vec[j], vec[j + 1]);
			}
		}
	}
}

最佳情况：T(n) = O(n)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(n2)

2、选择

• 初始状态：无序区为R[1..n]，有序区为空；
• 第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R[1..i-1]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R[k]，将它与无序区的第1个记录R交换，使R[1..i]和R[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；
• n-1趟结束，数组有序化了。

void select_sort(vector<int>&vec)
{
	int minVal = 0;
	int temp;
	for (int i = 0; i < vec.size();i++)
	{
		minVal = i;
		for (int j = i + 1; j < vec.size();j++)
		{
			if (vec[minVal]>vec[j])
			{
				minVal = j;
			}

		}
		temp = vec[minVal];
		vec[minVal] = vec[i];
		vec[i] = temp;
		
	}
}

最佳情况：T(n) = O(n2)  最差情况：T(n) = O(n2)  平均情况：T(n) = O(n2)

3、插入排序

• 从第一个元素开始，该元素可以认为已经被排序；
• 取出下一个元素，在已经排序的元素序列中从后向前扫描；
• 如果该元素（已排序）大于新元素，将该元素移到下一位置；
• 重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；
• 将新元素插入到该位置后；
• 重复步骤2~5。

void insert_sort(vector<int>& vec)
{
	int temp;
	int s;
	for (int i = 1; i < vec.size();i++)
	{
		for (int j = i-1; j >=0 ;j--)
		{
			if (vec[j+1]<vec[j])
			{
				temp = vec[j];
				vec[j] = vec[j+1];
				vec[j+1] = temp;
			}
		}
		
	}
}

最佳情况：T(n) = O(n)   最坏情况：T(n) = O(n2)   平均情况：T(n) = O(n2)

4、希尔

• 选择一个增量序列t1，t2，…，tk，其中ti>tj，tk=1；
• 按增量序列个数k，对序列进行k 趟排序；
• 每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

void sell_sort(vector<int>&vec)
{
	int temp, gap = 1;
	int i, j;
	while(gap<vec.size()/3)
	{
		gap = gap * 3 + 1;
	}
	for (gap; gap > 0;gap=gap/3)
	{
		for (i = gap; i < vec.size();i++)
		{
			temp = vec[i];
			for (j = i - gap; j >= 0 && temp < vec[j]; j-=gap)
			{
				vec[j + gap] = vec[j];
			}
			vec[j + gap] = temp;
		}
	}
}

最佳情况：T(n) = O(nlog2 n)  最坏情况：T(n) = O(nlog2 n)  平均情况：T(n) =O(nlog n)

5、归并

• 把长度为n的输入序列分成两个长度为n/2的子序列；
• 对这两个子序列分别采用归并排序；
• 将两个排序好的子序列合并成一个最终的排序序列。

void merge(int a[], int start, int mid, int end)
{
	int* tmp = (int*)malloc((end - start + 1)*sizeof(int));
	int i = start;
	int j = mid + 1;
	int k = 0;
	while (i<=mid&&j<=end)
	{
		if (a[i]<=a[j])
		{
			tmp[k++] = a[i++];
		}
		else
		{
			tmp[k++] = a[j++];
		}
	}
	
	while (i<=mid)
	{
		tmp[k++] = a[i++];
	}
	while (j<=end)
	{
		tmp[k++]=a[j++];
	}
  for(int i=0;i<end - start + 1;i++)
        a[i+start]=temp[i];
	free(tmp);
}
void merge_sort_up2down(int a[], int start, int end)
{
	if (a==NULL||start>=end)
	{
		return;
	}
	int mid = (end + start) / 2;
	merge_sort_up2down(a, start, mid);
	merge_sort_up2down(a, mid + 1, end);

	merge(a, start, mid, end);
}

最佳情况：T(n) = O(n)  最差情况：T(n) = O(nlogn)  平均情况：T(n) = O(nlogn)

6、快速

• 从数列中挑出一个元素，称为 “基准”（pivot）；
• 重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
• 递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。

void quick_sort(int a[], int l, int r)
{
	if (l<r)
	{
		int i, j, x;
		i = l;
		j = r;
		x = a[i];
		while (i<j)
		{
			while (i<j&&a[j]>x)
			{
				j--;
			}
			if (i<j)
			{
				a[i++] = a[j];
			}
			while (i<j&&a[i]<x)
			{
				i++;
			}
			if (i<j)
			{
				a[j--] = a[i];
			}
		}
		a[i] = x;
		quick_sort(a, l, i - 1);
		quick_sort(a, i, r);
	}
}

最佳情况：T(n) = O(nlogn)   最差情况：T(n) = O(n2)   平均情况：T(n) = O(nlogn)　

7、堆排序

void quick_sort(int a[], int l, int r)
{
	if (l<r)
	{
		int i, j, x;
		i = l;
		j = r;
		x = a[i];
		while (i<j)
		{
			while (i<j&&a[j]>x)
			{
				j--;
			}
			if (i<j)
			{
				a[i++] = a[j];
			}
			while (i<j&&a[i]<x)
			{
				i++;
			}
			if (i<j)
			{
				a[j--] = a[i];
			}
		}
		a[i] = x;
		quick_sort(a, l, i - 1);
		quick_sort(a, i, r);
	}
}
void maxheap_down(int a[], int start, int end)
{
	int c = start;
	int l = 2 * c + 1;
	int tmp = a[c];
	for (;  l < end; l=l*2+1)
	{
		if (l<end&&a[l]<a[l+1])
		{
			l++;
		}
		if (tmp>=a[l])
		{
			break;
		}
		else
		{
			a[c] = a[l];
			a[l] = tmp;
		}
	}
}

堆排序的时间复杂度是O(N*lgN)。

8、计数排序

void count_sort(int a[], int n)
{
	int maxnum=0;
	for (int i = 0; i < n;i++)
	{
		if (maxnum<a[i])
		{
			maxnum = a[i];
		}
	}
	cout << maxnum << endl;
	int *b = (int*)malloc(sizeof(int)*maxnum);

	memset(b, 0, sizeof(int)*(maxnum+1));
	for (int i = 0; i < n;i++)
	{
		b[a[i]]++;
		//cout << b[a[i]] << endl;
	}
	
	for (int i = 0; i < maxnum;i++)
	{
		while (b[i]>0)
		{
			cout << i << endl;
			b[i]--;
		}
	}
}