基本的排序算法

一、冒泡排序算法（时间复杂度为O（n²））

1. 假设有N个数，一开始交换的范围是0~N-1，那个大那个就放在后面，依次交换过去，最后最大的数就放在了最后面。
2. 接着把范围缩小到0~N-2，继续比较那个大那个就放在后面，依次交换过去，倒数第二大的数就放在倒数第二了
3. 直到把范围缩小到只有一个数的时候整个数组就有序了

int *bublesort(int *arry, int n)
{
    if(arry==NULL || n<2)
    {
        return arry;
    }
    int i = 0, j = 0;
    int temp;

    for(i=0; i<n-1; i++)
    {
        for(j=0; j<n-i-1; j++)
        {
            if(arry[j] > arry[j+1])
            {
                temp = arry[j];
                arry]j] = arry[j+1];
                arry[j+1] = temp;
            }
        }
    }
    return arry;
}


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

 

 二、选择排序（时间复杂度O（n²））

1. 一开始从整个数组的范围0~N-1上选出一个最小值放到位置0上
2. 然后从范围1~N-1选出最小的一个值放到位置1上
3. 直到最后只包含一个数的时候整个数组就有序了

   int *SelectSort(int *a, int n)
   {
       if(a==NULL || n<2)
       {
           return a;
       }
   
       int i,j;
       int min;
       int temp;
       for(i=0; i<n; i++)
       {
           min = i;
           for(j=i+1; j<n; j++)
           {
               if(a[min] > a[j])
               {
                   min = j;
               }
           }
           if(min != i)
           {
                temp = a[min];
                a[min] = a[i];
                a[i] = temp;
           }
       }
   
       return a;
   }

    

三、插入排序的过程（O（n²））

1. 首先位置1上的数和位置0上的数比较，如果位置1上的数更小那么就和位置0上的数交换
2. 接下来位置2上的数和它前面的数比较如果小就交换
3. 假设位置K的数为b那么b就和前面的数一次比较直到b>=它前面的数才停止
4. 从1位置到N-1位置重复刚刚的过程，那么整个数组就有序了

int *InsertSort(int *a, int n)
{
    if(a==NULL || n<2)
    {
        return a;
    }

    int i, j;
    int temp;
    for(i=1; i<n; i++)
    {
        for(j=i; j>0; j--)
        {
            if(a[j] < a[j-1])
            {
                temp = a[j];
                a[j] = a[j-1];
                a[j-1] = temp;
            }
            else
            {
                break;
            }
        }
    }
    return a;
}