目录
8638 直接插入排序
8639 折半插入排序
8640 希尔(shell)排序
#include <iostream>
using namespace std;
int a[1000];
int n;
void print()
{
for(int i=1 ; i<=n ; i++)
{
cout<<a[i]<<' ';
}
cout<<endl;
}
void ShellInsert(int dk)
{
for(int i=1+dk ; i<=n ; i++)
{
if(a[i-dk]>a[i])
{
int j;
a[0]=a[i]; //后移的时候会覆盖元素,所以要先记录,最后达到交换位置的目的
for(j=i ; j>0&&a[0]<a[j-dk] ; j-=dk)
a[j]=a[j-dk];
a[j]=a[0];
}
print(); //直接插入排序
}
// print(); //希尔排序
}
void ShellSort(int n)
{
// int d=n/2; //希尔排序
// while(d>=1)
// {
// ShellInsert(d);
// d/=2;
// }
//
ShellInsert(1); //直接插入排序
}
int main()
{
cin>>n;
for(int i=1 ; i<=n ; i++)
cin>>a[i];
ShellSort(n);
return 0;
}
8642 快速排序
#include <iostream>
#include <algorithm>
using namespace std;
int a[1000];
int n;
void print()
{
for(int i=1 ; i<=n ; i++)
{
cout<<a[i]<<' ';
}
cout<<endl;
}
int Partition(int a[],int low,int high)
{
a[0]=a[low];
while(low<high)
{
while(low<high&&a[high]>=a[0]) high--;
a[low]=a[high];
while(low<high&&a[low]<=a[0]) low++;
a[high]=a[low];
}
a[low]=a[0]; //枢轴来到真正属于他的位置
print();
return low;
}
void QSort(int a[],int low,int high)
{
if(low<high) /**记得加这个条件,否则将无限递归*/
{
int pivotloc=Partition(a,low,high);
QSort(a,low,pivotloc-1);
QSort(a,pivotloc+1,high);
}
}
int main()
{
cin>>n;
for(int i=1 ; i<=n ; i++)
cin>>a[i];
QSort(a,1,n);
return 0;
}
8644 堆排序
#include <iostream>
#include <algorithm>
using namespace std;
int a[100];
int n;
void print()
{
for(int i=1 ; i<=n ; i++)
{
cout<<a[i]<<' ';
}
cout<<endl;
}
void HeadAdjust(int a[],int k,int len)
{
a[0]=a[k]; //记录根 ,这里的根不是整棵树的根,而是相当于父节点(某棵子树的根)
for(int i=2*k ; i<=len ; i*=2) /*找根的孩子*/ /**开始的几次调整只会进行一次循环,因为k比较大,注意外层函数BuildHeap也有一层循环*/
{
if(i<len&&a[i]<a[i+1]) //左孩子<右孩子 ,i<len是因为i+1==len(刚好是最后一个元素)可能会成立 ,即最后一个非叶子节点必须要有右孩子才进入这个if
i++; //记住较大的孩子的下标
if(a[0]>=a[i]) //这里是a[0]而不是a[k],a[k]可能会指向比a[0]更大的元素,最后要找的是能放a[0]的位置,进行这步的前提是:下方已经没有比最先记录的小元素(上文记录的根)更小的了,也就是说,下方本来就已经是堆-->所以最开始建立大顶堆时要自下而上全部调整
break;
else //开始自上而下 ,小元素在多次该循环中持续下坠
{
a[k]=a[i]; //把大孩子拉上来
k=i; //聚焦到大孩子走后空缺的位置:为了后续的循环-->继续向下看该树
}
}
a[k]=a[0]; //小元素(上文记录的根)放入最终位置
}
void BuildMaxHeap(int a[],int len)
{
for(int i=len/2 ; i>0 ; i--) //自下而上,每个非叶子节点必须都要遍历到
HeadAdjust(a,i,len);
}
void HeapSort(int a[],int len)
{
BuildMaxHeap(a,len);
print();
for(int i=len ; i>1 ; i--) //0号位用作temp暂存数据,1号位才是顶部
/*i>1是因为(1)下面有个i-1,i-1==0会访问到0号位元素,
(2)最后一次堆排序把小元素降下来后就已经是有序的了,(联想冒泡排序的最后一次排序,总趟数只要len-1趟)*/
{
swap(a[i],a[1]); //找到了堆顶元素(最大值),堆顶堆底互换位置
HeadAdjust(a,1,i-1); //剩余元素重新调整为堆,末尾元素已完成排序,len-1
//除堆顶的树外,其余的树都已是堆,不用再次自下而上调整,而是直接自上而下
print();
}
}
int main()
{
cin>>n;
for(int i=1 ; i<=n ; i++)
{
cin>>a[i];
}
HeapSort(a,n);
return 0;
}
8645 归并排序(非递归算法)
#define _CRT_SECURE_NO_WARNINGS
#include<cstdio>
#include<iostream>
#include<vector>
#include<string.h>
#include<algorithm>
#include<queue>
using namespace std;
//归并两个部分 bg为第一部分的起点 mid为第二部分的起点 end为第二部分边界的下一位
void Merge(int num[], int bg, int mid, int end)
{
//建立临时数组存两个部分的合并后的数组
int* tmp = new int[end - bg];
int i = bg, j = mid;
int k = 0;
//比较两部分 当i=mid 或j=end 退出
while (i < mid && j < end)
{
//由大小依次排序放到临时数组里 直到一个部分排完退出
if (num[i] > num[j])
{
tmp[k++] = num[j++];
}
else
{
tmp[k++] = num[i++];
}
}
//如果前半部分没存完 依次存进去
while (i < mid)
{
tmp[k++] = num[i++];
}
//如果后半部分没存完 依次存进去
while (j < end)
{
tmp[k++] = num[j++];
}
//把排好的临时数组存到num数组对应下标里 别忘了这一步,否则将重复print原数组!!!!
for (int i = 0; i < k; i++)
{
num[bg++] = tmp[i];
}
}
int main(void)
{
ios::sync_with_stdio(0), cin.tie(0);
int n;
cin >> n;
int* num = new int[n + 1];
for (int i = 1; i <= n; i++) cin >> num[i];
//width为一部分的长度 依次为1 2 4 8 外层判断条件不能写width<=n 取等可能会重复输出一次
for (int width = 1; width < n; width *= 2)
{
// 第一部分起点bg为1 下一次为 bg+两个长度
for (int bg = 1; bg <= n; bg += width * 2)
{
//mid为第二部分的起点
int mid = bg + width;
//为了防止访问错误 如果mid边界大于 n则最大为 n+1
if (mid > n)mid = n + 1;
//end为第二部分边界的下一位
int end = bg + width * 2;
//同理 最大只能为 n+1
if (end > n)end = n + 1;
//合并两部分
Merge(num, bg, mid, end);
}
//检查
for (int i = 1; i <= n; i++) cout << num[i] << ' ';
cout << endl;
}
return 0;
}