排序算法集合

基础：三大排序

选择排序

for(int i=0;i<numsSize-1;i++)//每次从目标位置选取比他小的数移动交换
{
    for(int j=i+1;j<numsSize;j++)
    {
        if(nums[i]>nums[j])
        {
            int temp=nums[i];
                nums[i]=nums[j];
                nums[j]=temp;
        }
    }
}

冒泡排序 

 

for (int i = 0; i < numsSize-1;i++)//不用于自身比较，只需比较前numsSize-1个数即可
	{
		for (int j = 0; j < numsSize-1 - i; j++)//numsSize-1-i是因为每一趟就会少一个数比较
		{
			if (nums[j] > nums[j+1])
			{
				int temp = nums[j];
				nums[j] = nums[j+1];
				nums[j+1] = temp;
			}
        }
    }

插入排序 

for(int i=0;i<numsSize-1;i++)
{
    int now=nums[i],j;
    for(j=i-1;j>=0;j--)
    {
        if(nums[j]>nums[i])//较大的数在右边先填入，一般来说因为i之前都是有序的，只会执行一次
        //比如1,100，-1
        //第一次：1,100,100，j=1
        //第二次：1,1,100，j=0
        nums[j+1]=nums[j];
        else
        break;
    }
    nums[j+1]=now;//j+1=0,最终到达的是一个比nums[i]小的数
    
}

上述三种基本排序的时间复杂度基本上都是O（n^2）,因为有双重for循环，在对于数据量小的时候可以应对，但是一旦数据量变大就容易崩溃

提高

 归并排序（递归+分治）

需要额外申请空间

归并排序（Merge Sort）是一种基于分治思想的排序算法，它将待排序的数组分成两部分，分别对这两部分递归地进行排序，最后将两个有序子数组合并成一个有序数组。它的时间复杂度为 O(nlogn)。

归并排序的基本思路是将待排序的数组分成两个部分，分别对这两部分进行排序，然后将排好序的两部分合并成一个有序数组。这个过程可以用递归来实现。具体的实现步骤如下：

分解：将待排序的数组不断分成两个子数组，直到每个子数组只有一个元素为止。

合并：将相邻的两个子数组合并成一个有序数组，直到最后只剩下一个有序数组为止。

合并的过程中，需要用到一个辅助数组来暂存合并后的有序数组。具体来说，假设待合并的两个有序数组分别为 A 和 B，它们的长度分别为 n 和 m，合并后的有序数组为 C

那么合并的过程可以按如下步骤进行：

1.定义三个指针 i、j 和 k，分别指向数组 A、B 和 C 的起始位置。

2.比较 A[i] 和 B[j] 的大小，将小的元素放入 C[k] 中，并将对应指针向后移动一位。

3.重复步骤 2，直到其中一个数组的元素全部放入 C 中。

4.将另一个数组中剩余的元素放入 C 中。

归并排序的优点是稳定性好，即对于相等的元素，在排序前后它们的相对位置不会改变。缺点是需要额外的空间来存储辅助数组

//分割数组
void mergeSort(int *arr, int start, int end)
{
    if(start>=end)//只剩1个元素时停止递归
return;//什么都不干
//递归分割并对分割后的两个数组进行排序
    else
    {
    int mid=(start+end)/2;
    mergeSort (arr,start,mid);
    mergeSort (arr,mid+1,end);
    //合并
    merge(arr,start,mid,end);
    }
}
//排序后合并数组
void merge(int *arr, int start, int mid, int end)
{
    int m=0,begin1=start,//数组1起点begin2=mid+1;//数组2起点
    
int *nums=(int*)malloc((end-start+1)*sizeof(int));//为辅助数组申请内存
  
  while(begin1<=mid&&begin2<=end)//两个数组中都未排序完
  {
    if(arr[begin1]>arr[begin2])
        nums[m++]=arr[begin2++];
    else
        nums[m++]=arr[begin1++];
  }
  while(begin2<=end)//数组1排完
  nums[m++]=arr[begin2++];
  
  while(begin1<=mid)//数组2排完
  nums[m++]=arr[begin1++];
//拷贝辅助数组到原数组中  
memcpy(arr+start, nums , (end-start+1)*sizeof(int));
  free(nums);
}

快速排序（递归+分治）

快速排序说起来其实也挺简单的。算法的大致过程是对于一个无序序列,找到一个“哨兵数”,将序列中所有比哨兵数小的数字都在哨兵数的左边,所有比哨兵数大的数字都在哨兵数的右边;然后分别对哨兵数左边和右边再用问样的方法找到新的哨兵数,并再次进行分类,直到集合不可分割为止。

怎么选择哨兵呢?随便选,可以是第一个,可以是中间那个,也可以在序列中随机选择，这里选取中间那个

择好哨兵,然后从序列左端开始寻找第一个比n大的数字，从右端选取第一个比n小的数字，然后交换这两个数;接着继续从左边找到比哨兵大的数字,右边比哨兵小的数字并交换

直到将序列分为两组,左边序列都不大于哨兵,右边序列都不小于哨兵,就可以分别对左边和右边进行排序了。

/**
 * Note: The returned array must be malloced, assume caller calls free().
 */
 void swap(int* a,int* b)
 {
     int temp=*a;
     *a=*b;
     *b=temp;
 }
 void qsort0(int* flag,int *heights,int left,int right)
 {
     int i=left,j=right;
     int flag0=heights[(i+j)/2];
   do
    {
//注意这里不能用heights[(i+j)/2],因为heights处于排序中，值会改变，但是我们选取的flag0应当是不变量
        while(heights[i]>flag0)
        i++;
        while(heights[j]<flag0)
        j--;
        if(i<=j)
        {
            swap(&heights[i],&heights[j]);
            swap(&flag[i],&flag[j]);
            i++;
            j--;
        }
    }while(i<=j);
    //循环结束时i在j的右边,且i,j紧邻
    //递归
    if(left>=right)
    return ;
    if(left<j) qsort0(flag,heights,left,j);
   if(i<right) qsort0(flag,heights,i,right);
 }
char** sortPeople(char** names, int namesSize, int* heights, int heightsSize, int* returnSize) 
{
    *returnSize=namesSize;
    //构造一个flag 数组用以存入names对应的身高下标
    int flag[heightsSize];
    for(int i=0;i<heightsSize;i++)
    flag[i]=i;
    //快速排序
    qsort0(flag,heights,0,heightsSize-1);
    char**str=(char**)malloc(sizeof(char*)*heightsSize);
    //str数组填入排序后的对应指针
    for(int i=0;i<heightsSize;i++)
    {
        str[i]=names[ flag[i] ];
    }
    return str;
}