冒泡排序，快速排序

冒泡排序

基础款、

时间复杂度 O（n^2）最好最坏一样

空间 O（1）

void baseBubbleSort(int *a){ //基础冒泡算法
    for(int i = 1; i <= a[0]; i++){
        for(int j = 1; j <= a[0] - i; j++){
            if(a[j+1] < a[j]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
            }
        }
    }
}

加强版

时间复杂度 :   最好 O（n） 最坏 O（n^2）平均  O（n^2）

空间:  O（1）

void seniorBubbleSort1(int *a){ //flag 做标记
    for(int i = 1; i <= a[0]; i++){
        bool flag = 0;
        for(int j = 1; j <= a[0] - i; j++){
            if(a[j+1] < a[j]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                flag = 1;
            }
        }
        if(flag == 0){
            return ;
        }
    }
}

 

void seniorBubbleSort2(int *a){ //找最后一次交换位置
    int i = a[0];
    while(i > 1){
        int lastExchangeIndex = 1;
        for(int j = 1; j < a[0]; j++){
            if(a[j+1] < a[j]){
                int temp = a[j];
                a[j] = a[j+1];
                a[j+1] = temp;
                lastExchangeIndex = j;
            }
        }
        i = lastExchangeIndex;
    }
}

快速排序

时间复杂度 ：最好（越接近无序越快）O（n*logn）以2为底  最坏（接近有序）:  O（n^2）  平均 O（n^2）

空间复杂度：O（log n）以2 为底

int Partition(int *a, int low, int high){
	int temp = a[low];
	while(low < high){
		while( a[high] >= temp && low < high) --high;
		a[low] = a[high];
		while( a[low] < temp && low < high) ++low;
		a[high] = a[low];
	}  
	a[low] = temp;
	return low;
}
void QSort(int *a, int low, int high){	//快速排序 
    if(low < high){
    	int mid = Partition(a, low, high);
        QSort(a, low, mid - 1);
		QSort(a, mid + 1, high); 
    }
}

int main()
{
    int n;
    cout << "输入无序数组的个数 ：" << endl;
    cin >> n;
    int *a = new int[n+1];
    a[0] = n;
    
    for(int i = 1; i <= a[0] ; i++){
        cin >> a[i];
    } 
    QSort(a, 1, a[0]);
    for(int i = 1; i <= a[0]; i++){
        cout << a[i] << " " ;
    }

}