插入排序 希尔排序 冒泡排序 归并排序 快速排序 选择排序 计数排序 堆排序[C++代码]

理论篇链接↓↓↓
插入排序-希尔排序-选择排序-冒泡排序-快速排序-基数排序-外部排序-归并排序[数据结构与算法]

插入排序

• 简单说就三步 定位-》挤空-》插入
• 从无序序列中的选择第一个插入到有序序列
• 时间复杂度就是 最好0（n）最坏0（n^2）平均0（n ^ 2).空间复杂度0（1）
• 比较次数不固定 看代码就知道

# include<string.h>
# include<stdio.h>
#include <algorithm>
# include<vector>
# include<iostream>
using namespace std;

void straisort(vector<int>& vec )//对长度为n的序列
{
	int i,j;
	int temp;
	int n=vec.size();
	for(i=1;i<n;i++)//遍历无序
	{
		temp =vec[i];//保存无序序列的第一个
		j=i-1;//从后往前
		
		while(j >= 0 && temp<vec[j])//从有序找到第一个比temp小的（！）
		//举个例子 把 6 插入 123789，6是在9后面 
		{
		//如果比temp大的都后移
			vec[j+1]=vec[j];
			j--;//此时指向下一个待比较的元素（！）
		}
		vec[j+1]=temp;//(!)注意j+1
	}
}

int main(void)
{
	int a[]={ 2,5,1,5,3,7,5,7,5,6 };
	vector<int> test(a,a+sizeof(a)/sizeof(a[0]));
	straisort(test);
	for (int i = 0; i < 10; i++) {
		cout << test[i] << " ";
	}
	return 0;
}

• 2021-09-17：取出无序第一个插入到有序 for嵌套while实现

希尔排序

• 插入排序的改进，
• 宏观调整最后微观调整（逐步有序）
• i 和 i+step的比较，步长逐步减少到1

# include<string.h>
# include<stdio.h>
#include <algorithm>
# include<vector>
# include<iostream>
using namespace std;

void  shellsort(vector<int>& vec )//对长度为n的序列
{
	int step,i;
	int n= vec.size();//长度
	step = n/3+1;	//	设定步长
	for( step ; step>0 ;step--) //外层循环控制步长
	{
		for(i=0 ; i+step<n ;i++ )//内层循环移动两两元素进行比较
		{
			if(vec[i] > vec[i+step])
			{
				swap(vec[i],vec[i+step]);
			}
		}
	}
	
}

int main(void)
{
	int a[]={ 2,5,1,5,3,7,5,7,5,6 };
	vector<int> test(a,a+sizeof(a)/sizeof(a[0]));
	shellsort(test);
	for (int i = 0; i < 10; i++) {
		cout << test[i] << " ";
	}
	return 0;
}

• 2021-09-17复习：记住步长的设置 内层for
• 思想简单，就是一个逐步有序

冒泡排序

• 两两比较，每次把最大的移到后面，设置flat标志位 在最外层
• 比较次数固定，时间复杂度0（n ^ 2）

# include<string.h>
# include<stdio.h>
#include <algorithm>
# include<vector>
# include<iostream>
using namespace std;

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

}

int main(void)
{
	int a[] = { 2,5,1,5,3,7,5,7,5,6 };
	vector<int> test(a, a + sizeof(a) / sizeof(a[0]));
	bubble_sort(test);
	for (int i = 0; i < 10; i++) {
		cout << test[i] << " ";
	}
	return 0;
}

• 补充第二种写法，外循环决定趟数 内循环比较 每次少一个数

归并排序

• 标准的分治递归，和找众数一样标准四步

#include<iostream>
using namespace std;
#include<vector>
//用于暂时存放合并的元素的空数组,不过需要注意的是 需要初始化空间 越界访问会出错
vector <int> t(20); 


void merge_sort(int* a,int l,int r){
//第一步：终止条件 只有一个元素的时候
	if (l==r) return;  //递归出口
//第二步：处理当前层的逻辑 分成两个子序列
	int mid=(l+r)/2;
//第三步：进入下一层
	merge_sort(a,l,mid);
	merge_sort(a,mid+1,r);
//第四步 merge 汇总结果（排序比较 ）
	int i=l;
	int j=mid+1;
	for (int k=l; k<=r; k++)
	{ //合并
		//两种情况 右半部分已经全部放入了 j表示下一个待放入的元素超过了
		//第二种就是正常情况 左边的元素比右边的小并且在范围呢
		if ( (j>r) || (a[i]<=a[j] && i<=mid ) ) 
		{
			t[k]=a[i];
			i++;//指向下一个待比较的元素
		} else
		{
			t[k]=a[j];
			j++; 
		}
	}
	for (int k=l; k<=r; k++) a[k]=t[k]; //复制 边界是l和r
}

int main()
{
	int arr[] = { 2,8,23,10,4,1,6,7 };
	int L = 0;
	int R = 7;
	merge_sort(arr, L, R);

	for (int i = 0; i <= R; i++)
	{
		cout << arr[i] << endl;
	}

	return 0;
}

• 第二个版本 把数组作为参数传入 不再作为全局变量
• a[i]<=a[j] && i<=mid 容易写错

#include<iostream>
using namespace std;
#include<vector>
//用于暂时存放合并的元素的空数组,不过需要注意的是 需要初始化空间 越界访问会出错
/ector <int> t(20); 


void merge_sort(vector<int>& a,int l,int r,vector<int>& t)
{
//第一步：终止条件 只有一个元素的时候
	if (l==r) return;  //递归出口
//第二步：处理当前层的逻辑 分成两个子序列
	int mid=(l+r)/2;
//第三步：进入下一层
	merge_sort(a,l,mid,t);
	merge_sort(a,mid+1,r,t);
//第四步 merge 汇总结果（排序比较 ）
	int i=l;
	int j=mid+1;
	for (int k=l; k<=r; k++)
	{ //合并
		//两种情况 右半部分已经全部放入了 j表示下一个待放入的元素超过了
		//第二种就是正常情况 左边的元素比右边的小并且在范围呢
		if ( (j>r) || (a[i]<=a[j] && i<=mid ) ) 
		{
			t[k]=a[i];
			i++;//指向下一个待比较的元素
		} else
		{
			t[k]=a[j];
			j++; 
		}
	}
	for (k=l; k<=r; k++) a[k]=t[k]; //复制 边界是l和r
}

int main()
{
	int arr[] = { 2,8,23,10,4,1,6,7 };
	vector<int> arr_new(arr,arr+sizeof(arr)/sizeof(arr[0]));
	int L = 0;
	int R = 7;
	
	vector <int> t(arr_new.size()); 

	merge_sort(arr_new, L, R , t);

	for (int i = 0; i <= R; i++)
	{
		cout << arr_new[i] << endl;
	}

	return 0;
}

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


//先序分开 + 后序 汇总
void merge_sort(int* a, int l, int r)
{
	//递归终止条件
	if (l == r) return;
	// 先序逻辑处理
	int mid = (l + r) / 2;
	//进入下一层
	merge_sort(a, l, mid);
	merge_sort(a, mid + 1, r);
	//后续 结果汇总
	int i = l;
	int j = mid + 1;
	vector<int> vec;
	for (int k = l; k <= r; k++)
	{
		//放入左边 第一种情况 右边全都放入了 第二种在范围内 小于
		if ((j > r) || a[i] <= a[j] && i <= mid)
		{
			vec.push_back(a[i]);
			//t[k] = a[i];
			i++;
		}
		else//放入右边
		{
			vec.push_back(a[j]);
			//t[k] = a[j];
			j++;
		}
	}
	int n = 0;
	for (int k = l; k <= r; k++) a[k] = vec[n++];
	


}

• 补充了第三种写法，没什么大的区别 小的修改，归并是先序+后序，在后序处理需要定义 i j k 三个变量。for循环内进行判断，只有两种情况 放入左边数据 还是放入 右边的数据 。不要忘记终止条件

快速排序

• 一个就是while嵌套的判断也要加上i<j
• 第二个就是 s[i]=s[j];忘记i++ 要记得移到下一个判断点，或者理解成被填入的位置前进
• 第三个就是 s[i] = x; 最后要把枢纽放入i下标
• 第四个就是 quickSort(s, i + 1, r); 不是（s,i,r）
• 第五从右边判断开始 因为第一个需要填入的是左边
• 不要忘记 if （i<j）因为要确保不是因为越界才跳出循环 确保是因为找到第一个符合的值（补充）

#include<iostream>
using namespace std;
void quickSort(int s[], int l, int r)
{
	//终止条件
	if (l>= r) //元素个素只有一个
	{
		return;
	}
	//处理当前层的逻辑
	int i = l, j = r, x = s[l];//枢纽
	while (i < j)//注意是从右边开始 因为我们是取左边第一个为枢纽 那个值可以填入
	{
		while(i < j && s[j]>= x) // 从右向左找第一个小于x的数
		j--;//下一个待比较的值 
		if(i < j && s[j]<x ) //右边第一个小于枢纽的值 填入到 当前i的位置
		{
			s[i]=s[j];
			i++;//i值被覆盖了 指向下一个待比较的数字
		}
		while(i < j && s[i]< x) // 从左向右找第一个大于等于x的数
			i++; 
		if(i < j)
		{
			s[j]=s[i];
			j--;//指向下一个待比较的数字
		}
		
	}
	s[i] = x;
	//进入下一层
	quickSort(s, l, i - 1); // 递归调用
	quickSort(s, i + 1, r);
	
}


int main()
{
	int array[]={34,65,12,43,67,5,78,10,3,70},k;
	int len=sizeof(array)/sizeof(array[0]);
	cout<<"The orginal arrayare:"<<endl;
	for(k=0;k<len;k++)
		cout<<array[k]<<",";
	cout<<endl;
	quickSort(array,0,len-1);
	cout<<"The sorted arrayare:"<<endl;
	for(k=0;k<len;k++)
		cout<<array[k]<<",";
	cout<<endl;
	system("pause");
	return 0;
}

• 2021-09-17 其实就是思考一个序列怎么分成两个部分 挖出一个空，保存值为 x ，再加上两个指针 i 和 j

选择排序

• 就是每次选择最小的
• 时间复杂度0（n ^ 2），比较的个数是固定的
• 需要注意的一个临时变量存放最小值坐标
• 每一趟的初始最小值 和 实际最小值

# include<string.h>
# include<stdio.h>
# include<vector>
# include<iostream>
using namespace std;

void  selectsort(vector<int>& vec )//对长度为n的序列
{
	int i,j,k;
	//int temp;
	int n=vec.size();
	for(i = 0;i<n;i++)
	{
		k = i; //每次把第一个当作最小值坐标
		for(j = i+1;j<n;j++)//内层循环控制后面的无序序列
		{
			if(vec[k]>vec[j])//如果出现比最小值小的 修改最小值坐标
			{
				k = j;
			}
		}
		if(k != i)//如果最小值坐标变化了 更换实际最小值和这趟的初始最小值
		{
			/*
			temp = select[i];
			select[i] = select[min];
			select[min] = temp;
			*/
			swap(vec[k],vec[i]);
		}
	}
	
}

int main(void)
{
	int a[]={ 2,5,1,5,3,7,5,7,5,6 };
	vector<int> test(a,a+sizeof(a)/sizeof(a[0]));
	selectsort(test);
	for (int i = 0; i < 10; i++) {
		cout << test[i] << " ";
	}
	return 0;
}

计数排序

• 这个比较简单，就不放在这边了
• 构建一个数组，下标表示数值，元素表示频率，第一次循环放入构建的数组
• 第二次循环遍历输出，频率–

堆排序

• 大堆顶 根结点是最大值 的堆，用于维护和查询 max、
• 第 i 个结点的 父结点 下标 为 （i-1）/2 ;
• 第 i 个结点的 左子结点 下标 为 2i+1 ;
• 第 i 个结点的 右子结点 下标 为 2i+2 ;
• 最后一个非叶子结点 下标为：n/2 -1（也可以理解成 最后一个节点坐标是 n-1 带入第一个公式 就是 （n-2）/2）
• 思想就是： 将一个长为n的序列构造成一个大顶堆，则整个序列的最大值就是堆顶的根结点。 将最大值结点与末尾结点的值互换，此时末尾结点的值就是最大值。(即数组的最后一个元素为最大值) 。然后将剩余的 n-1个序列重新构造成一个大顶堆，再将n-1序列的最大值与末尾结点的值互换，就会得到 次最大值。 如此重复执行，就可以得到一个有序序列了。
• 局部调整向下，从后向前建立（右下）

#include<iostream>
#include <algorithm>
using namespace std;
//调整的函数
//需要传入的参数
// 1数组 
// 2数组的调整的长度（最大下标+1）
// 3调整的起始点（下标）
 
void heapify(int* tree, int n, int i)
{
	if (i >= n) return;
	//左子结点
	int c1 = i * 2 + 1;
	//右子结点
	int c2 = i * 2 + 2;
	//假设最大值坐标是根结点，获取左右子结点的最大值
	int max = i;
	if (c1<n && tree[c1]>tree[max])
	{
		max = c1;
	}
	if (c2<n && tree[c2]>tree[max])
	{
		max = c2;
	}
	if (max != i)
	{
		//将左右子树的最大值赋给父结点
		swap(tree[max],tree[i]);
		//较小的值，被赋给左子树或右子树，则左子树或右子树 需要重新建堆 
		heapify(tree,n,max);
	}
 
}
 
void build_heap(int *tree, int n)
{
	int last_node = n - 1;
	//最后一个结点的父节点 下标，即最后一个非叶子结点
	int parent = (last_node - 1) / 2;
	
	//针对最后一个父节点的 及其前面的父节点进行建堆
	for (int i =parent; i>=0; i--)
	{
		heapify(tree,n,i);
	}
}
 

// 实现整体排序
void heap_sort(int *tree, int n)
{
	//建立一个堆 从后向前建立
	build_heap(tree,n);
	
	//循环不断把最大值放在最后 并且对第一个值进行局部调整
	for (int i = n-1; i>=0; i--)
	{
		//堆顶与末尾结点值交换
		swap(tree[i], tree[0]);
		//每次把第一个移到最后 最后一个移上来 然后进行局部调整
		heapify(tree,i,0);//注意这边的i 放入i的下标 剩余i个元素
	}
}
 
int main()
{
	int tree[] = { 7,10,15,30,35,23,40 };
	int n = 7;
	heap_sort(tree,n);
 
	for (int i=0;i<n;i++)
	{
		cout << tree[i]<<" ";
	}
	cout<< endl;
 
	return 0;
}

• 参考链接