选择，冒泡，插入，快速四种排序实现(字符串)

/*字符串排序*/
#include <stdio.h>
#include <string.h>

//选择排序
void sel_sort( char* p_arr[], int n_size );
//冒泡排序
void bubble_sort( char* p_arr[], int n_size );
//插入排序
void insert_sort( char* p_arr[], int n_size );
//快速排序
void quick_sort( char* p_arr[], int low, int high );

int main() {
char* p_arr[5] = {"guli", "zhaocunxiao", "liumanqian", "tangjingxiang" ,"chenyu"};
    //printf("%d\n", sizeof(p_arr)/sizeof(p_arr[0]));
    quick_sort( p_arr, 0, 4 );
printf("%s\n%s\n%s\n%s\n%s\n",p_arr[0], p_arr[1], p_arr[2], p_arr[3], p_arr[4]);
printf("---------\n");

return 0;
}

//选择排序
//第一次遍历找到最小元素，放在数组首位；
//第二次在剩余未排序元素中，继续找最小元素，放在数组第二位
//依次类推，直至排序完成
/*
选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。
首先在未排序序列中找到最小元素，存放到排序序列的起始位置，然后，
再从剩余未排序元素中继续寻找最小元素，然后放到排序序列末尾。
以此类推，直到所有元素均排序完毕。
*/
void sel_sort( char* p_arr[], int n_size){
    int i=0, j=0;
    for( i=0; i<n_size-1; i++){ //需要n-1次排序
        for( j=i+1; j<n_size; j++){
            if( 0<strcmp(p_arr[i], p_arr[j]) ){
                char* ptr = p_arr[i];
                p_arr[i] = p_arr[j];
                p_arr[j] = ptr;
            }
        }
    }
}
//冒泡排序
//从第一项元素开始，比较相邻的一对元素，第一项>第二项,则交换两元素
//从第一对，到最后一对，均如此操作，则最后一项是最大的元素
//对剩余元素重复以上步骤
/*
冒泡排序（Bubble Sort，台湾译为：泡沫排序或气泡排序）是一种简
单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如
果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直
到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由
来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
步骤：
1、比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2、对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。
    在这一点，最后的元素应该会是最大的数。
3、针对所有的元素重复以上的步骤，除了最后一个。
4、持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需
     要比较。

*/
void bubble_sort( char* p_arr[], int n_size ){
    int i=0, j=0;
    for( i=0; i<n_size-1; i++ ){ //需要n-1次排序
        for( j=0; j<n_size-1-i; j++ ){//随着无序元素递减，比较次数递减
            if( 0<strcmp( p_arr[j], p_arr[j+1] ) ){
                char* ptr = p_arr[j];
                p_arr[j] = p_arr[j+1];
                p_arr[j+1] = ptr;
            }
        }
    }
}
//插入排序
/*
插入排序（Insertion Sort）的算法描述是一种简单直观的排序算法。
它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列
中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采
用in-place排序（即只需用到O(1)的额外空间的排序），因而在从后
向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提
供插入空间。
步骤：
1、从第一个元素开始，该元素可以认为已经被排序
2、取出下一个元素，在已经排序的元素序列中从后向前扫描
3、如果该元素（已排序）大于新元素，将该元素移到下一位置
4、重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5、将新元素插入到该位置中
6、重复步骤2
*/
void insert_sort( char* p_arr[], int n_size ){
    int i=0, j=0;
    for(i=0; i<n_size-1; i++){ //需要n-1次排序
        j=i;//j初始化为最后一个有序元素下标, j用以指向插入位置
        char* p_tmp = p_arr[i+1]; //copy这个无序元素
        while( 0 <= j ){
            if( 0<strcmp( p_arr[j], p_tmp ) ){
                p_arr[j+1] = p_arr[j]; //大于无序元素，就移动到下一位置
                j--;
            }else{
                break;
            }
        }
        p_arr[j+1] = p_tmp;
    }

}
//快速排序
/*
快速排序是由东尼·霍尔所发展的一种排序算法。在平均状况下，
排序 n 个项目要Ο(n log n)次比较。在最坏状况下则需要Ο(n2)次比较，
但这种状况并不常见。事实上，快速排序通常明显比其他Ο(n log n)
算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很
有效率地被实现出来，且在大部分真实世界的数据，可以决定设计的
选择，减少所需时间的二次方项之可能性。

步骤：

▲从数列中挑出一个元素，称为 “基准”（Pivot），
▲重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素
   比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区
   退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
▲递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子
    数列排序。

*/
void my_swap( char** p_arg1, char** p_arg2 ){
    char* ptr = *p_arg1;
    *p_arg1 = *p_arg2;
    *p_arg2 = ptr;
}

int part( char* p_arr[], int low, int high ){
    char* pivot = p_arr[low]; //采用子序列的第一个元素作为枢纽元素
    while( low < high){
        //从后往前栽后半部分中寻找第一个小于枢纽元素的元素
                 while ( low < high && 0<=strcmp(p_arr[high], pivot) )
                 {
                     --high;
                 }
                 //将这个比枢纽元素小的元素交换到前半部分
                 my_swap( &p_arr[low], &p_arr[high] );
                 //从前往后在前半部分中寻找第一个大于枢纽元素的元素
                 while ( low <high &&  strcmp( p_arr [low ], pivot )<0 )
                 {
                     ++low ;
                 }
                 //将这个枢纽元素大的元素交换到后半部分
                 my_swap( &p_arr[low], &p_arr[high] );
    }
    return low ;//返回枢纽元素所在的位置
}

void quick_sort( char* p_arr[], int low, int high ){
    if (low <high )
             {
                 int n=part(p_arr ,low ,high );
                 quick_sort (p_arr ,low ,n );
                 quick_sort (p_arr ,n +1,high );
             }
}