常用排序方法

冒泡排序（适合少量数据，多次排序稳定）

思路一：

lenght为arr的长度
void Bubble(int arr[],int lenght){
    for (int i = 0; i < lenght; ++i)
    {
        for (int j = 0; j <lenght-i-1;++j)
        {
            if (arr[j] > arr[j + 1])
            {
                int tmp = arr[j];
                arr[j] = arr[j+1];
                arr[j + 1] = tmp;
            }
        }
    }
    
}

思路二：

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

选择排序（适合少量数据，多次排序不稳定）

void Selection(int arr[], int lenght)
{
    for (int i = 0; i < lenght-1; ++i)
    {
        int m = i;
        for (int j = i + 1; j < lenght; ++j)
        {
            if (arr[m] > arr[j])
            {
                m = j;
}
        }
        if (m != i)
        {
            int tmp = arr[m];
            arr[m] = arr[i];
            arr[i] = tmp;
        }
    }
}

插入排序（适合少量数据，多次排序稳定）

void void Insertion(int arr[], int lenght)
{
    for (int i = 1; i < lenght; ++i)
    {
        for (int j = i; j>0; --j)
        {
            if (arr[j-1] > arr[j])
            {
                int tmp = arr[j - 1];
                arr[j - 1] = arr[j];
                arr[j] = tmp;
            }
            else
            {
                break;
            }
        }
    }
}

希尔排序（适合大数据，多次排序不稳定）

void Shell(int arr[], int lenght)
{
    int m = 1;
    while (m < lenght / 2)
    {
        m =m* 2+1;
    }
    while (m>0)
    {
        for (int i =m; i< lenght; ++i)
        {
            for (int j = i; j >= m; j -= m)
            {
                if (arr[j] < arr[j- m])
                {
                    int tmp = arr[j];
                    arr[j] = arr[j-m];
                    arr[j-m] = tmp;
                }
                else
                {
                    break;
                }
            }   
            
        }
        m /= 2;
    }
}

归并排序（适合大数据，多次排序稳定）

void Merge(int arr[], int start,int end)
{
    if (end <=start)
    {
        return;
    }
       
    int h =start+(end-start)/ 2;
    if (start < h)
    {
        Merge(arr, start, h);
    }
    if (h + 1 < end) {
        Merge(arr, h + 1, end);
   }
    
    int* arry =(int *) malloc(sizeof(int) * end);
    if (!arry)
    {
        return;
    }
    int p1 = start;
    int p2 = h+1;
    int m = start;
    while (p1 <= h && p2 <= end)
    {
        if (arr[p1] > arr[p2])
        {
            arry[m++] = arr[p2++];
        }
        else {
            arry[m++] = arr[p1++];
        }
    }
    while (p1 <= h)
    {
        arry[m++] = arr[p1++];
  }
    while (p2 <= end)
    {
        arry[m++] = arr[p2++];
    }
    for (int i = start; i <= end; ++i)
    {
        arr[i] = arry[i];
    }
}

快速排序（适合大数据，多次排序不稳定）

void Quick(int arr[],int lo,int hi)
{
    if (hi <= lo)
    {
        return;
    }
    int m=arr[lo];
    int left = lo;
    int right = hi;
    while (true)
    {
       
        while (arr[--right] > m)
        {
            if (right == lo)
            {
                break;
            }
           
        }
        while (arr[++left] < m)
        {

            if (left == hi)
            {
                break;
            }  
        }
        if (left >= right)
        {
            break;
        }
        else
        {
            int tmp = arr[right];
            arr[right] = arr[left];
            arr[left] = tmp;
        }
   }
    
     
        arr[lo] = arr[right];
        arr[right] = m;
    Quick(arr, lo,left-1);
    Quick(arr, left+1, hi);
}