冒泡排序和快速排序算法

一、冒泡排序：冒泡排序的基本思想是多次遍历数组，每次比较相邻元素并交换顺序错误的元素，使较大的元素逐渐 "冒泡" 到数组末尾。

struct SqList{
	int *r;   //用于存储要排序的数组，大小是数字个数+1，其中r[0]用作哨兵，目的是减小时间复杂度
	int length;   //记录数字个数 
}; 
void swap(SqList &L,int i,int j){   //交换函数
	int temp=L.r[i];
	L.r[i]=L.r[j];
	L.r[j]=temp;
	
}

void BubbleSort(SqList &L){
	int i,j;
	int count=0; 
	for(i=1;i<L.length;i++){    //总共需要length-1次 
		for(j=1;j<L.length-i+1;j++){ 
			if(L.r[j]>L.r[j+1]){
				swap(L,j,j+1);			
			}
			    
		}
	}
}

冒泡排序的优化：在传统冒泡排序中，无论数组是否已经有序，算法都会执行固定的 n-1 轮比较（n 为数字个数）。

优化算法的核心：提前终止机制（通过设置flag来判断数组是否已经有序，若是则终止循环）

void BubbleSort(SqList &L){
	int i,j;
	int flag=1; 

	for(i=1;i<L.length&&flag;i++){    //总共需要length-1次
	     flag=0;
		for(j=1;j<L.length-i+1;j++){ 
			if(L.r[j]>L.r[j+1]){
				swap(L,j,j+1);     
				flag=1;						
			}
		}        //若flag=0则说明数组的排序已经完成 
	}
	
}

完整代码：

#include<iostream>
using namespace std;
struct SqList{
	int *r;   //用于存储要排序的数组，大小是数字个数+1，其中r[0]用作哨兵，目的是减小时间复杂度
	int length;   //记录数字个数 
}; 
void swap(SqList &L,int i,int j){
	int temp=L.r[i];
	L.r[i]=L.r[j];
	L.r[j]=temp;
	
}
/*void BubbleSort(SqList &L){    //优化前 
	int i,j;
	int count=0; 
	for(i=1;i<L.length;i++){    //总共需要length-1次 
		for(j=1;j<L.length-i+1;j++){ 
			if(L.r[j]>L.r[j+1]){
				swap(L,j,j+1);			
			}
			    
		}
	}
}*/
void BubbleSort(SqList &L){     //优化后的冒泡排序 
	int i,j;
	int flag=1; 

	for(i=1;i<L.length&&flag;i++){    //总共需要length-1次
	     flag=0;
		for(j=1;j<L.length-i+1;j++){ 
			if(L.r[j]>L.r[j+1]){
				swap(L,j,j+1);     
				flag=1;						
			}
		}        //若flag=0则说明数组的排序已经完成 
	}
	
}
int main(){
	int n,i;
	SqList L;
	cin>>n;
	L.r=new int[n+1];
	L.length=n;
	for(i=1;i<n+1;i++){
		cin>>L.r[i];	
	}
	BubbleSort(L); 
	for(i=1;i<=L.length;i++){
		cout<<L.r[i]<<" ";
	}
	cout<<endl;
	delete[] L.r;  // 释放动态分配的内存
	return 0;

}

二、快速排序：

核心思想：

1. 分治法：

   • 将原始数组划分为两个子数组，其中一个子数组的所有元素都小于另一个子数组的所有元素。
   • 递归地对子数组进行排序，最终合并成完整的有序数组。

2. 分区（Partition）：

   • 选择一个枢轴元素（pivot）（通常是数组的第一个元素）。
   • 调整数组，使得所有小于枢轴的元素放在左边，所有大于枢轴的元素放在右边。
   • 返回枢轴的最终位置，用于递归处理左右子数组。

int Partition(SqList &L,int low,int high){
	int p=L.r[low];
	while(low<high){
		while(low<high&&L.r[high]>p)
		    high--;		
		L.r[low]=L.r[high];
	    while(low<high&&L.r[low]<p)
	        low++;	    
	    L.r[high]=L.r[low];
	}
	L.r[low]=p;
	return low;
}
void QuickSort(SqList &L,int low,int high){

	if(low<high){
		int pivot=Partition(L,low,high);	
		QuickSort(L,low,pivot-1);
		QuickSort(L,pivot+1,high);
	}
}

 完整代码：

#include<iostream>
using namespace std;
struct SqList{
	int *r;   //用于存储要排序的数组，大小是数字个数+1，其中r[0]用作哨兵，目的是减小时间复杂度
	int length;   //记录数字个数 
}; 

int Partition(SqList &L,int low,int high){
	int p=L.r[low];
	while(low<high){
		while(low<high&&L.r[high]>p)
		    high--;		
		L.r[low]=L.r[high];
	    while(low<high&&L.r[low]<p)
	        low++;	    
	    L.r[high]=L.r[low];
	}
	L.r[low]=p;
	return low;
}
void QuickSort(SqList &L,int low,int high){

	if(low<high){
		int pivot=Partition(L,low,high);	
		QuickSort(L,low,pivot-1);
		QuickSort(L,pivot+1,high);
	}
}
int main(){
	int n,i;
	SqList L;
	cin>>n;
	L.r=new int[n+1];
	L.length=n;
	for(i=1;i<n+1;i++){
		cin>>L.r[i];	
	}
	QuickSort(L,1,L.length);
	for(i=1;i<=L.length;i++){
		cout<<L.r[i]<<" ";
	}
	cout<<endl;
	delete[] L.r;  // 释放动态分配的内存
	return 0;

}