排序总结

// 1选择排序：就是将第一个与最小的那个交换，然后将第二个与余下的最小的那个交换 ....

 

选择排序是不稳定的        （稳定是两个数如果相等，则保持他们在排序前的相对顺序，反之就是不稳定的）

#include <stdio.h>

void select_sort(int a[], int n)                     //选择排序
{
 int i, j, min, t;
 for(i=0; i<n-1; i++)
 {
  min = i;                                                    //min记下下标,min每次都增大    假设当前下标为i的数最小

  for(j=i; j<n; j++)                                      //循环找到最小数的下标
  {
   if(a[min] > a[j])
    min = j;                                                  //将最小的那个下标记下
  }
  if(i != min)                                                 //将第一个与最小的交换.....      如果min在循环中改变了，就需要交换数据    

                                                                     可以不要，但有可以节省时间，如第一个就是最小的用了if则下面就不用交换了

 {
   t = a[i];
   a[i] = a[min];
   a[min] = t;
  }
 }
 printf("output array:/n");
 for(i=0; i<10; i++)
 {
  printf("%d ",a[i]);
 }
 printf("/n");
}

 

 

//2冒泡就是两两比较将最大的那个沉底

 

冒泡排序是稳定的

 

void bubble_sort(int a[], int n)
{
 int i, j, temp;
 for(i=0; i<n-1; i++)
  for(j=0; j<n-i-1; j++)                                        //控制下面比较的个数
  {
   if(a[j]>a[j+1])
   {
    temp = a[j];
    a[j] = a[j+1];
    a[j+1] = temp;
   }
  }
 printf("output array:/n");
 for(i=0; i<10; i++)
 {
  printf("%d ",a[i]);
 }
 printf("/n");
}

 

//3直接插入排序：假设前面n-1个数都是排好顺序的，现在吧第n个数插到前面的有序数中，使得这n个数有序，反复循环，直到全部排好

 

比较适合序列比较小，序列中有一个有序序列

 

 

直接插入排序是稳定的

 

从第1个开始，一个一个的插入，直到所有的都插入为止

 

void insert_sort(int a[], int n)
{
 int i, t, j;
 for(i=1; i<10; i++)                             // 第一个数有序，所以从1开始
 {
  t = a[i];                                            //每一个待插入的数
  for(j=i-1; j>=0; j--)                          //从后向前比较，并依次后移
  {
   if(a[j]>t)
    a[j+1] = a[j];
   else
    break;
  }
   a[j+1] = t;
 }
 printf("output array:/n");
 for(i=0; i<10; i++)
 {
  printf("%d ",a[i]);
 }
 printf("/n");
}

 

 //4 shell排序（也叫缩小增量排序）：算法将要排序的全部元素按增量d分成d组，每组的记录下标相差d，对每组全部元素排序，然后在用一个较小的增量对它排序，在每组中在进行排序，当增量减到1时，整个要排序的数被分成1组，排序完成。

 

 

 

先为n/2,在为一半......直到1为止

希尔排序是不稳定的，直接插入排序的改进

 

void shell_sort(int a[], int n)
{
 int i, j, k, t;
 for(i=n/2; i>0; i=i/2)                                         //控制增量
 {
  for(i=n-i; i<n; i++)                                           //开始直接插入排序
  {
   t = a[n/2];
   for(j=i-n/2; j>=0; j=j-n/2)
   {
    if(a[j]>t)
     a[j+n/2] = a[j];
    else
     break;
   }
   a[j+n/2] = t;
  }
 }
 printf("output array:/n");
 for(i=0; i<10; i++)
 {
  printf("%d ",a[i]);
 }
 printf("/n");
}

 

 

void quick_sort(int a[], int low, int high)             //递归过程    冒泡排序的一种改进
{
 int i, j, t;
 if(low<high)                                         //小的放在左边，大的放在右边，以下标为low的元素为基准点
 {
  i = low;
  j = high;
  t = a[low];                                          //暂存
 
  while(i<j)
  {
   while(i<j && a[j]>t)                             //右边的只要比基准点大仍放在右边        
   {
    j--;                                                     //前移
   }
   if(i<j)
   {
    a[i] = a[j];                                         //小 则替换基准点的数
    i++;
   }
   while(i<j && a[j]<=t)
   {
    i++;
   }
   if(i<j)
   {
    a[j] = a[i];
    j--;
   }
  }
  a[i] = t;
  quick_sort(a, low, i-1);                                      //对基准点左边的数载执行快速排序
  quick_sort(a, i+1, high);                                    //对基准点右边的数载执行快速排序

 }
/* printf("output array:/n");
 for(i=0; i<10; i++)
 {
  printf("%d ",a[i]);
 }
 printf("/n");*/
}

 

main()
{
 int i, a[10];
 int n = 10;
 printf("input 10 number:/n");
 for(i=0; i<10; i++)
 {
  scanf("%d", &a[i]);
  printf("/n");
 }
  select_sort(a, n);
  bubble_sort(a, n);
  insert_sort(a, n);                            
 shell_sort(a, n);
 quick_sort(a, n);
}