C语言----常用排序方法

C语言----常用排序方法

1.选择排序

int selectsort(int arr[],int n)
{
    for(int i=0;i<n;i++)
    {
        int k=i;
        for(int j=i+1;j<=n;j++)
        {
            if(arr[j]<arr[k])
            {
                k=j;
            }
        }
        if(i!=k)
        {
            int tmp=arr[i];
            arr[i]=a[k];
            a[k]=tmp;
        }
    }
}

选择排序就是通过n-i次大小的比较，找出最小的，并和第i个数交换。

从n个数中选出最小的与第一个数交换，再从n-1个数中选最小的数与第二个数交换

2.插入排序

int insertsort(int arr[],int n)
{
    int i,j,x;
    for(i=1;i<n;i++)
    {
        x=arr[i];
        j=i-1;
        while((j>=0)&&(arr[j]>x))
        {
            arr[j+1]=arr[j];
            j--;
        }
        arr[j+1]=x;
    }
}

插入排序就是将无序的元素插入到有序数组中，将整个数组变为有序，

设第一个元素为一个有序数组，从第二个数开始插入到数组里。

3.希尔排序

int shellsort(int arr[],int n)
{
    int m=4;
    while(m>=1)
    {
        for(int i=m;i<n;i++)
        {
            for(int j=i;j>=m&&arr[j]<arr[j-1];j-=m)
            {
                int tmp=arr[j];
                arr[j]=arr[j-m];
                arr[j-m]=tmp;
            }
        }
        m/=2;
    }
}

希尔排序是一种更高效的插入排序算法，希尔排序减少了移动元素和比较元素的次数，

希尔排序是定义一个间隔x,将间隔为x的数作为一个数组，对组内元素进行插入排序，然后缩小x重复该操作，直到x=1。

4.快速排序

int quicksort(int arr[],int left,int right)
{
    if(left>=right)
    {
        return;
    }
    int i=left;
    int j=right;
    int x=arr[i];
    while(i<j)
    {
        while(i<j&&arr[j]>=x)
        {
            j--;
        }
        arr[i]=arr[j];
        while(i<j&&arr[i]<=x)
        {
            i++;
        }
        arr[j]=arr[i];
    }
    arr[i]=x;
    quicksort(arr,left,i-1);
    quicksort(arr,i+1,right);
}

快速排序就是找到一个值x,将数列分为两部分，小于x的放在左边，大于x的放在右边，继续对这两部分进行该操作，知道每个元素都自成一部分。

5.冒泡排序

int bubblesort(int arr[],int n)
{
    int i,j;
    for(i=0;i<n;i++)
    {
        for(j=0;j<n-i;j++)
        {
            if(arr[j]>arr[j+1])
            {
                int tmp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=tmp;
            }
        }
    }
}

冒泡排序就是将要排序的数据从上至下排列，对每一组相邻的元素进行比较，若第一个数比第二个数大，则交换这两个数的位置，两两进行比较，直到数据的最后一对，重复n轮此操作，每轮结束后的最后一个元素不用参与下一轮的比较。