排序算法专题

已于 2023-08-21 23:48:07 修改
阅读量159 收藏
点赞数
分类专栏： 算法知识 文章标签： 排序算法 算法 数据结构
于 2020-10-18 11:02:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43015237/article/details/104576127
版权
  1. 冒泡排序bubbleSort
  2. 选择排序selectionSort
  3. 插入排序insertSort
    从待排序列中选择一个元素插入到有序序列的合适位置，并且其后的元素向后移动。适合待排序列基本有序，这样移动较少。
    归并排序mergeSort
    快速排序quickSort
    堆排序heapSort

冒泡排序:相邻元素两两比较，将通过比较得到的最大元素放在最后
选择排序:总是选最小的元素放在当前有序序列的末尾，选n-1次
插入排序:插入有序序列的合适位置使其仍有序，插n-1次
归并排序:一分为二，两边有序后再合并。具体为反复一分为二，到一个元素分不了了(一个元素有序)，再向上合并merge。典型的分治思想三部曲，分解子问题，求解子问题，合并子问题。递归边界
快速排序:partition返回的枢轴在整体有序序列的下标，一次划分partition后左边元素都比以partion为下标的元素小，右边元素都比它大，再对partion两边元素求解直到区间长度为1有序。分治思想，不需要合并子问题。

1、冒泡排序

def bubbleSort(nums, size):
    for _ in range(size - 1):
        flag = True
        for i in range(size - 1 - i):  # 对range(size-1)的优化
            if nums[i] > nums[i+1]:
                nums[i], nums[i+1] = nums[i+1], nums[i]
                flag = False
        if flag:
            break

if __name__ == '__main__':
    import numpy as np
    max_len = 15
    nums = np.arange(0, max_len)

    repeats = 1000
    while repeats:
        np.random.shuffle(nums)
        bubbleSort(nums, max_len)
        # print(nums)
        assert (nums == np.arange(max_len)).all()
        repeats -= 1

/*
冒泡排序
相邻两个元素比较，交换 
*/

#include<iostream>
#include<algorithm>
using namespace std;

void bubbleSort(int A[], int n)
{
	for(int i=0; i<n-1; i++)
	{
		bool flag = true;
		for(int j=0; j<n-i-1; j++)	//j=0,第一趟比较n-1次 
		{
			if(A[j+1] < A[j])
			{
				swap(A[j], A[j+1]);
				flag = false;
			}
		}
		if(true == flag)
			break;
	}
}

int main()
{
	const int n = 5;
	int A[n] = {6,4,5,2,3};
	bubbleSort(A, n);
	for(int i=0; i<n; i++)
		cout<<A[i]<<" ";
		
	return 0;
}

2.选择排序

def selectSort(nums, size):
    for i in range(size - 1):  # 需要正确的填nums[i]
        min_idx, min_value = i, nums[i]
        for j in range(i+1, size):
            if nums[j] < min_value:
                min_idx, min_value = j, nums[j]
        if min_idx != i:
            nums[i], nums[min_idx] = nums[min_idx], nums[i]

if __name__ == '__main__':
    import numpy as np
    max_len = 15
    nums = np.arange(0, max_len)

    repeats = 1000
    while repeats:
        np.random.shuffle(nums)
        selectSort(nums, max_len)
        # print(nums)
        assert (nums == np.arange(max_len)).all()
        repeats -= 1

/*
选择排序，对数组 
排序函数形参为数组，返回类型为void，数组“传地址” 
*/

#include<iostream>
#include<algorithm>
using namespace std;

void selectionSort(int A[], int n)
{
	for(int i=0; i<n-1; i++)			//选当前最小的 元素放在A[i]处 
	{
		int idx = i;
		for(int j=i+1; j<n; j++)
		{
			if(A[j] < A[idx])
				idx = j;
		}
		
		if(idx != i)	//这个判断也可以去掉 
		{
			swap(A[idx], A[i]);
			//int temp = A[idx];
			//A[idx] = A[i];
			//A[i] = temp;
		}
	}
}

int main()
{
	int n = 5;
	int A[n] = {1,4,5,2,3};
	selectionSort(A, n);
	
	for(int i=0; i<n; i++)
		cout<<A[i]<<" ";
		
	return 0;
}

3、插入排序

注意：
第0个元素已经有序，只需要从第1个元素开始插入；
后移时会覆盖当前待插入的元素，需要提前记录
j的处理，找到有序序列中小于cur_num的元素位置j（可能没有则j=-1），则j+1即为cur_num的位置

def insertSort(nums, size):
    for i in range(1, size):
        cur_num = nums[i]
        j = i - 1
        while j >= 0:
            if nums[j] >= cur_num:
                nums[j+1] = nums[j]
            else:
                break
            j -= 1
        # for j in range(i-1, -1, -1):
        #     if nums[j] >= cur_num:
        #         nums[j+1] = nums[j]
        #     else:
        #         break
        #     # if j == 0:
        #     #     j -= 1
        nums[j+1] = cur_num

if __name__ == "__main__":
    import numpy as np

    max_len = 15
    nums = np.arange(0, max_len)

    repeats = 1000
    while repeats:
        np.random.shuffle(nums)
        insertSort(nums, max_len)
        # print(nums)
        assert (nums == np.arange(max_len)).all()
        repeats -= 1

/*
插入排序
只需要对后n-1个数插入到前面指定位置 
从后往前比较， 
*/

#include<iostream>
using namespace std;

void insertSort(int A[], int n)
{
	for(int i=1; i<n; i++)	//从第二个数(下标1)起都得插入 
	{
		int insertN = A[i];	//待插入的数，必须记录下来，不然后面往后挪动后会被覆盖 
		int j=i-1;
		for(; j>=0; j--)
		{
			if(insertN < A[j])
				A[j+1] = A[j];
			else
				break;
		}
		if(insertN != A[i]) 	//未向后挪动，即当前不改变就是有序序列 //这个判断也可以去掉																																							
			//A[j+1] = A[i];	错误，可能已经被覆盖，不再是原始序列的A[i]
			A[j+1] = insertN; 
	}
}
				 
int main()
{
	const int n = 5;
	int A[] = {1,4,5,2,3};
	insertSort(A, n);
	
	for(int i=0; i<n; i++)
		cout<<A[i]<<" ";
		
	return 0;
}

4、二路归并排序

注意：
range的右边界是开的，而right1、right2是闭的
只能mid、mid+1而不能mid-1、mid

def merge(nums, left1, right1, left2, right2):
    left1_copy, left2_copy = left1, left2
    nums_ans = [-1] * (right1 - left1 + 1 + right2 - left2 + 1)
    itr = 0
    while left1 <= right1 and left2 <= right2:
        if nums[left1] < nums[left2]:
            nums_ans[itr] = nums[left1]
            itr += 1
            left1 += 1
        else:
            nums_ans[itr] = nums[left2]
            itr += 1
            left2 += 1
    while left1 <= right1:
        nums_ans[itr] = nums[left1]
        itr += 1
        left1 += 1
    while left2 <= right2:
        nums_ans[itr] = nums[left2]
        itr += 1
        left2 += 1

    # 迁移到nums
    itr = 0
    for _ in range(left1_copy, right1 + 1):  # attention
        nums[left1_copy] = nums_ans[itr]
        left1_copy += 1
        itr += 1
    for _ in range(left2_copy, right2 + 1):
        nums[left2_copy] = nums_ans[itr]
        left2_copy += 1
        itr += 1


def mergeSort(nums, left, right):
    if left < right:
        mid = (left + right) // 2
        mergeSort(nums, left, mid)
        mergeSort(nums, mid + 1, right)
        merge(nums, left, mid, mid + 1, right)


if __name__ == '__main__':
    import numpy as np

    max_len = 15
    nums = np.arange(0, max_len)

    repeats = 1000
    while repeats:
        np.random.shuffle(nums)
        mergeSort(nums, 0, max_len-1)
        # print(nums)
        assert (nums == np.arange(max_len)).all()
        repeats -= 1

/*
归并排序
递归方式
*/

#include<iostream>
using namespace std;

void merge(int A[], int L1, int R1, int L2, int R2){
	int *B = new int(R1-L1+1+R2-L2+1);
	int k=0;
	int i=L1, j=L2;
	while(i<=R1 && j<=R2){
		if(A[i]<A[j])
			B[k++] = A[i++];
		else
			B[k++] = A[j++];
	}
	while(i<=R1)
		B[k++] = A[i++];
	while(j<=R2)
		B[k++] = A[j++];
		
	for(int i=0; i<k; i++)
		A[L1+i] = B[i];
}

void mergeSort(int A[], int left, int right){
	if(left<right){
		int mid = (left+right)/2;
		mergeSort(A, left, mid);
		mergeSort(A, mid+1, right);
		merge(A, left, mid, mid+1, right);
	}
}

int main(){
	//int A[5] = {5,3,5,6,8};
	int A[9] = {3,4,5,1,2,9,8,6,7};
	mergeSort(A,0,8);
	
	for(int i=0; i<9; i++)
		cout<<A[i]<<" ";
		
	return 0;
}

5、快速排序

def partition(nums, left, right):
    pivot = nums[left]
    while left < right:
        while left < right and nums[right] >= pivot:
            right -= 1
        nums[left] = nums[right]
        # left += 1
        while left < right and nums[left] <= pivot:
            left += 1
        nums[right] = nums[left]
        # right -= 1
    nums[left] = pivot
    return left

def quickSort(nums, left, right):
    if left < right:
        pos = partition(nums, left, right)
        quickSort(nums, left, pos-1)
        quickSort(nums, pos+1, right)
    # return nums

if __name__ == '__main__':
    import numpy as np
    max_len = 15
    nums = np.arange(0, max_len)

    repeats = 1000
    while repeats:
        np.random.shuffle(nums)
        quickSort(nums, 0, max_len-1)
        # print(nums)
        assert (nums == np.arange(max_len)).all()
        repeats -= 1

#include<iostream>
using namespace std;

int partition(int A[], int left, int right){
	int pivot = A[left];						//记录枢轴 
	while(left<right){
		while(left<right && A[right]>=pivot)	//必须带等号，否则部分样例陷入死循环(该样例就是) 
			right--;
		A[left] = A[right]; // 不可以改为A[left++] = A[right];
		
		while(left<right && A[left]<=pivot)		//同上 
			left++;
		A[right] = A[left]; // 不可以改为A[right--] = A[left];
	} 
	//此时left==right
	A[left] = pivot;
	return left;
}

void quickSort(int A[], int left, int right){
	if(left<right){								
		int pos = partition(A, left, right);
		quickSort(A, left, pos-1);
		quickSort(A, pos+1, right);
	}
}

int main(){
	int A[5] = {5,3,5,6,8};
	quickSort(A,0,4);
	
	for(int i=0; i<5; i++)
		cout<<A[i]<<" ";
		
	return 0;
}

6、堆排序

排序时每次替换第一个元素，末尾元素在不断前移（待排序列长度不断减小）
下浮时，要判断左右孩子是否存在，不存在时退出，存在一个时…存在两个时取最小者；判断最小者是否小于父结点，是的话才交换，否则退出

"""
待排序列：nums[1]-nums[seq_len] = nums[1:seq_len+1]
len(nums) = seq_len+1，nums[0]闲置
"""

def adjust_iteration(nums, k, seq_len):
    while 2 * k <= seq_len:
        if 2 * k + 1 <= seq_len and nums[2 * k + 1] < nums[2 * k]:
            i = 2 * k + 1
        else:
            i = 2 * k
        if nums[k] > nums[i]:
            nums[k], nums[i] = nums[i], nums[k]
            k = i
        else:
            break


def adjust_recursion(nums, k, seq_len):
    if 2 * k <= seq_len:
        if 2 * k + 1 <= seq_len and nums[2 * k + 1] < nums[2 * k]:
            i = 2 * k + 1
        else:
            i = 2 * k
        if nums[k] > nums[i]:
            nums[k], nums[i] = nums[i], nums[k]
            adjust_recursion(nums, i, seq_len)

def heapSort(nums, seq_len):
    # 第一步建堆：从最后一个非叶子结点调整
    for i in range(seq_len // 2, 0, -1):
        adjust_recursion(nums, i, seq_len)

    # 第二步反复取堆顶的最小元素，并用末尾元素替代，并重新调整
    for cur_len in range(seq_len, 1, -1):
        nums[1], nums[cur_len] = nums[cur_len], nums[1]
        adjust_recursion(nums, 1, cur_len-1)
    return nums

if __name__ == '__main__':
    import numpy as np
    np.random.seed(1)
    max_len = 15
    nums = np.arange(0, max_len)

    repeats = 1000
    while repeats:
        np.random.shuffle(nums)
        ans = heapSort(np.concatenate(([-1], nums)), max_len)
        # print(ans[1:])
        assert (ans[1:] == np.arange(max_len-1, -1, -1)).all()
        repeats -= 1

#include<iostream>
using namespace std;


void Adjust(int A[], int k, int len) {
	for(int i = 2*k; i<=len; i*=2) {
		if(i+1<=len && A[i+1]<A[i]) //找最小的孩子
			i++;
		if(A[i]<A[k]) {
			swap(A[i], A[k]); 
			k = i;		//此时A[k]替换到i的位置，可能破坏了以i下标结点为根的堆，
		}
	}
}
	 	
void heapSort(int A[], int len){	//下标为1-len
	//先构造初始堆，从最后一个非叶子结点起，不断调整
	for(int i=len/2; i>=1; i--)
		Adjust(A, i, len);
	//堆底元素替换堆顶元素，再以堆顶为根节点调整
	for(int i=len; i>1; i--){	//len-1次 
		swap(A[1],A[i]);
		Adjust(A,1,i-1); 		//剩下i-1个元素调整为对 
	}
} 

int main(){
	int A[6] = {0,5,3,5,6,8};
	heapSort(A,5);
	
	for(int i=1; i<6; i++)
		cout<<A[i]<<" ";
		
	return 0;
}

7、希尔排序

改进的插入排序基本组件是插入排序，同时引入了控制增量gap（最终一定得是1）
0、gap、2gap、
1、1+gap、2+gap、

gap = len // 2
while gap:
	for i in range(gap):
		排序  i、i+gap、
	gap  = gap // 2

8、桶排序

设置桶的数量5
找出待排序列元素的最大值maxValue、最小值minValue。
则每个桶的存放的数据范围大小为interval_len=(maxValue-minValue) // 5 + 1，并不是桶的容量，一个桶可以存着无数数据
第0桶存放数据的范围为minValue-minValue+interval_len只要(num-minValue) // interval_len==0 就放入该桶
第i桶存放数据的范围为minValue-minValue+interval_len只要(num-minValue) // interval_len==i 就放入该桶
因为桶间有序，故只需对非空的桶进行排序（需要某排序算法例如冒泡）

9、基数排序

时间复杂度O(kn)，k为数位
空间复杂度O(k+n)
一种多关键字的排序算法，可用桶排序实现。

算法思想：
取得数组中的最大数，并取得位数；
arr为原始数组，从最低位开始取每个位组成radix数组；
对radix进行计数排序（利用计数排序适用于小范围数的特点）

10、计数排序

时间复杂度O(n+k)，k是值域范围
空间复杂度O(k)

计数排序
计数排序统计小于等于该元素值的元素的个数i，于是该元素就放在目标数组的索引i位（i≥0）。

计数排序基于一个假设，待排序数列的所有数均为整数，且出现在（0，k）的区间之内。
如果 k（待排数组的最大值） 过大则会引起较大的空间复杂度，一般是用来排序 0 到 100 之间的数字的最好的算法，但是它不适合按字母顺序排序人名。
计数排序不是比较排序，排序的速度快于任何比较排序算法。

算法思想：
找出待排序的数组中最大和最小的元素；
统计数组中每个值为 i 的元素出现的次数，存入数组 C 的第 i 项；
对所有的计数累加（从 C 中的第一个元素开始，每一项和前一项相加）；
向填充目标数组：将每个元素 i 放在新数组的第 C[i] 项，每放一个元素就将 C[i] 减去 1

Echo木
关注
专栏目录
排序算法专题实训
Junds0的博客
09-06 1549
本关任务：编写函数通过比较数组相邻两个元素求数组最大值。 第2关：冒泡排序 本关任务：编写函数实现冒泡排序。 第3关：快速排序的递归算法 本关任务：编写函数实现快速排序的递归算法。 第4关：编写函数在一个数组中选择最小值 本关任务：编写函数在一个数组一定范围内选择最小值。 第5关：简单选择排序 本关要求通过定义函数void SelectSort(int *a,int n)来实现简单选择排序的功能。 第6关：堆排序 本关任务：编写函数实现堆排序。 第7关：编写函数将一个给定的整数插到原本有序的整数序列中，使结
排序算法专题练习1.pdf
最新发布
03-30
【排序算法专题练习】 1. 冒泡排序优化： 冒泡排序是一种基础的排序算法，它通过重复地遍历待排序的序列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。这个过程会持续到没有再需要交换，也就是说该序列...
排序算法专题记录
爱踢球的程序员的博客
01-25 742
排序算法
排序算法专题-计数排序
lemon_tttea的博客
12-16 506
  计数排序是一种在数值小于100以内十分高效的排序算法，时间复杂度为O(n)，原理十分简单，是一个桶的简单运用（后面有机会再详细介绍介绍桶）。比如我们排序元素的数值分布在1-100，那么首先遍历一遍数组，记录1-100每个数值出现的个数，比如1,10,1,12，那么1出现了2次，10出现了1次，12出现了1次。就这样，两次O(n)时间复杂度的遍历就可以完成排序，这种只适用于数组最大值和最小值差值不大的情况，这种情况效率很高，但是如果差值较大，时间和空间开销都很高。 算法步骤： （1）找出待排序的数组
排序算法专题-快速排序
lemon_tttea的博客
12-14 1273
  快速排序是冒泡排序算法基础上改进的进阶版排序算法，他使用分治法把一个序列基于一个基准分成两个子序列，比如left均小于基准,right均大于基准，通过再次选择基准对left和right序列进行递归的划分，直到划分的数组长度为1或者0，由于划分依据是在序列中选择一个基准，即每次迭代至少有一个元素（基准）是放到了正确的而位置，所以这个算法一定会结束。 算法步骤： 1：从数列中挑出一个元素，称为 “基准”（pivot）; 2：重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准
排序算法专题-希尔排序
lemon_tttea的博客
12-10 759
  希尔排序也叫递减增量排序，是第一批冲破O(n2)的算法之一，他的算法思想很简单，首先拟定一个增量gap，一般是从len(nums)//3或者len(nums)//2开始,然后对序列nums[i,i+gap,i+gap*k…]进行插入排序，一轮迭代完成后gap=gap//2，知道gao=1是，排序完成。 算法步骤是： 1：选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；:2：按增量序列个数 k，对序列进行 k 趟排序； 2：每趟排序，根据对应的增量 ti，将待排序列
排序算法专题-冒泡排序
lemon_tttea的博客
12-09 1068
  顾名思义，冒泡排序的原理就是最小（最大）的元素会在一次次迭代中逐渐浮现到数组的顶端，每一次的迭代都是相邻两个元素之间的比较. 具体的算法步骤是： 1:比较相邻的元素。如果第一个比第二个大，就交换他们两个。 2:对每一对相邻元素作同样的比较和操作，一直到数组最后一个元素。第一轮迭代完成后，最后的元素会是最大的数。 3:针对所有的元素重复以上的步骤，每一轮迭代需要的比较次数为n-k，k为已经迭代的次数，因为每迭代以此，就有一个元素确定了位置。 举个栗子： 原数组：3 38 5 44 15 36
排序算法专题-概览
lemon_tttea的博客
12-09 911
  排序算法是很多算法的基础，尤其是目前最为热门的搜索、推荐系统中，良好的排序可以极大的促进搜索效率，目前市场上各种各样的算法都是基于下述的十大经典排序算法。   总的来说，排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排序、基数排序等。用一张图概括： 图片来源-菜鸟教程 ...
排序算法专题-归并排序
lemon_tttea的博客
12-13 1013
  归并排序是一种十分经典的冲破O(n2)时间复杂度的排序算法，该算法是基于分治的思想，讲解算法原理之前，先看一下下面一张图。 图片来源：【算法】排序算法之归并排序   上图就是归并算法的一个简单示例。该算法就是每次将数组递归拆解为两部分，直到所有部分包含元素为1，之后递归的将各个部分进行归并。 具体的算法步骤如下： 1:递归拆解数组，直到每个区块包含元素数量为1 2：归并数组，直到归并后的数组长度等于原数组长度 3： 申请空间，使其大小为两个已经排序序列之和，该空间用来存放合并后的序列 4：设定两
排序算法专题-桶排序
lemon_tttea的博客
12-17 625
  计数排序其实本质上就是一种桶，只不过每个桶对应一个数值，可以理解为桶排序的一种最原始情况，而桶排序是计数排序的升级版，他的桶对应是一个映射区间，而不是一个值，如下图： 图片来源：桶排序   而后在桶内完成排序，最后将各个桶连接起来，完成排序。该算法很容易理解，但是其高效与否取决于两个部分，一个是映射空间的划定，最好的情况是n个数组均匀的划分到k个桶中，最坏的情况是输入的数组分配到了同一个桶中；第二个是桶内排序算法的选择，本文基于python的内置是Timsort排序算法实现，Timsort排序算法以
排序算法专题练习1.docx
03-30
冒泡排序是一种简单的排序算法，它重复地遍历待排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字...
TSP with Miller-Tucker-Zemlin (MTZ) model
qq_43015237的博客
06-16 3484
TSP with Miller-Tucker-Zemlin 建模与解释
C++多种方法判断奇数
qq_43015237的博客
02-16 2810
多种方式判断奇数
P问题、NP问题
qq_43015237的博客
03-20 2357
P、NP、NPC与NPH 1. 基本概念 多项式时间（Polynomial time） 在计算复杂度理论中，指一个问题的计算时间不大于问题规模的多项式倍数，即在表示时间复杂度时问题的规模n作为底数，例如O(nk), O(log n), 而不是O(an), O(n!)。与多项式时间对应的是“超多项式时间”，表示只要问题规模足够大，超多项式时间所需的解题时间终究会大大超过任何多项式时间。多项式时间被看作是计算机解决问题的分水岭。 非确定性算法 非确定性算法将问题分解成猜测和验证两个阶段，算法的猜测阶段是
食谱问题Diet Problem
qq_43015237的博客
06-07 1206
食谱问题Diet Problem 线性规划
KKT条件与SVM
qq_43015237的博客
05-04 973
结合KKT条件，分析SVM并编程实现
割线法求根
qq_43015237的博客
06-08 727
割线法求根
FFD for bin packing装箱问题的FFD算法
qq_43015237的博客
05-12 464
FFD for bin packing (hard)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值