常用排序算法

• 冒泡排序 

  原理：一种交换排序，它的基本思想是：两两比较相邻记录的关键字，如果反序则交换，直到没有反序的记录位置。

• 代码

  #include<iostream>
  #include<vector>
  #include<algorithm>
  using namespace std;
  
  int main()
  {
  	char c;
  	int num;
  	vector<int>array;
  	do
  	{
  		cin >> num;
  		array.push_back(num);
  		c = getchar();
  	} while (c != '\n');
  
  	int len = array.size();
  
  	for (int i = 0; i < len; i++)
  	{
  		bool flag = false;
  		for (int j = len - 1; j > i; j--)
  		{
  			if (array[j] < array[j - 1])
  			{
  				swap(array[j], array[j - 1]);
  				flag = true;
  			}
  		}
  		if (flag == false)
  			break;
  	}
  	for (int i = 0; i < len; i++)
  	{
  		cout << array[i] << " ";
  	}
  	cout << endl;
  	system("pause");
  	return 0;
  }

• 快速排序

• 原理：通过一趟排序将待排记录分割为独立的两个部分，其中一部分记录的关键字均比另一部分的关键字小，则可继续对这两部分继续进行排序，以达到整个序列有序的目的。
• 代码

  #include<iostream>
  #include<vector>
  #include<algorithm>
  using namespace std;
  
  int Partition(vector<int>& array, int start, int end)
  {
  	int temp = array[start];
  	int index = start;
  	for (int i = start + 1; i <= end; i++)
  	{
  		if (array[i] < temp)
  		{
  			index++;
  			if (index != i)
  			{
  				swap(array[index], array[i]);
  			}
  		}
  	}
  	swap(array[index], array[start]);
  	return index;
  }
  void qsort(vector<int>& array, int start, int end)
  {
  	if (start < end)
  	{
  		int index = Partition(array, start, end);
  		if (index > start)
  		{
  			qsort(array, start, index - 1);
  		}
  		if (index < end)
  		{
  			qsort(array, index + 1, end);
  		}
  	}
  }
  int main()
  {
  	vector<int>array;
  	int temp;
  	char c;
  	do
  	{
  		cin >> temp;
  		array.push_back(temp);
  		c = getchar();
  	} while (c != '\n');
  	int len = array.size();
  	qsort(array, 0, len - 1);
  	for (int i = 0; i< len; i++)
  	{
  		cout << array[i] << " ";
  	}
  	cout << endl;
  	system("pause");
  	return 0;
  }

• 堆排序

• 原理：将待排序的序列构造成一个大顶堆或小顶堆。此时整个序列的最大值或最小值就是对顶的节点。将它移走，然后将剩余的n-1个序列重新构成一个堆，这样就会得到n个元素中的次大值。如此反复执行，就能得到一个有序序列。
• 代码

  #include<iostream>
  #include<vector>
  #include<algorithm>
  using namespace std;
  void HeapAdjust(vector<int>& array, int s, int len)
  {
  	int temp = array[s];
  	for (int i = s * 2; i <= len; i = i * 2)
  	{
  		if (i < len && array[i] < array[i + 1])
  			i++;
  		if (temp >= array[i])
  			break;
  		array[s] = array[i];
  		s = i;
  	}
  	array[s] = temp;
  }
  
  int main()
  {
  	int len;
  	while (cin >> len)
  	{
  		vector<int>array(len+1);
  		for (int i = 1; i <= len; i++)
  		{
  			cin >> array[i];
  		}
  		for (int i = len / 2; i >= 1; i--)
  		{
  			HeapAdjust(array, i, len);//从下往上调节
  		}
  		for (int i = len; i>1;i--)
  		{
  			swap(array[i], array[1]);
  			HeapAdjust(array, 1, i-1);
  		}
  		for (int i = 1; i <= len; i++)
  		{
  			cout << array[i] << " ";
  		}
  		cout << endl;
  	}
  	system("pause");
  	return 0;
  }

• 归并排序

• 原理：利用归并的思想实现排序的方法。假设初始序列含有n个元素，则可以看成n个有序的子序列，每个子序列的长度为1，然后两两合并，得到（n/2）个长度为2或1的有序子序列；然后在两两归并，如此重复，直到得到一个长度为n的有序序列为止。
• 代码

  #include<iostream>
  #include<vector>
  #include<algorithm>
  using namespace std;
  void Merge(vector<int>& array, int i, int m, int n)
  {
  	int j, k, l;
  	vector<int>temp = array;
  	for (j = m + 1, k = i; i <= m && j <= n; k++)
  	{
  		if (temp[i] < temp[j])
  			array[k] = temp[i++];
  		else
  			array[k] = temp[j++];
  	}
  	if (i <= m)
  	{
  		for (; i <= m; i++)
  			array[k++] = temp[i];
  	}
  	if (j <= n)
  	{
  		for (; j <= n; j++)
  			array[k++] = temp[j];
  	}
  }
  void Msort(vector<int>& array, int start, int end)
  {
  	if (start < end)
  	{
  		int m = (start + end) / 2;
  		Msort(array, start, m);
  		Msort(array, m + 1, end);
  		Merge(array, start, m, end);
  	}
  }
  int main()
  {
  	int N;
  	cin >> N;
  	vector<int>array(N);
  	for (int i = 0; i < N; i++)
  	{
  		cin >> array[i];
  	}
  
  	Msort(array, 0, N - 1);
  
  	for (int i = 0; i < N; i++)
  	{
  		cout << array[i] << " ";
  	}
  	cout << endl;
  	system("pause");
  	return 0;
  }
  

• 荷兰旗问题

• 代码

  #include<iostream>
  #include<algorithm>
  #include<vector>
  using namespace std;
  int main()
  {
  	int len;
  	cin >> len;
  	vector<int>array(len);
  	for (int i = 0; i < len; i++)
  	{
  		cin >> array[i];
  	}
  	int begin = 0, current = 0, end = len - 1;
  	while (current <= end)
  	{
  		if (array[current] == 1)
  			current++;
  		else if (array[current] == 0)
  		{
  			swap(array[begin], array[current]);
  			current++;
  			begin++;
  		}
  		else
  		{
  			swap(array[end], array[current]);
  			end--;
  		}
  	}
  	for (int i = 0; i < len; i++)
  	{
  		cout << array[i] << " ";
  	}
  	cout << endl;
  	system("pause");
  	return 0;
  }

• 总结

• 各种排序算法的性质

  算法种类	最好情况	平均情况	最坏情况	是否稳定
  冒泡排序				是
  快速排序				否
  堆排序				否
  归并排序				是