小白日记（**）排序算法：冒泡排序_直接插入排序_简单选择排序_二路归并排序_快速排序

**冒泡排序:**
思路：通过相邻两个元素之间不断比较大小，相互交换位置，来达到有序的目的；

#include <stdio.h>
#include <stdlib.h>
#define MAX 100005
int main()
{
    int a[MAX],i,j,N,temp;
    scanf("%d",&N);
    for(i=0 ; i<N ;i++)
        scanf("%d",&a[i]);
    printf("\n排序前数据的顺序：\n");
    for(i=0 ; i<N ; i++)
        printf("%3d",a[i]);
    for(i=0 ; i<N ; i++)
    {
        for(j=i+1 ; j<N ; j++)	//j=i+1；表示是从下表i元素的后面开始排序；
        {
            if(a[i]>a[j])	//此处为升序排序；如果前面一个比后面大，交换两者的位置；
            {
                temp=a[j];
                a[j]=a[i];
                a[i]=temp;
            }
        }
    }
    printf("\n排序后数据的顺序：\n");
    for(i=0 ; i<N ; i++)
        printf("%3d",a[i]);
    return 0;
}

输入案例
10
2 1 3 5 5 6 7 8 10 4
输入案例
排序前数据的顺序：
  2  1  3  5  5  6  7  8 10  4
排序前数据的顺序：
  1  2  3  4  5  5  6  7  8 10

/*时间复杂度O(n2)*/

**直接插入排序**
思路：在前面有序个数列中，在后面第一个元素插入到前面有序的数列中；
{有序数列}{a[i],无序数列}
将a[i]插入到前面有序的序列中；

#include <stdio.h>
#include <stdlib.h>
#define MAX 100005
void Insertsort(int *a, int length)
{
    int i,j,an;
    for(i=1 ; i<length ; i++)
    {
        an=a[i];
        for(j=i-1 ; j>=0 ; j--)	//前面在i个有序数列中找到an应在的位置；
        {
            if(an<=a[j])
            {
                a[j+1]=a[j];	//an比有序元素小，则后移一位；
            }
            else
                break;	//找到比an小的，直接退出；
        }
        a[j+1]=an;		//在第i个位置an比a[j]大，插入至j+1的位置；
    }
    printf("\n排序后数据的顺序：\n");
    for(i=0 ; i<length ; i++)
        printf("%3d",a[i]);
}
int main()
{
    int a[MAX],i,N;
    scanf("%d",&N);
    for(i=0 ; i<N ; i++)
        scanf("%d",&a[i]);
    printf("\n排序前数据的顺序：\n");
    for(i=0 ; i<N ; i++)
        printf("%3d",a[i]);
    Insertsort(a, N);
    return 0;
}

输入案例：
10
2 1 3 5 5 6 7 8 10 4
输出案例：
排序前数据的顺序：
  2  1  3  5  5  6  7  8 10  4
排序后数据的顺序：
  1  2  3  4  5  5  6  7  8 10
时间复杂度O(n2)

**简单选择排序**
思路：每次都从后面的元素中找到最小的元素，然后与前面的元素进行交换。
例如：7 5 8 3 2 5

 1. 在{7 5 8 3 2 5}  找到最小的元素 2，并将它与第一个7交换；交换后{2 5 8 3 7 5}
 2. 在{2}{5 8 3 7 5} 找到最小的元素 3，并将它与第一个5交换；交换后{2 3 8 5 7 5}
 3. 在{2 3}{ 8 5 7 5}找到最小的元素 5，并将它与第一个8交换；交换后{2 3 5 8 7 5}
 4. 在{2 3 5}{8 7 5} 找到最小的元素 5，并将它与第一个8交换；交换后{2 3 5 5 7 8}
 5. 在{2 3 5 5}{7 8} 找到最小的元素 7，并将它与第一个7交换；交换后{2 3 5 5 7 8}
 6. 在{2 3 5 5 7}{8} 找到最小的元素 8，并将它与第一个8交换；交换后{2 3 5 5 7 8}
 即得到有序数列；

#include <stdio.h>
#include <stdlib.h>
#define MAX 100005
void SelectSort(int *a , int length)
{
    int i,j,temp,min;
    for(i=0 ; i<length ; i++)
    {
        min=i;
        for(j=i ; j<length ; j++)		//从后面的元素中找到一个最小的元素跟最前的元素交换；
        {
            if(a[j]<a[min])
                min=j;
        }
        temp=a[i];
        a[i]=a[min];
        a[min]=temp;
    }
    printf("\n排序后元素的顺序：\n");
    for(i=0 ; i<length ; i++)
        printf("%3d",a[i]);
}
int main()
{
    int arry[MAX],i,N;
    scanf("%d",&N);
    for(i=0 ; i<N ; i++)
        scanf("%d",&arry[i]);
    printf("\n排序前元素顺序:\n");
    for(i=0 ; i<N ; i++)
        printf("%3d",arry[i]);
    SelectSort(arry , N);
    return 0;
}

输入案例：
10    
2 1 3 5 5 6 7 8 10 4
输出案例：
排序前元素顺序:
  2  1  3  5  5  6  7  8 10  4
排序后元素的顺序：
  1  2  3  4  5  5  6  7  8 10
  时间复杂度O(n2)

//**二路归并排序**
#include <stdio.h>
#include<malloc.h>
#define Max 50000     /*N为数据量大小*/

void MergeSort(int R[],int N,int low,int high); //二路归并排序，R中具有N个元素，该函数实现对R中R[low]...R[high]进行升序排序
void Merge(int R[],int N,int u,int m,int v);//将有序段R[u..m],R[m+1..v]归并到R[u..v]
void Print(int R[],int N);

int  main()
{
  int *R,N,i;                     /*数据存储在R[1]...R[N]中*/
  scanf("%d",&N);
  R=(int *)malloc((N+1)*sizeof(int));
  for(i=1;i<=N;i++)
    scanf("%d",&R[i]);
  MergeSort(R,N,1,N);
  Print(R,N);
  return 0;
}

void Print(int R[],int N)
{
    int i;
    for (i=1;i<N;i++)
        printf("%d,",R[i]);
    printf("%d\n",R[N]);
}

void MergeSort(int R[],int N,int low,int high)
{
    int mid;
    if (low<high)
    {
        mid=(low+high)/2;
        MergeSort(R,N,low,mid);
        MergeSort(R,N,mid+1,high);
        Merge(R,N,low,mid,high);
    }
}
void Merge(int R[],int N,int u,int m,int v)     //将有序段R[u..m],R[m+1..v]归并到R[u..v];
{	//如果需要直接水过去;可以直接从u到v直接排序排序(亲测有用);
    int i=u,j=m+1,k=0;
    int A[Max];	//定义一个新的数组;将两个数组有序合并;
    while(i<m+1||j<v+1)	//初始满足的条件;
    {
        if(i<m+1&&j<v+1)	//两个数组都没有寻找完;
        {
            if(R[i]<R[j])
                A[k++]=R[i++];
            else
                A[k++]=R[j++];
        }
        else if(i>=m+1)	//当前面一个数组找完了;
        {
            A[k++]=R[j++];
        }
        else	//后面一个数组找完了;
            A[k++]=R[i++];
    }
    for(i=u ; i<=v ; i++)	//将定义数组赋值给原数组;
        R[i]=A[i-u];	//原数组从0开始;
    return ;
}

输入样例：
10
121 924 447 271 787 717 127 34 63 296

输出样例：
34,63,121,127,271,296,447,717,787,924

//**快速排序递归算法**
#include <stdio.h>
#include<malloc.h>
#define Max 50000     /*N为数据量大小*/

int Partition(int R[],int low,int high); //对R[low]..R[high]进行一趟划分
void QuickSort(int R[],int N,int low,int high ); //对R[low]..R[high]进行快速排序，其中N是原始待排序数组的大小，便于输出整个数组的中间状态
void Print(int R[],int N);

int  main()
{
    int *R,N,i;                     /*数据存储在R[1]...R[N]中*/
    scanf("%d",&N);
    R=(int *)malloc((N+1)*sizeof(int));
    for(i=1; i<=N; i++)
        scanf("%d",&R[i]);
    QuickSort(R,N,1,N);
    Print(R,N);
    return 0;
}

void Print(int R[],int N)
{
    int i;
    for (i=1; i<N; i++)
        printf("%d,",R[i]);
    printf("%d\n",R[N]);
}

void QuickSort(int R[],int N,int low,int high )
{
    int p;
    if (low<high)
    {
        p=Partition(R,low,high);  //对数组R从low到high进行一次划分
       // Print(R,N); //输出当前整个数组的状态 (加入可以观察每段排序输出此时数组的状态)
        QuickSort(R,N,low,p-1); //对数组R前半段(low,p-1) 进行快速排序
        QuickSort(R,N,p+1,high);//对数组R后半段(p+1,high)进行快速排序
    }
}
int Partition(int R[],int low,int high)  //对R[low]..R[high]进行一趟划分
{
	if(low>=high)	//待排序没有元素;或者传入数据错误;
        return NULL;
    int i=low,j=high,k;
    k=R[i];	//将第一个作为中间值
    while(i<j)
    {
        while(R[j]>=k&&i<j)	//从后往前找比k小的值;
            j--;
        if(i<j)	//判断while循环退出的条件,如果i<j,即找到了比k小的值;
            R[i++]=R[j];	//与最前面i所指的位置进行交换;
        while(R[i]<=k&&i<j)	//从前往后找比k大的值;
            i++;
        if(i<j)	//判断while循环退出的条件,如果i<j,即找到了比k大的值;
            R[j--]=R[i];	//与后面j所指向的值进行交换;
    }
    R[i]=k;	//i=j时,即为中间值所在的位置;
    return i;
}

输入样例：
10
121 924 447 271 787 717 127 34 63 296

输出样例：
34,63,121,127,271,296,447,717,787,924