c++交换类排序算法（冒泡排序、快速排序）

冒泡排序

 冒泡排序（Bubble sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。

算法步骤：

1）比较相邻的元素。如果第一个比第二个大，就交换他们两个。

2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。这步做完后，最后的元素会是最大的数。

3）针对所有的元素重复以上的步骤，除了最后一个。

4）持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

复杂度分析：

冒泡排序对 n 个元素需要 O(n^2) 的比较次数，且可以原地排序，无需辅助空间。

冒泡排序仅适用于对于含有较少元素的数列进行排序。

最差时间复杂度 O(n^2)
平均时间复杂度 O(n^2)
最优时间复杂度 O(n)
最差空间复杂度 O(n)，辅助空间 O(1)

特点分析：稳定算法（stable）、in place算法

void Bibble_sort(vector<int>& a, int n){
	for (int i=0;i<n;i++){
		
		for(int j = i+1 ;j<n;j++){
		   if(a[i]>a[j]){
		      int temp = a[i];
			   a[i]= a[j];
			   a[j]= temp;
			  
		   }
		}
   }
}
int main()
{
	vector<int> data{12, 15, 9, 6,20, 6, 31, 24};
	int n = data.size();
	//SI_sort(data,n);
	//shell_sort(data,n);
	Bibble_sort(data,n);
    for (int i = 0; i < n; i++)
    {
        cout << data[i]<<" ";
    }
   return 0;
}

快速排序

原理： 每次选一个轴pivot（我选数组的第一个元素arr[p]），遍历其余数组元素使得比arr[p]大的数都在arr[p]的右边，比arr[p]小的数都在arr[p]的左边，然后递归处理arr[p]的左边和arr[p]的右边。

注意：

• 快排不稳定
• 时间复杂度nlogn，空间复杂度logn

int  quick_sort(vector<int>& a, int low,int high);
void quickSort(vector<int>& a, int low, int high) {
		if (low < high) {
			int q = quick_sort(a, low, high);
			quickSort(a, low, q - 1);
			quickSort(a, q + 1, high);

		}
	}

int  quick_sort(vector<int>& a, int low,int high){
	int pivorkey =a[low];
	while(low<high){
		while(low<high && a[high]>=pivorkey){
			--high;
		}
		a[low] = a[high];
		while(low<high &&a[low]<=pivorkey){
			++low;
		}
		a[high] = a[low];
	}
	a[low] = pivorkey;
	return low;
}
int main()
{
	vector<int> data{12, 15, 9, 6,20, 6, 31, 24};
	int n = data.size();
	//SI_sort(data,n);
	//shell_sort(data,n);
	//Bibble_sort(data,n);
	quickSort(data,0,n-1);
    for (int i = 0; i < n; i++)
    {
        cout << data[i]<<" ";
    }
   return 0;
}