专题1--排序算法-CSDN博客

本文链接：https://blog.csdn.net/weixin_42640840/article/details/107407577

参考：https://www.cnblogs.com/fnlingnzb-learner/p/9374732.html

一、排序算法分析

序号	排序方法	时间复杂度（平均）	时间复杂度（最坏）	时间复杂度（最好）	空间复杂度	稳定性
01	插入排序	O(n²)	O(n²)	O(n)	O(1)	稳定
02	希尔排序	O(n^1.3)	O(n²)	O(n)	O(1)	不稳定
03	选择排序	O(n²)	O(n²)	O(n²)	O(1)	不稳定
04	堆排序	O(nlogn)	O(nlogn)	O(nlogn)	O(1)	不稳定
05	冒泡排序	O(n²)	O(n²)	O(n)	O(1)	稳定
06	快速排序	O(nlogn)	O(n²)	O(nlogn)	O(nlogn)	不稳定
07	归并排序	O(nlogn)	O(nlogn)	O(nlogn)	O(n)	稳定

二、算法实现

01 插入排序

class Solution{
public:
	void InsertSort(vector<int>& nums){
		if(nums.size() < 2 ) return;
		int i, j;
		for(int i = 0; i < nums.size(); i++){
			for(int j = i; j > 0; j--){
				if(nums[j] < nums[j-1]) swap(nums[j], nums[j-1]);
				else break;
			}
		}
		return;
	}
}

02 希尔排序

class Solution{
public:
	void ShelltSort(vector<int>& nums){
		int n = nums.size();
		if(n < 2 ) return;
		for(int div = n / 2; div >= 1; div /= 2){ //分为几组
			for(int k = 0; k < div; k++){ //每组比较
				for(int i = div + k; i < n; i+= div){ //控制步长
					for(int j = i; j > k; j-= div){  //从后往前比较
						if(nums[j] > nums[j-div]) 
							swap(nums[j],nums[j-div]);

		return;
	}
}

03 选择排序

class Solution{
public:
	void SelectSort(vector<int>& nums){
		int len = nums.size();
		if(len < 2 ) return;
		int min, i,j;
		for(i = 0; i < len - 1; i++){
			min = i;
			for(j = i; j < len; j++)
				if(nums[j] < nums[min]) min = j;
			swap(nums[i],muns[min]);
		}
		return;
	}
}

04 堆排序

三步法：
1、创建堆；
2、交换数据；
3、向下调整。
最大堆sort之后：数据从小到大排序

class Solution{
public:
	
	void adjustheap(vector<int>& nums, int node, int len){
		int index = node;
		int child = 2 * index + 1; //因为第一个编号是0
		while(child < len){
			if(child+1 < len && nums[child] < nums[child + 1]) child++;
			if(nums[child] < nums[index]) break;
			swap(nums[child], nums[index]);
			index = child;
			child = index * 2 + 1;
		}
	}
	
	void makeheap(vector<int>& nums, int len){
		for(int i = len / 2; i >= 0; i--){
			adjustheap(nums,i,len);
		}
	}
	
	void heapSort(vector<int>& nums){
		int len = nums.size();
		makeheap(nums,len);
		for(int i = len - 1; i >= 0; i--){
			swap(nums[0],nums[i]);
			adjustheap(nums,0,i);
		}
		return nums;
	}
}

05 冒泡排序

class Solution{
public:
	void bubbleSort(vector<int>& nums){
		int len = nums.size();
		if(len < 2 ) return;
		//i是次数，j是下标
		for(i = 0; i < len-1; i++){
			for(j = 0; j < len-1-i; j++)
				if(nums[j] > nums[j+1]) 
					swap(nums[j],muns[j+1]);
		}
		return;
	}
}

06 快速排序

递归实现

class Solution{
public:
	void __quicksort(vector<int>& nums, int left, int right){
		if(nums.size() == 0) return;
		if(left >= right) return;
		
		//防止有序数组降低效率
		srand((unsigned)time(NULL));
		int len = right - left;
		int kindex = rand() % (len + 1) + left;//随机选取基准数
		swap(nums[index],nums[left]);
		
		int key = nums[left], i = left, j = right;
		while(i < j){
			while(nums[j] >= key && i < j) j--;
			if(i < j) nums[i] = nums[j];
			while(nums[i] < key && i < j) i++;
			if(i < j) nums[j] = nums[i]; 
 		}
		
		h[i] = key;
		__quicksort(nums,left,i-1);
		__quicksort(nums,j+1,right);//这样的一个好处，去掉相等的key
}
	void quickSort(vector<int>& nums){
		int left = 0, right = nums.size()-1;
		__quicksort(nums,left, right);
	}
}

非递归实现

class Solution{
public:
	void partition(vector<int>& nums,int left, int right){
		int key = nums[left];
		while(left < right){
			while(nums[right] >= key && left < right) right--;
			if(left < right) nums[left] = nums[right];
			while(nums[left] < key && left < right) left++;
			if(left < right) nums[right] = nums[left];
		}
		nums[left] = key;
		return left;
    }
	void __quicksort(vector<int>& nums, int left, int right){
		//手动利用栈来存储每次快排的起点
		//栈非空时循环获取中轴入栈
		stack <int> s;
		if(left < right){
			int index = partition(nums, left, right);
			if(index -1 > left){ //确保左分区存在
				s.push(left);
				s.push(index-1);
			}
			if(index + 1 < right){ //确保右分区存在
				s.push(index+1);
				s.push(right);
			}
			while( !s.empty()){
				int r = s.top(); s.pop();
				int l = s.top(); s.pop();
				
				index = partition(nums,l,r);
				if(index - 1 > l){
					s.push(l);
					s.push(index-1);
				}	
				if(index + 1 < r){
					s.push(index +1);
					s.push(r);
				}
			}
		}	
}
	void quickSort(vector<int>& nums){
		int left = 0, right = nums.size()-1;
		__quicksort(nums,left, right);
	}
}

07 归并排序

class Solution{
public:
	void __merge(vector<int>& nums, int left, int mid, int right){
		//将nums[left...mid]和nums[mid+1...right]两部分进行归并
		int tem[right-left+1];
		//赋初值
		for(int i = left; i <= right; left++){
			tem[i-left] = nums[i];
		}
		int i = left, j = mid + 1;
		for(int k = left; k <= r; k++){
			 if(i > mid){ nums[k] = tem[j-left]; j++;}
			 else if( j > r){nums[k] = tem[i-left]; i++;}
			 else if(tem[i-left] < tem[j-left]){
			 	nums[k] = tem[i-left]; 
			 	i++;
			 }
			 else {nums[k] = tem[right-l]; j++;}
		}
	}
	void __mergesort(vector<int>& nums, int left, int right){
		if(left >= right) return;
		int mid = (left + right) / 2;
		__mergesort(nums, left, mid);
		__mergesort(nums,mid + 1, right);
		__merge(nums, left, mid, right);	
	}
	void mergeSort(vector<int>& nums){
		__mergesort(nums, 0, nums.size()-1);
	}
}