排序算法实现及总结

排序算法实现及总结（c++)

(1)冒泡排序

时间复杂度：

最坏情况和平均情况：O(n²)

最好情况：O(n)

属于稳定排序

void Bubble_sort(vector<int>&nums){
	int n = nums.size()-1;
	for (int i = n; i > 0; i--){
		int flag = 0;//优化，加入提前判断排序完成语句
		for (int j pp= 0; j < n; j++){
			if (nums[j] > nums[j + 1]){
				swap(nums[j], nums[j + 1]);
				flag++;
			}
		}
		if (flag == 0)break;
	}
	return;
}

(2)选择排序

时间复杂度：

最坏情况，最好情况，平均情况：O(n²）

不是稳定排序

适用于数据量小的或有部分数据已经做过排序的情况；

void Select_sort(vector<int>&nums){
	int n = nums.size() - 1;
	for (int i = 0; i < n; i++){
		for (int j = i + 1; j <= n; j++){
			if (nums[i]>nums[j]){
				swap(nums[i], nums[j]);
			}
		}
	}
	return;
}

(3)插入排序

时间复杂度：

最坏情况、平均情况：O(n²)

最好情况：O(n)

是稳定排序

插入排序用于大部分数据已经过排序或已排序的数据库在新增数据后再进行排序

void Insert_sort(vector<int>&nums){
	int n = nums.size() - 1;
	for (int i = 1; i <= n; i++){
		int temp = nums[i];
		int j = i - 1;
		while (j >= 0 && nums[j] > temp){
			nums[j + 1] = nums[j];
			j--;
		}
		nums[j+1] = temp;
	}
}

(4)希尔排序

希尔排序是插入排序的变形，但希尔排序不受输入数据顺序的影响

任何状况的时间复杂度都为O(n3/2)，适用于数据大部分都已经排序完成的情况

void Shell_sort(vector<int>&nums){
	int n = nums.size() - 1;
	int jump = nums.size() / 2;//分组距离
	while (jump != 0){
		for (int i = jump; i <= n; i++){
			int j = i - jump;
			int temp = nums[i];
			while (j>=0&&nums[j]>temp){
				nums[j + jump] = nums[j];
				j = j - jump;
			}
			nums[j+jump] = temp;
		}
		jump = jump / 2;
	}
	return;
}

(5)快速排序

快速排序是平均运行时间最快的排序法，在最好和平均情况下复杂度为O(nlogn)

最坏情况下就是每次挑中的中间值不是最大就是最小，复杂度为O(n²)

在最差情况下，空间复杂度为O(n),而最佳情况下为O(logn)

void Quick_sort_core(vector<int>&nums,int L,int R){
	if (L >= R)return;
	int flag = L;
	int i = L + 1;
	int j = R;
	while (1){
		while (nums[j]>nums[flag]){
			j--;
		}
		while (nums[i] < nums[flag] && i < j){
			i++;
		}
		if (i >= j)break;
		swap(nums[i], nums[j]);
		j--;
		i++;
	}
	swap(nums[flag], nums[j]);
	Quick_sort_core(nums, L, j - 1);
	Quick_sort_core(nums, j + 1, R);
}
void Quick_sort(vector<int>&nums){
	if (nums.size()<2)return;
	Quick_sort_core(nums, 0, nums.size() - 1);
}

（6）归并排序

void Merge(vector<int>&nums, int L, int mid, int R){
	vector<int>temp;
	int l = L;
	int m = mid;
	int r = mid+1;
	while (l <= m&&r <= R){
		if (nums[l] <= nums[r]){
			temp.push_back(nums[l]);
			l++;
		}
		else{
			temp.push_back(nums[r]);
			r++;
		}
	}
	if (l > m){
		for (int i = r; i <= R; i++){
			temp.push_back(nums[i]);
		}
	}
	else{
		for (int j = l; j <= m; j++){
			temp.push_back(nums[j]);
		}
	}
	int numbers = R - L;
	for (int num = 0; num <= numbers; num++){
		nums[L] = temp[num];
		L++;
	}
}
void M_sort(vector<int>&nums, int L, int R){
	if (L == R)return;
	int mid = (L + R) / 2;
	M_sort(nums, L, mid);
	M_sort(nums, mid + 1, R);
	Merge(nums, L, mid, R);
	return;
}
void Merge_sort(vector<int>&nums){
	if (nums.size() == 0 || nums.size() == 1)return;
	int n = nums.size() - 1;
	return M_sort(nums,0,n );
}

(7)堆排序

void heapsort(std::vector<int>&nums){
    int end=nums.size();
    for(int i=end/2-1;i>=0;i--){
        heapjust(nums,i,end);
    }
    for(int j=end-1;j>=0;j--){
        std::swap(nums[0],nums[j]);
        heapjust(nums,0,j);
    }
}

void heapjust(std::vector<int>&nums,int begin,int end){
    int i=2*begin+1;
    for(;i<end;i=2*begin+1){
        if(i+1<end&&nums[i+1]>nums[i]){
            i++;
        }
        if(nums[begin]<nums[i]){
            std::swap(nums[begin],nums[i]);
            begin=i;
        }
        else break;
    }
}