C语言实现的算法总结

 

 快速排序  quick sort
 
基本思想：以一个数为参照，把比它小的排左边，比它大的排右边（从小到大排序）
          左边找大于参照的，右边找小于参照的，找到就彼此交换。
 
5     6     9     1     10    8     7     2     3     0    原顺序 第一个为参照
5     0     9     1     10    8     7     2     3     6    i从左第二个向右扫描 j从右扫描 符合条件就交换
5     0     3     1     10    8     7     2     9     6    
5     0     3     1     2     8     7     10    9     6
2     0     3     1     5     8     7     10    9     6
 
 
 
/************************
a 为数组名形参
low 为最小下标
high 为最大下标
*************************/
 
第一种方式：
void quicksort(int *a,int low,int high) 
{
    int i,j;
    int temp;
 
    i = low;
    j = high;
 
    while ( i != j)
    {
        if ( a[i+1] <= a[low])       /* 从左到右找比a[low]大的元素*/ 
        {                            /* 注意加 相等 的情况，必加，不然当
            i++;                    /*  有相等的数存在时，就会出错 */
        }
        else if ( a[j] > a[low])     /* 从右到左找比a[low]小的元素*/
        {
            j--;
        }
        else                         /* 若找到且满足条件，则交换  */
        {
            temp = a[i+1];
            a[i+1] = a[j];
            a[j] = temp;
        }
    }
 
    temp = a[low];
    a[low] = a[i];
    a[i] = temp;
 
    if ( i > low )            /* 左边待排数的进入递归排序 */
    {
        quicksort(a,low,i-1);
    }
    if ( j < high)           /* 右边待排数的进入递归排序 */
    {
        quicksort(a,j+1,high);
    }
 
}
 
 
第二种方式：
void quicksort(int *a,int low,int high)
{
    int i,j;
    int temp;
 
    i = low;
    j = high;
 
    while ( i < j)    //等同于 while (i != j)
    {
        while ( a[i+1] <= a[low] && i < j)  /* 从左到右找比a[low]大的元素 */ 
        {                                   /* 注意加限制条件 i<j  不然会出错*/  
            i++;                            /* 注意加 相等 的情况，必加，不然当
        }                                   /*  有相等的数存在时，就会出错 */
        while ( a[j] > a[low] && i < j)     /* 从右到左找比a[low]小的元素 */ 
        {
            j--;
        }
        if ( i < j )      /*若找到且满足条件，则交换,必须加限制条件 i<j */ 
        {                 /* 否则当 i = j 跳出时也会交换，就出错了 */
            temp = a[i+1];
            a[i+1] = a[j];
            a[j] = temp;
        }
        
    }
 
    temp = a[low];
    a[low] = a[i];
    a[i] = temp;
 
    if ( i > low )
    {
        quicksort(a,low,i-1);
    }
    if ( j < high)
    {
        quicksort(a,j+1,high);
    }
 
}
 
 
第三种方式：
void quicksort(int *a,int low,int high)
{
    int i,j;
    int temp;
 
    i = low;
    j = high;
    temp = a[low];
 
    while ( i < j)
    {
        while (a[j] >= temp && i < j )
        {
            j--;
        }
        if (i < j)
        {
            a[i] = a[j];
            i++;
        }
        while (a[i] < temp && i < j)
        {
            i++;
        }
        if (i < j)
        {
            a[j] = a[i];
            j--;
        }
        
    }
    a[i] = temp;
 
    if ( i > low )
    {
        quicksort(a,low,i-1);
    }
    if ( j < high)
    {
        quicksort(a,j+1,high);
    }
 
}
B：插入排序
 
①：直接插入排序   insert sort
 
void insertsort(int *a,int n)
{
    int i,j;
    int temp;
    
    for (i=0; i<n-1; i++)
    {
        temp = a[i+1];              
        j = i;
 
        while (temp < a[j] && j >=0)
        {
            a[j+1] = a[j];
            j--;
        }
        a[j+1] = temp;
    }
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
②:希尔排序       shell sort
 
void shellsort(int *a,int n)
{
    int i,j,k;
    int temp;
    int span = n/2;  //span为跨度
 
    while ( span >= 1 )
    {
        for (k=0; k<span; k++)
        {
            for (i = k; i+span <n ; i=i+span)   //直接插入排序
            {
                temp = a[i+span];
                j = i;
                while (temp < a[j] && j >= k)
                {
                    a[j+span] = a[j];
                    j = j-span;
                }
                a[j+span] = temp;
 
            }
            
 
        }
        span = span/2;
    }
}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
C:选择排序
①：直接选择排序  select sort
重点：设置一个flag标志位，记录每次循环中的最小（大）数的下标，循环完成时交换。
      减少了交换次数。
void selectsort(int *a,int n)
{
    int i,j;
    int flag;      //flag记录每次循环中最小（大）的数的下标
    int temp;      //temp用于临时交换
 
    for (i=0; i< n-1; i++)
    {
        flag = i;  //每次循环的最小（大）数的下标
        for (j=i+1; j<n; j++)
        {
            if (a[flag]>a[j]) //如果最小（大）数大于（小于）任意一个数
            {
                flag = j;     //则把其下标赋给flag 
            }
 
        }
        if (flag != i)       //如果最小（数）不是每次循环的第一个，则交换
        {                    //可以减少交换次数
            temp = a[i];
            a[i] = a[flag];
            a[flag] = temp;
        }
 
    }
}