几种常用的排序算法小结

一、关于排序算法

排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。

常见的内部排序算法有：插入排序、选择排序、冒泡排序、归并排序、快速排序、计数排序、鸡尾酒排序等。

1、插入排序

void insertsort(int arr[],int len)
{
    for(int i=0;i<len-1;i++)
    {
        int num=arr[i+1];
        int j=0;
        for(j=i;j>=0;j--)
        {
            if(arr[j+1]<arr[j])
            {
                int temp=arr[j];
                arr[j]=arr[j+1];
                arr[j+1]=temp;
            }
            else
            {
                break;
            }
        }

2、快速排序

void quicksort(int arr[],int low,int high)
{
    if(low>=high)
    {
        return;
    }
    int first=low;
    int last=high;
    int key=arr[first];
    while(first<last)
    {
        while(first<last&&arr[last]>=key)
        {
            last--;
        }
        arr[first]=arr[last];
        while(first<last&&arr[first]<=key)
        {
            first++;

        
        }
        arr[last]=arr[first];
    }
    arr[first]=key;
    quicksort(arr,low,first-1);
    quicksort(arr,first+1,high);

}

        arr[j+1]=num;

    }
}

3、冒泡排序

#define swap(a,b) {a+=b;b=a-b;a=a-b;}
 
void bubble_sort(int arr[],int len)
{
    for (int i = 0; i < len-1; i++) //只需要循环len-1次 每循环一次 最值都会放入到最后面
    {
        bool flag = false;
        for (int j = 0; j <= len-i-1; j++)
        {
            if (arr[j] < arr[j+1])
            {
                swap(arr[j],arr[j+1]);
                flag = true;
            }
        }
        if(flag == false)  break;
    }
}

4、鸡尾酒排序

void cooktail_sort(int arr[],int len)
{
    
    for (int i = 0; i < len/2; i++)
    {
        int p_min = i;
        int p_max = i;
        for (int j = i; j <= len-i-1 ; j++)//每次遍历的区间[i,len-i-1]  p_min，p_max不能超过这个区间
        {
             if(arr[j]<arr[p_min]) p_min = j;
             if(arr[j]>arr[p_max]) p_max = j;
        }
        if (p_min != i)
        {
            swap(arr[p_min],arr[i]);
            if (p_max == i)
            {
                p_max = p_min;
            }
        }        
        if (p_max != len-i-1)
        {
            swap(arr[p_max],arr[len-i-1]);//此宏定义函数与冒泡中的一致
        }
    }
}

5、归并排序

//一个数组 以mid为分界线 左右都是有序的 将左右两部分合并有序
void mergearr(int arr[],int left,int mid,int right)
{
    int len = mid-left+1;
    int* p = malloc(sizeof(int)*len);
    int i=0;
    while(i<len)
    {
        p[i++] = arr[left+i];
    }
    i = 0;
    int j = mid+1;
    int k = left;
    while(i<=mid && j<=right)
    {
        if (p[i]<arr[j])
        {
            arr[k++] = p[i++];
        }
        else
        {
            arr[k++] = arr[j++];
        }
    }
 
    while(i<=mid)
    {
        arr[k++] = p[i++];
    }
 
}
 
void merge(int arr[],int left,int right)
{
    if (right <= left)
    {
        return;
    }
    int mid = (left + right)/2;
    merge(arr,left,mid);
    merge(arr,mid+1,right);
    mergeArr(arr,left,mid,right);
}
 
void mergesort(int arr[],int len)
{
    merge(arr,0,len-1);
}

6、选择排序

void select_sort(int arr[],int len)
{
    for (int i = 0; i < len-1; i++)
    {
        int pos = 0;
        for (int j = 1; j <= len-i-1; j++)
        {
            pos = arr[j] > arr[pos] ? j : pos;
        }
        if (pos != len-i-1)
        {
            swap(arr[pos],arr[len-i-1]);
        }
    }
}

7、计数排序

void countsort(int arr[],int len)
{
    int max =arr[0];
    for (int i = 1; i < len; i++)
    {
        if (arr[i] > max)
        {
            max = arr[i];
        }
    }
    max++;
    int* p = calloc(max,sizeof(int));
    for (int j = 0; j < len; j++)
    {
        p[arr[j]]++;
    }
    int j =0;
    for (int i = 0; i < max; i++)
    {
        while(p[i]>0)
        {
            arr[j++] = i;
            p[i]--;
        }
    }
}