数据结构与算法常见排序算法(持续更新中)

已于 2024-06-12 15:20:08 修改
阅读量320 收藏 4
点赞数 10
文章标签： 排序算法 算法 数据结构 c++
于 2024-04-07 16:10:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_56640148/article/details/137240848
版权

学习笔记

堆

非叶子节点的下标为n/2-1(下标从0开始，/代表整除)

需要注意的地方

1.传参进去是坐标还是数值
2.堆排序需要递归

代码

# include<iostream>
using namespace std;
void print(int *arr,int n)
{
	for(int i=0;i<n;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}
void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}
void heaptify(int *arr,int n,int now) 
{
	int largest=now;
	int left=2*largest+1;
	int right=2*largest+2;
	if(arr[left]>arr[largest]&&left<n)
	{
		largest=left;
	}
	if(arr[right]>arr[largest]&&right<n)
	{
		largest=right;
	}
	if(largest!=now)
	{
		swap(arr[largest],arr[now]);
		heaptify(arr,n,largest);
	}
	
}
void heapSort(int *arr,int n)
{
	for(int i=n/2-1;i>=0;i--)
	{
		heaptify(arr,n,i);//从最后一个非叶子节点开始构造大顶堆 
	}
	for(int i=n-1;i>=0;i--)
	{
		swap(arr[i],arr[0]);//将最大的放到数组的最后
		heaptify(arr,i,0) ;
	}
}
int main()
{
	int arr[] = {12, 11, 13, 5, 6, 7};
	int n =sizeof(arr)/sizeof(arr[0]);
	print(arr, n);
	heapSort(arr,n);
	print(arr, n);
}

快速排序

需要注意的地方

1.while循环和if 条件，都是取等号的

代码

void quickSort(int *arr,int n,int left,int right)
{
	if(left<right)
	{
		int pivot=(left+right)/2; //基准坐标
		int i =left;
		int j=right;
		while(i<=j) //取等号 ，不然不运行结果 
		{
			while(arr[i]<arr[pivot])
			{
				i++;
			}
			while(arr[j]>arr[pivot])
			{
				j--;
			}
			
			if(i<=j) //取等号
			{
				swap(arr[i],arr[j]);
				i++;//交换后要记得++,--
				j--;
			}
			
			
		}//递归不能忘记
		quickSort(arr,n,left,j); //只有在left<right 的大前提下才会继续进行quick,并且，i,j是if大条件下的变量
		quickSort(arr,n,i,right);
		 
	}
	
}

归并排序

需要注意的地方

  1. L2是从mid+1开始的

代码

# include<iostream>
using namespace std;
void print(int *arr,int n)
{
	for(int i=0;i<n;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}
void swap(int &a, int &b)
{
    int temp;
    temp = a;
    a = b;
    b = temp;
}
void merge(int left,int mid,int right,int*arr)
{
	int n1=mid-left+1;
	int n2=right-(mid+1)+1;
	int L1[n1]={0};
	int L2[n2]={0};
	for(int i=0;i<=n1;i++)
	{
		L1[i]=arr[left+i]; 
	}
	//print(L1,n1);
	for(int j=0;j<=n2;j++)
	{
		L2[j]=arr[mid+1+j]; //这里从mid+1开始
	}
	//print(L2,n2);
	int i=0;
	int j=0;
	int p=left;
	while(i<n1&&j<n2)
	{
		if(L1[i]<L2[j])
		{
			arr[p]=L1[i];
			p++;
			i++;
		}
		else
		{
			arr[p]=L2[j];
			p++;
			j++;
		}
	
	}
	while(i<n1)
	{
		arr[p]=L1[i];
		p++;
		i++;
	}
	while(j<n2)
	{
		arr[p]=L2[j];
		p++;
		j++;
	}
}
void mergeSort(int *arr ,int n,int left,int right)
{
	if(left<right)
	{
		int mid=(left+right)/2;
		mergeSort(arr,n,left,mid);
		mergeSort(arr,n,mid+1,right);
		merge(left,mid,right,arr);
	}
}

int main()
{
	int arr[] = {12, 11, 13, 5, 6, 7};
	int n =sizeof(arr)/sizeof(arr[0]);
	print(arr, n);
	mergeSort(arr,n,0,n-1);
	print(arr, n);
}

选择排序

选择排序是一种简单直观的排序算法，它的基本思想是每次从待排序的元素中选择最小（或最大）的元素，然后将其放到已排序序列的末尾。这个过程重复进行，直到所有元素都排序完成。

需要注意的地方

1.注意比较的是两个元素，但是交换的是下标
2. if(index_min!=i)
{
swap(arr[i],arr[index_min]);
}
这个if可以没有，但是必须有交换的过程

代码

# include<iostream>
# include<string>
using namespace std;
void swap(int &a ,int &b)
{
	int temp;
	temp=a;
	a=b;
	b=temp;
}
void selectionSort(int *arr,int n)
{
	for(int i=0;i<n-1;i++) //每次放置的位置 
	{
		int index_min=i;
		 for(int j=i+1;j<n;j++)
		 {
		 	if(arr[j]<arr[index_min])
		 	{
			 	index_min=j;
			} 
		 }
		 if(index_min!=i)
		 {
		  swap(arr[i],arr[index_min]);
		 }
		
	}
}

int main() {
    int arr[] = {64, 25, 12, 22, 11};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    selectionSort(arr, n);

    cout << "Sorted array: ";
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;

    return 0;
}

插入排序

需要注意的地方

1.插入排序要用while 来进行计算，内层循环

代码

# include<iostream>
# include<string>
using namespace std;
void print(int *arr,int n)
{
	for(int i=0;i<n;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}
void insertion(int *arr,int n)
{
	for(int i=0;i<n-1;i++) //i 代表要插入的起始位置 
	{
		int key=arr[i+1];
		int j=i;
		while(j>=0&&arr[j]>key) //比要key大的元素都往后移动 
		{
			arr[j+1]=arr[j];
			j--;
		}
		arr[j+1]=key;
	}
}
int main()
{
	int arr[]={5, 2, 4, 6, 1, 3};
	int n=sizeof(arr)/sizeof(arr[0]);
	print(arr,n);
	insertion(arr,n);
	print(arr,n);
}

计数排序

需要注意的地方

  1. 注意循环的上限是n还是length ,这两个代表不同的意思，并且容易混淆
  2. int o_index =count[index]-1; o_index需要通过count来计算，而不是直接index ，很容易就写错了
  3. count[index]–;不能忘记
  4. 计数排序放置位置的时候需要逆序
    为何要逆序

代码

# include<iostream>
using namespace std;
void print(int *arr,int n)
{
	for(int i=0;i<n;i++)
	{
		cout<<arr[i]<<" ";
	}
	cout<<endl;
}
void countSort(int *arr,int n)
{
	int max=arr[0];
	int min=arr[0];
	for(int i=0;i<n;i++)
	{
		if(max<arr[i])
		{
			max=arr[i];
		}
		if(min>arr[i])
		{
			min=arr[i];
		}
	}
	int length=max-min+1;
	int count[length]={0};
	//index作为下标，count数组作为每个数相对于最小值有几个 
	for(int i=0;i<n;i++)
	{
		int index=arr[i]-min;
		count[index]++;
	}
	for(int i=0;i<length-1;i++)
	{
		count[i+1]=count[i]+count[i+1];
	}
	int output[n]={0};
	
	//根据累加数组的结果，将原数排序好放到output数组中
	//这里是正序放入的，相对位置会改变，其实不是严格意义上的计数排序，但是方便理解（后面基数排序会写基数排序的逆序版）
	for(int i=0;i<n;i++)  
	{
		int index=arr[i]-min;
		int o_index=count[index]-1;//output数组下标从0开始
		output[o_index]=arr[i];
		count[index]--; //例子:同样的3 有2个，一个已经放好到排序数组中了，所以还有一个，count--; 
	} 
	for(int i=0;i<n;i++)
	{
		arr[i]=output[i];
	}
	
	

}

int main()
{
	int arr[] = {4, 2, 2, 8, 3, 3, 1};
    int n = sizeof(arr) / sizeof(arr[0]);
    print(arr, n);
    countSort(arr,n);
    print(arr, n);
    

}

希尔排序

需要注意的地方

1.arr[j+gap]=key; 这里是更新k
2. j从i-gap开始，i从gap开始循环（需要理解j和i代表的含义）

代码

# include<iostream>
using namespace std;

void shellSort(int *arr,int n)
{
	for(int gap=n/2;gap>0;gap/=2)
	{
		for(int i=gap;i<n;i++)
		{ 
			int key=arr[i];//i 代表要插入元素的下标 
			int j=i-gap;  //j代表要插入的前一个元素的下标 
			while(j>=0&&arr[j]>key)
			{
				arr[j+gap]=arr[j];
				j-=gap;
			}
			arr[j+gap]=key;
		}
	}
} 





void printArray(int arr[], int n) {
    for (int i = 0; i < n; i++) {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main()
{
	int arr[] = {12, 34, 54, 2, 3,9,8,20};
    int n = sizeof(arr) / sizeof(arr[0]);

    cout << "Original array: ";
    printArray(arr, n);

    shellSort(arr, n);

    cout << "Sorted array: ";
    printArray(arr, n);

    return 0;
	
}

桶排序

需要注意的地方

  1. vector<vector > buckets(cnt); 括号，不是中括号
  2. 要把元素放到桶里再排序，容易漏掉

代码

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

void print(vector<int> nums,int n)
{
	 for (vector<int>::iterator numIter = nums.begin(); numIter != nums.end(); ++numIter) {
        cout << *numIter << " ";
    }
    cout<<endl;
}

void bucketSort(vector<int> &num,int n)
{
	int max=num[0];
	int min=num[0];
	for(int i=0;i<n;i++)
	{
		if(max<num[i])
		{
			max=num[i];
		}
		if(min>num[i])
		{
			min=num[i];
		}
	}
	int size=(max-min)/n+1;//保证每个桶至少有一个元素
	int cnt= (max-min)/size+1;//保证至少有一个桶
	vector<vector <int> > buckets(cnt);//这里是括号 
	
	//将元素放到桶里
	for(int i=0;i<n;i++)
	{
		//(mn+size*i,mn+size*(i+1)) 
		int idx=(num[i]-min)/size;
		 buckets[idx].push_back(num[i]); //向末尾添加元素 
	
	} 
	
	for(int i=0;i<cnt;i++)
	{
		sort(buckets[i].begin(),buckets[i].end()); //桶内排序 
	}

	
	
}
int main()
{
	int arr[] = {19, 27, 35, 43, 31, 22, 54, 66, 78};
	int n=sizeof(arr)/sizeof(arr[0]);
	vector<int> nums(arr,arr+n);
	bucketSort(nums,n);
	print(nums, n);
	
	return 0;
}

基数排序

需要注意的地方

  1. 如果直接对nums全部进行除和取余操作，后续无法将原本的nums放入output数组里面
  2. 必须逆序对计数排序进行计算，不然无法得到正确结果
  3. (nums[i]/exp)%10和nums[i]一定要分清

代码

# include<iostream>
# include <vector>
# include<algorithm>
using namespace std;
void print(vector<int> &nums,int n)
{
	for(vector<int>::iterator numIter=nums.begin();numIter!=nums.end();numIter++)
	{//vector<int>::iterator numIter
	
		cout<<*numIter<<" ";
	}
	cout<<endl;
}
int getMax(vector<int> &nums,int n)
{
	int max=nums[0];
	for(int i=0;i<n;i++)
	{
		if(nums[i]>max)
		{
			max=nums[i];
		}
	}
	return max;
}


void countSort(vector<int> &nums,int n,int exp)
{
	cout<<"exp:"<<exp<<endl;
//	for(int i=0;i<n;i++)
//	{
//		nums[i]/=exp;
//		nums[i]%=10;
//	}
//	print(nums,n);
	

	int max=(nums[0]/exp)%10;
	int min=(nums[0]/exp)%10;
	for(int i=0;i<n;i++)
	{
		if(max<(nums[i]/exp)%10)
		{
			max=(nums[i]/exp)%10;
		}
		if(min>(nums[i]/exp)%10)
		{
			min=(nums[i]/exp)%10;
		}
	
		
	}
	cout<<"max"<<max<<"min"<<min<<endl;
		int length=max-min+1;
		vector<int> count(length, 0);
		for(int i=0;i<n;i++)
		{
			//count的下标表示的是与最小值的插值,count 数组表示的是有几个 
			int index=(nums[i]/exp)%10-min;
			count[index]++;
		}
		cout<<"计数数组"<<endl;
		print(count,length);
		for (int i = 1; i <length; i++) 
		{
        	count[i] += count[i - 1];
    	}
		
		cout<<"统计数组"<<endl;
		print(count,length);
		int output[n];
		for(int i=n-1;i>=0;i--)
		{
			int index=(nums[i]/exp)%10-min;
			int o_index=count[index]-1;
			output[o_index]=nums[i];
			count[index]--;
		}

		
		
		for(int i=0;i<n;i++)
		{
			nums[i]=output[i];
		}
		cout<<"sorted"<<endl;
		print(nums,n);

}
void radixSort(vector<int> &nums,int n)
{
	int max=getMax(nums,n);
	for(int exp=1;max/exp>0;exp*=10)
	{
		countSort(nums,n,exp);
	}
}


int main()
{
	int arr []={170, 45, 75, 90, 802, 24, 2, 66};
	int n=sizeof(arr)/sizeof(arr[0]);
    vector<int> nums(arr,arr+n);
    cout << "原始数组：" << endl;
    print(nums, n);
    radixSort(nums,n);
    cout << "排序后的数组：" << endl;
    print(nums, n);
    return 0;
}
码农10087号
关注
  • 10
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 数据结构与算法 排序算法
08-17
本文件将四大排序算法通过“「程序算法之排序」冒泡排序、插入排序、选择排序与快速排序”一文编写出,欢迎下载学习(文章链接:https://blog.csdn.net/Pomelo_ABC/article/details/126015013)
数据结构中常见的8种排序算法，超详细
06-26
常见的冒泡、插入、希尔、选择、堆排、快排、归并、计数排序 关于堆排中的向上调整算法、向下调整算法以及如何建堆（建大堆、建小堆） 快排的递归法、非递归法；递归法中又分三种方法，以及堆递归法的优化 归并排序...
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 446
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构小测试：排序算法
m0_63432840的博客
07-14 582
冒泡排序：将相邻元素之间的比较和交换，使得每一轮比较后，最大的元素能够到达数组的末尾。重复这个过程，直到整个数组有序。选择排序：在每一轮中，找到数组中最小的元素，并将其与当前轮的第一个元素交换位置。重复这一操作，使得每一轮过后，都有一个元素被放到了正确的位置上。插入排序：将数组分为已排序部分和未排序部分，每次从未排序部分取出一个元素，插入到已排序部分的正确位置上。希尔排序：首先确定一个间隔序列，按此间隔将数组元素分组并进行插入排序。随后逐渐缩小间隔并重复排序过程，直到间隔为1。
【C语言】深入解析快速排序
Easonmax的博客
07-15 748
快速排序（Quick Sort）是一种基于比较的排序算法。它通过选择一个“基准”元素（pivot），将数组分割成两部分：一部分元素小于基准元素，另一部分元素大于基准元素。然后，递归地对这两部分进行快速排序。快速排序的核心思想是分治法。
排序系列 之 插入排序
最新发布
oneouto的博客
07-18 163
整理了插入排序的思路
大根堆的实现和堆排序
2401_83010439的博客
07-15 667
/建一个大根堆return ans;//插入数据break;
Python算法实现之排序算法的Python实现详解
Rocky006的博客
07-18 578
排序算法是计算机科学中最基础和最重要的算法之一。它们在数据处理中起着关键作用，广泛应用于搜索、数据分析和优化等领域。本文将详细介绍几种常见的排序算法及其Python实现，包括冒泡排序、选择排序、插入排序、归并排序和快速排序，并通过具体示例代码展示它们的工作原理和性能比较。
快排的3种方式
2401_83010439的博客
07-15 546
/（前两种时间复杂度为o(n^2) , 最后一种为o(n*logn）//把一个数组以arr[R]划分，返回的是值为arr[R]的区间。//使数组中以arr[R]划分，返回循环后arr[R]的所在地。
算法014：找到字符串中所有字母异位词
m0_62319039的博客
07-14 452
算法014：找到字符串中所有字母异位词
LC53最大子数组和、lc5最长回文子串、lc283移动零
m0_47536537的博客
07-14 217
请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。连续子数组 [4,-1,2,1] 的和最大，为 6。移动到数组的末尾，同时保持非零元素的相对顺序。，必须在不复制数组的情况下原地对数组进行操作。"aba" 同样是符合题意的答案。是数组中的一个连续部分。，编写一个函数将所有。LC53最大子数组和。
代码随想录算法训练营第三十二天
weixin_44791877的博客
07-14 234
这道题自己思考ac出来了，主要是这道题需要使用二维的dp数组进行规划，由于动归是递推的，所以从结果向前思考，因此到右下角的方法只能由右下角这个格子或者左边这个格子走过来，因此右下角这个格子的方法数应该等于上一个格子的方法数加上左边这个格子的方法数。值得注意的是只有一行的或者一列的每个格子都只有1种方法，还有就是多行多列的边界格子也是只有一种方法，这个也是要初始化的。然后初始化边界的时候在障碍物之前的都初始化为1，障碍物以及障碍物之后的都初始化为0；首先几个特殊情况 当障碍物在起点或者终点的话直接返回0；
树与二叉树
2201_76027754的博客
07-15 776
树和二叉树
摩尔投票算法
qq_55846232的博客
07-14 476
摩尔投票算法的介绍以及相关例题的讲解
手撕七大排序(三)
Zbldx的博客
07-14 318
手撕七大排序 （三）
【C++】B3716分解质因子3 题解_素数筛法_欧拉筛+埃氏筛_算法竞赛
YLCHUP的博客
07-14 706
洛谷B3716题解，一道巧妙的质数筛法变形题，讲解得很详细，适合中等水平学习。快来看ヾ(•ω•`)o
【JavaScript 算法】哈希表：快速查找与存储
Allen-
07-15 782
哈希表（Hash Table）是一种非常高效的数据结构，用于实现快速的查找和存储操作。通过使用哈希函数将数据映射到数组中的某个位置，哈希表能够在常数时间内完成插入、删除和查找操作。
【算法/序列】等差数列&&子序列&&算术序列&&最长对称子串
island1314的博客
07-14 914
子序列：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。：是通过从原序列删除零个或多个元素并在不改变顺序的情况下排列其余元素而获得的序列。该题主要是求其满足等差性质的子数组个数，并且子数组在原数组的相对顺序不能变，并且。长度为3的子序列：（1，2，3）、（1，2，5）、（1，4，5）长度为1的子序列：（1）、（2）、（3）、（4）、（5）长度为2的子序列：长度为2的子序列都是算术子序列。：是数组中的一个连续序列。长度为4的子序列：0。长度为5的子序列：0。
力扣第七题——整数反转
m0_74932528的博客
07-15 406
/ 方法体这里定义了一个名为Solution的类，以及一个reverse方法，该方法接收一个整数x作为参数，并返回一个整数。
数据结构与算法：选择排序和堆排序解析
排序算法在实际应用中占据重要地位，如简单选择排序通过不断地选取最小元素并交换，逐步构建有序序列，而堆排序则利用了堆这种数据结构，能在O(n log n)的时间复杂度内完成排序。" 详细说明: 简单选择排序是一种...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值