插入算法
将所需排序的数一个个通过循环找到相应位置插入已排序好的数列中
*时间复杂度：*O（n^2）
#include<stdlib.h>
#include<stdio.h>
int main()
{
int i,j,a,key;
scanf("%d",&a);
int A[100];
for (i=0;i<a;i++)
scanf("%d",&A[i+1]);
for (j=2;j<=a;j++)
{
key=A[j];
i=j-1;
while(i>0&&A[i]>key)
{
A[i+1]=A[i];
i=i-1;
A[i+1]=key;
}
}
return 0;
}
归并排序
将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。若将两个有序表合并成一个有序表。
时间复杂度：O（nlog（n））
#include<stdio.h>
#include<math.h>
#include<string.h>
void MERGE(int*A,int left,int mid,int right)
{
int n1=mid-left+1;
int n2=right-mid;
int L[100],R[100];
int i,j,k;
for(i=1;i<=n1;i++)
L[i]=A[left+i-1];
for (j=1;j<=n2;j++)
R[j]=A[mid+j];
L[n1+1]=100000;
R[n2+1]=100000;
i=1;
j=1;
for (k=left;k<=right;k++)
{
if (L[i]<=R[j])
{
A[k]=L[i];
i++;
}
else{
A[k]=R[j];
j++;
}
}
return;
}
void MERGE_SORT(int*A,int left,int right)
{
int mid;
if(left<right)
{mid=(left+right)/2;
MERGE_SORT(A,left,mid);
MERGE_SORT(A,mid+1,right);
MERGE(A,left,mid,right);}
return;
}
int main()
{
int n,i,left,right;
int A[100];
scanf("%d",&n);
for(i=1;i<=n;i++)
{
scanf("%d",&A[i]);
}
printf("请输入要排序左右");
scanf("%d%d",&left,&right);
MERGE_SORT(A,left,right);
for(i=1;i<=n;i++)
printf("%d ",A[i]);
return 0;
}
分治算法
分治算法的基本思想是将一个规模为N的问题分解为K个规模较小的子问题，这些子问题相互独立且与原问题性质相同。求出子问题的解，就可得到原问题的解。
其实归并排序也是用到分治算法的思想，接下来的样例是求解一组数列中最大子数列，采用二分思想，分三类情况讨论：1：最大子数列在二分后的左边。2最大子数列在二分后的右边。3最大子数列在二分后跨越中介（由左半边一部分和右半边一部分构成）
时间复杂度：O（nlog（n））
#include <stdio.h>
#include <stdlib.h>
int main()
{
int i,n,low,high;
int A[100];
scanf("%d",&n);
for (i=1;i<=n;i++)
scanf("%d",&A[i]);
printf("请输入范围low，high\n");
scanf("%d%d",&low,&high);
printf("%d",find_max_subarray(A,low,high));
return 0;
}
int find_crossing_max_subarray(int *A,int low,int mid,int high)
{
int left=-1000000;
int sum=0;
int i,j;
for (i=mid;i>=low;i--)
{
sum+=A[i];
if (sum>left)
{
left=sum;
}
}
int right=-1000000;
sum=0;
for(j=mid+1;j<=high;j++)
{
sum+=A[j];
if (sum>right)
right=sum;
}
return (right+left);
}
int find_max_subarray(int *A,int low,int high)
{
int mid;
if (high==low)
return A[low];
else mid=(low+high)/2;
int leftans=find_max_subarray(A,low,mid);
int rightans=find_max_subarray(A,mid+1,high);
int crossans=find_crossing_max_subarray(A,low,mid,high);
if (leftans>=rightans&&leftans>=crossans)
return leftans;
else if(rightans>=leftans&&rightans>=crossans)
return rightans;
else return crossans;
}
堆排序
此代码有C++语言实现
堆这种数据结构首先是一种特殊的完全二叉树，且满足子节点值大于父节点点值的大或小。然后此堆排序使用最大堆，是先通过将数组创建为一个二叉树，保证每一个节点元素要比他的子节点元素要大，构成一个大顶堆。则该纾解点的根节点元素是所有元素中最大的元素。只要按照把根节点一次提取出来即可。
*时间复杂度：*O（nlog（n））
#include<iostream>
using namespace std;
void heapify(int A[],int n,int i)
{
int largest=i;
int l=2*i;
int r=2*i+1;
if (l<n&&A[l]>A[i])
largest=l;
if (r<n&&A[r]>A[i])
largest=r;
if (largest!=i)
{
swap(A[i],A[largest]);
heapify(A,n,largest);
}
}
void heapsort (int A[],int n)
{
for(int i=n/2;i>0;i--)
heapify(A,n,i);
for (int i=n;i>1;i--)
{
swap (A[1],A[i]);
heapify(A,i,1);
}
}
void printA(int A[],int n)
{
for(int i=n;i>0;i--)
cout<<A[i]<<" ";
cout<<endl;
}
int main()
{
int n;
int A[20];
cin>>n;
for (int i=1;i<=n;i++)
cin>>A[i];
heapsort(A,n);
printA(A,n);
return 0;
}
快速排序
快速排序其实也是用到了分治算法的思想，快速排序采用双向查找的策略，每一趟选择当前所有子序列中的一个数为界限，将子序列中比界限小的前移，比界限大的后移，当本趟所有子序列都按上述规则划分完毕后将会得到新的一组更短的子序列，他们将成为下趟划分的初始序列集。这里的程序使用的是快速排序的随机版本，所以是输入数据的划分是比较平均的*
*时间复杂度：最坏情况：O（n^2） 平均情况：O(nlog(n))
#include <iostream>
#include <cstdlib>
using namespace std;
int PARTITION (int A[],int l,int r)
{
int x=A[r];
int i=l-1;
for(int j=l;j<=r-1;j++)
{
if (A[j]<=x)
{
i++;
swap(A[i],A[j]);
}
}
swap(A[i+1],A[r]);
return i+1;
}
int RANDOMIZED_PARTITION (int A[],int l,int r)
{
int i=rand()%(r-l+1)+l;
swap(A[r],A[i]);
return PARTITION(A,l,r);
}
void RANDOMIZED_QUICKSORT (int A[],int l,int r)
{
if (l<r)
{
int q=RANDOMIZED_PARTITION(A,l,r);
RANDOMIZED_QUICKSORT(A,l,q-1);
RANDOMIZED_QUICKSORT(A,q+1,r);
}
}
void printA(int A[],int l,int r)
{
for(int i=l;i<=r;i++)
cout<<A[i]<<" ";
cout<<endl;
}
int main()
{
int n,l,r;
int A[20];
cin>>n;
for (int i=1;i<=n;i++)
cin>>A[i];
cout<<"请输入要排序的范围l r";
cin>>l>>r;
RANDOMIZED_QUICKSORT(A,l,r);
printA(A,l,r);
return 0;
}
计数排序
计数排序是用了一个缓存数组储存了数组A的信息，用下表表示A数组的值，C数组的的值表示个数，然后经过countsort函数中第一个for循环C的数值就表示对应A【i】比其小的数有多少个相当于位序然后再把它排列到B数组中
时间复杂度O（n）
#include <iostream>
#include <vector>
using namespace std;
void countsort(int A[],int B[],int k,int n)
{
int *C;
int j;
C=new int[k+1]{};
for (int i=1;i<=n;i++)
C[A[i]]=C[A[i]]+1;
for (j=1;j<=k;j++)
C[j]=C[j]+C[j-1];
for (j=n;j>=1;j--)
{
B[C[A[j]]]=A[j];
C[A[j]]--;
}
}
int main()
{
int n,i,k=-10000000000;
cin>>n;
int A[n+1];
for (i=1;i<=n;i++)
{
cin>>A[i];
if(A[i]>k)
k=A[i];
}
int B[n+1];
countsort(A,B,k,n);
for(i=1;i<=n;i++)
cout<<B[i]<<" ";
return 0;
}
基数排序
计数排序原理还是计数排序，只是多了位，通过低位到高位一位一位排序最终得到结果
时间复杂度：O (nlog®m)，其中r为所采取的基数，而m为堆数，在某些时候，基数排序法的效率高于其它的稳定性排序法
#include <iostream>
using namespace std;
void printA(int A[],int n)
{
for (int i = 0;i<n;i++)
{
cout << A[i] << " ";
}
cout << endl;
}
int maxbit(int data[],int n)
{
int b=1;
int x=10;
for(int i=0;i<n;i++)
{
while(data[i]>x)
{
x*=10;
b++;
}
}
return b;
}
void radixsort(int A[],int n)
{
int b=maxbit(A,n);
int T[n];
int C[10];
int i,j,k,radix=1;
for (i=1;i<=b;i++)
{
for (j=0;j<10;j++)
C[j]=0;
for (j=0;j<n;j++)
{
k=(A[j]/radix)%10;
C[k]++;
}
for (j=1;j<10;j++)
C[j]=C[j-1]+C[j];
for (j=n-1;j>=0;j--)
{
k=(A[j]/radix)%10;
T[C[k] - 1] = A[j];
C[k]--;
}
for (j=0;j<n;j++)
A[j]=T[j];
radix*=10;
}
}
int main()
{
int n;
cin>>n;
int A[n];
for (int i=0;i<n;i++)
cin>>A[i];
radixsort(A,n);
printA(A,n);
return 0;
}
桶排序
桶排序细节可以改很多原理和计数排序差不多不多解释
平均时间复杂度：O（n）
#include <iostream>
#include <vector>
using namespace std;
void bucketsort(int A[],int MAX,int n)
{
vector <int>B(MAX+1,0);
int i,j,count=1;
for (i=1;i<=n;i++)
B[A[i]]++;
for (i=0;i<=MAX;i++)
{
if(B[i]>0)
{
for(j=0;j<B[i];j++)
{
A[count]=i;
count++;
}
}
}
}
int main()
{
int n,i,MAX=-10000000000;
cin>>n;
int A[n+1];
for (i=1;i<=n;i++)
{
cin>>A[i];
if(A[i]>MAX)
MAX=A[i];
}
bucketsort(A,MAX,n);
for (i=1;i<=n;i++)
cout<<A[i]<<" ";
return 0;
}
期望时间为线性时间的选择算法
该代码作用如其标题很好理解，实现代码有用到快速排序的思想，目标输出给出数组中第i个大的数，
先在数组中随机拿出一个数A【q】作为界限分左右两堆，左边都小于他右边都大于他，然后他所在队列位置q与所需目标位置i比较确定第i个数就是他还是在左边或是右边，递归进行找到最后输出。
时间复杂度：O（n）
#include <iostream>
#include <cstdlib>
using namespace std;
int PARTITION (int A[],int l,int r)
{
int x=A[r];
int i=l-1;
for(int j=l;j<=r-1;j++)
{
if (A[j]<=x)
{
i++;
swap(A[i],A[j]);
}
}
swap(A[i+1],A[r]);
return i+1;
}
int RANDOMIZED_PARTITION (int A[],int l,int r)
{
int i=rand()%(r-l+1)+l;
swap(A[r],A[i]);
return PARTITION(A,l,r);
}
int select(int A[],int l,int r,int i)
{
if (l==r)
return A[l];
int q=RANDOMIZED_PARTITION(A,l,r);
int k=q-l+1;
if (i==k)
return A[q];
else if(i<k)
return select(A,l,q-1,i);
else return select(A,q+1,r,i-k);
}
int main()
{
int n,l,r,i;
cin>>n;
int A[n+1];
for (int i=1;i<=n;i++)
cin>>A[i];
cout<<"l r i";
cin>>l>>r>>i;
cout<<select(A,l,r,i);
return 0;
}
后续请看更新
134
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
