数据结构八大排序算法C/C++语言实现

数据结构九大排序算法C/C++语言实现

第一个算法：冒泡排序

核心思想：一个个对比，每一趟能把最大的一个归位。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
辅助空间：O（1）
稳定性 ：好

#include 
#include 
using namespace std;
//预定义函数
void Bubble_swap(int a[],int i,int j);
void BubbleSort(int a[],int n);
void display(int a[],int n);
int main()
{
    int a[10]={10,9,8,7,6,5,4,3,2,1};
    BubbleSort(a,10);   //冒泡排序
    display(a,10);      //展示一个数组的指定个元素
    return 0;
}
//交换一个数组中指定两个位置的元素
void Bubble_swap(int a[],int i,int j)
{
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}
//冒泡排序核心程序
void BubbleSort(int a[],int n)
{
    int i,j,flag=1,coun=0;
    for(i=0;i<n-1;i++)
    {
        for(j=0;j<n-i-1&&flag;j++)
        {
            flag=0;
            if(a[j]>a[j+1])
            {
                Bubble_swap(a,j,j+1);
                flag=1;
                coun++;
            }
        }
    }
    printf("交换了%d次\n",coun);
}
//展示
void display(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
}

咱们可以看到结果如下：

第二个算法：直接插入排序

核心思想：把要排序的数据看成有序段和无序段，有序段从第一个数字开始，然后后面的无序段看成一个个来往有序段插入，这就是直接插入排序名字的由来。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
辅助空间：O（1）
稳定性 ：好

#include 
#include 
#include 
using namespace std;
//预定义函数
void insert_sort(int a[],int n);
void display(int a[],int n);
int main()
{
    int a[10]={10,9,8,7,6,5,4,3,2,1};
    insert_sort(a,10);   //冒泡排序
    display(a,10);      //展示一个数组的指定个元素
    return 0;
}
//直接插入排序核心程序
void insert_sort(int a[],int n)
{
    int i,j,k;
    for(i=1;i<n;i++)
    {
        for(j=i-1;j>=0;j--)
        {
            if(a[i]<a[j])
        	{
	            int temp=a[i];
	            for(k=i-1;k>j;k--) a[k+1]=a[k]; //把比要排序的数字后移一位
	            a[k+1]=temp;
        	}
        }
    }
}
//展示
void display(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
}

第三个算法：折半插入排序

核心思想：这个排序算法其实和直接插入排序没啥太大的区别，主要是对比关键字上采用了折半查找。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
辅助空间：O（1）
稳定性 ：好

#include 
#include 
#include 
using namespace std;
//预定义函数
void Binsert_sort(int a[],int n);
void display(int a[],int n);
int main()
{
    int a[10]={1,2,3,5,4,6,7,8,9,10};
    Binsert_sort(a,10);   //冒泡排序
    display(a,10);      //展示一个数组的指定个元素
    return 0;
}
//折半直接插入排序核心程序
void Binsert_sort(int a[],int n)
{
    int i,k;
    for(i=1;i<n;i++)
    {
        int low=0,high=i-1;
        while(low<=high)    //找到合适的位置,循环结束之时,high+1的位置就是应该放的位置，这里我不多赘述
        {
            int mid=(low+high)/2;
            a[i]>a[mid]?low=mid+1:high=mid-1;
        }
        int temp=a[i];
        for(k=i-1;k>high;k--) a[k+1]=a[k]; //把比要排序的数字后移一位
        a[k+1]=temp;
    }
}
//展示
void display(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
}

第四个算法：希尔排序

核心思想：分组插入，将整个带排序的序列分割成几个小组，从而减少了参与排序的数据量，然后对每一组进行直接插入排序，然后再增加每组的数据量，重新分组。几次循环之后，序列就是基本有序，此时再对整个序列进行直接插入排序，就可以减少对比次数，很快的得到有序序列。
平均时间复杂度：O(n^1.3)
最坏时间复杂度：O(n^1.3)
辅助空间：O（1）
稳定性 ： 不稳定

#include 
#include 
#include 
using namespace std;
//预定义函数
void insert_sort(int a[],int n);
void display(int a[],int n);
int main()
{
    int a[10]={1,2,3,5,4,6,7,8,9,10};
    insert_sort(a,10);   //冒泡排序
    display(a,10);      //展示一个数组的指定个元素
    return 0;
}
//希尔排序核心程序
void insert_sort(int a[],int n)
{
    int i,j,temp;
    int gap=n;
    do
    {
        gap=gap/3+1;
        for(i=gap;i<n;i++)
        {
            if(a[i]<a[i-gap])
            {
                temp=a[i];
                for(j=i-gap;a[j]>temp;j-=gap) a[j+gap]=a[j];
                a[j+gap]=temp;
            }
        }
    }while(gap>1);
}
//展示
void display(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
}

第五个算法：堆排序

核心思想：利用完全二叉树结构来排序，把数组排成一个大顶堆或者是小顶堆结构，然后把最大的取出来放在数组的最后面，接着对剩下的继续构建大顶堆或者是小顶堆，不断循环，直到把无序序列变成有序序列。
平均时间复杂度：O(nlog2n)
最坏时间复杂度：O(nlog2n)
辅助空间：O（1）
稳定性 ： 不稳定

#include 
#include 
using namespace std;
void swapp(int a[],int i,int j)   //交换数组内的两个数字
{
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}
void heapify(int a[],int n,int i)         //大顶堆构成三角，
{
    if(i>=n) return ;                      //递归出口
    int c1=2*i+1;                          //找到左儿子
    int c2=2*i+2;                          //找到右儿子
    int m=i;
    if(c1<n&&a[c1]>a[m]) m=c1;             //最大的放在头
    if(c2<n&&a[c2]>a[m]) m=c2;
    if(m!=i)
    {
        swapp(a,m,i);                       //交换
        heapify(a,n,m);                     //接着换
    }
}
void build_heap(int a[],int n)
{
    int last=n-1;
    int parent=(last-1)/2;
    int i;
    for(i=parent;i>=0;i--) heapify(a,n,i);
}
void display(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
}
void heap_sort(int a[],int n)
{
    build_heap(a,n);
    int i;
    for(i=n-1;i>=0;i--)
    {
        swapp(a,i,0);
        heapify(a,i,0);
    }
}
int main()
{
    int a[100];
    int n;
    cin>>n;
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    heap_sort(a,n);
    display(a,n);
    return 0;
}

第六个算法：简单选择排序

核心思想：从头开始，每一次都选出最小的往前排，这样就可以从小到大了。
平均时间复杂度：O(n^2)
最坏时间复杂度：O(n^2)
辅助空间：O（1）
稳定性 ： 稳定的

#include 
#include 
#include 
#include 
void display(int a[],int n)
{
    for(int i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
}
void swap(int a[],int i,int j)
{
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}
void simple(int a[],int n)
{
    int min,i,j,k;
    for(i=0;i<n-1;i++)
    {
        min=a[i];
        k=i;
        for(j=i;j<n;j++)
        {
            if(min>a[j])
            {
                k=j;
                min=a[j];
            }
        }
        if(k!=i) swap(a,i,k);
        display(a,n);
    }
}

using namespace std;

int main()
{
    //freopen("1.0.txt","r",stdin);
    int n;
    int a[100];
    cin>>n;
    for(int i=0;i<n;i++)
    {
        scanf("%d",&a[i]);
    }
    simple(a,n);
    return 0;
}

第七个算法：归并算法

核心思想：把一组数据划分为一组组数据，然后对比合并，有数组实现是递归实现。在此我提供递归算法。
平均时间复杂度：O(nlog2n)
最坏时间复杂度：O(nlog2n)
辅助空间：O（1）
稳定性 ： 稳定的

#include 
#include 
#include 
#define MAXSIZE 10
using namespace std;
//归并排序的递归算法实现方式
void mering(int [],int,int [],int);
void megorder(int k[],int n)
{
    if(n>1)
    {
        int *left=k;
        int left_length=n/2;
        int *right=k+n/2;
        int right_length=n-left_length;
        //继续分
        megorder(left,left_length);
        megorder(right,right_length);
        //合并两个数组并且排序
        mering(left,left_length,right,right_length);
    }
}

void mering(int *a,int i,int *b,int j)
{
    //合并两个数组
    int x=0,y=0,k=0,m;
    int temp[MAXSIZE];
    while(x<i&&y<j)
    {
        a[x]>b[y]?temp[k++]=b[y++]:temp[k++]=a[x++];
    }
    while(x<i) temp[k++]=a[x++];
    while(y<j) temp[k++]=b[y++];
    //再把新数组的值放在A上
    for(m=0;m<(i+j);m++)
    {
        a[m]=temp[m];
        //printf("a-> %d\n",a[m]);
    }
}

int main()
{
    int a[]={10,9,8,7,6,5,4,3,2,1};
    megorder(a,10);
    for(int i=0;i<10;i++)
    {
        printf("%d ",a[i]);
    }
}

第八个算法：快速排序算法

核心思想：找到一个基准点，然后开始从两边寻找，从右边找到一个比基准点小的数，然后让它与基准点交换，从左边找到一个比基准点大的数，让他与基准点交换。在这过程中，基准点的位置不断变化，但是他的值和最后的位置是确定的，最后的位置一定是low=high=基准点的时候。
平均时间复杂度：O(nlog2n)
最坏时间复杂度：O(n^2)
辅助空间：O（1）
稳定性 ： 不稳定的

#include 
#include 
using namespace std;
void display(int a[],int n);               //展示数组元素
void quicksort(int a[],int low,int high,int n);  //快速排序
int part(int a[],int low,int high,int n);     //找到轴
void swapp(int a[],int i,int j)       //交换
{
    int temp=a[i];
    a[i]=a[j];
    a[j]=temp;
}
int main()
{
    int a[100],n;
    scanf("%d",&n);
    for(int i=0;i<n;i++) scanf("%d",&a[i]);
    quicksort(a,0,n-1,n);
    return 0;
}
void quicksort(int a[],int low,int high,int n)
{
    int point;
    if(low<high)           //递归出口
    {
        point=part(a,low,high,n);
        quicksort(a,low,point-1,n);
        quicksort(a,point+1,high,n);
    }
}

int part(int a[],int low,int high,int n)
{
    int point;
    point=a[low];
    while(low<high)         //当跳出循环之时，就是low等于high的时候
    {
        while(low<high&&a[high]>=point) high--;
        swapp(a,low,high);
        while(low<high&&a[low]<=point) low++;
        swapp(a,low,high);
    }
    display(a,n);
    return low;
}

void display(int a[],int n)
{
    int i;
    for(i=0;i<n;i++)
    {
        printf("%d ",a[i]);
    }
    printf("\n");
}

有错误之处还望指出。O(∩_∩)O谢谢