【算法】希尔排序,快速排序,选择排序,插入排序,冒泡排序

头文件

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

#ifndef _MYINCLUDE_H
#define _MYINCLUDE_H

#include <stdio.h>
#include <stdbool.h>

extern void bubble_sort(int n,int test[]);//冒泡排序

extern void select_sort(int n,int number[]);//选择排序

extern void swap(int number[], int i, int j);//用于交换数组中的索引为i，j的数

extern int quick_pass(int *array, int low, int high);//得到基准值应该存放的位置
extern void quick_sort(int *array, int low, int high);//快速排序

extern void insert_sort(int len, int *array);//插入排序

extern void shell_sort(int len, int *array);//希尔排序

#endif

主文件

// 实现数组的排序

// 冒泡排序,选择排序,快速排序,插入排序,希尔排序
// @author:成鹏致远
// #net:infodown.tap.cn

#include "myinclude.h"

#define LEN 6

int main()
{
    int test[LEN] = {4,3,5,9,11,8};
    int i;

    //bubble_sort(LEN,test);//冒泡排序
    //select_sort(LEN,test);//选择排序
    //quick_sort(test,0,LEN-1);//快速排序
    //insert_sort(LEN,test);//插入排序
    shell_sort(LEN,test);//希尔排序

    for(i=0; i<LEN; i++)
    {
        printf("%d	",test[i]);
    }
    printf("
");

    return 0;
}

 希尔排序

/*
* @function: 希尔排序
* @author: 成鹏致远
* @net: infodown.tap.cn
*/
//希尔排序
//希尔排序为非稳定排序算法
//希尔排序减少了元素的移动的次数

#include "myinclude.h"

void shell_sort(int len, int *array)//希尔排序
{
    int d;//d个元素分为一组进行排序
    int i;//i为组内未排序部分
    int j;//j为组内排好序的部分
    int tmp;

    for(d = len/2; d >=1 ; d /= 2)
    {
        for(i = d;i < len; i++)//内两层循环实质是一个插入排序，分组减少了元素移动的次数
        {
            tmp = array[i];
            /*寻找插入的位置*/
            for(j = i-d;(tmp < array[j]) && (j>=0);j -= d)//i-d即为组内排好序的最后一个元素
                array[j+d] = array[j];
            array[j+d] = tmp;
        }

    }
}

 快速排序

/*
* @function: 快速排序
* @author: 成鹏致远
* @net: infodown.tap.cn
*/


#include "myinclude.h"

void quick_sort(int *array, int low, int high)//快速排序
{
    int mid;//存储基准值

    if(low < high)
    {
        mid = quick_pass(array,low,high);//得到基准值应该存放的位置
        quick_sort(array,low,mid-1);//对左边的数组递归进行快速排序
        quick_sort(array,mid+1,high);//对左边的数组递归进行快速排序
    }
}



int quick_pass(int *array, int low, int high)//得到基准值应该存放的位置
{
    int tmp = array[low];//tmp保存基准值，此时array[low]位置可认为空

    while(low < high)
    {
        while(low < high && tmp < array[high])//仍需要low<high条件是因为low和high在变化
            high--;//从后往前找，直到找到比基准值小的，下标为high
        if(low < high)
            array[low] = array[high];//将比基准值小的放到空位置，此时array[high]位置可认为空
        while(low < high && tmp > array[low])//再从前往后找，直到找到比基准值大的，下标为low
            low++;
        if(low < high)
        {
            array[high] = array[low];//此时array[low]可认为空
        }
    }
    //此时array[low]为空，此位置正好是基准值的位置
    array[low] = tmp;

    return low;//返回基准值的位置
}

选择排序 

/*
* @function: 选择排序
* @author: 成鹏致远
* @net: infodown.tap.cn
*/

#include "myinclude.h"

void select_sort(int n,int number[])
{
    int i,j;

    for(i=0; i<n; i++)
    {
        int m =i;//每次确定一个最小数
        for (j=i+1; j<n; j++)
        {
            if(number[j] <number[m])
            {
                m =j;
            }
        }
        if (i != m)
        {
            swap(number,i,m);
        }
    }
}

void swap(int number[], int i, int j)
{
    int t;
    t = number[i];
    number[i] = number[j];
    number[j] = t;
}

插入排序 

//@　author　成鹏致远
//@　net http://infodown.tap.cn
//@　qq 552158509
//@ blog　lcw.cnblogs.com

//插入排序

void insert_sort(int len, int *array)//插入排序
{
    int i,j;
    int tmp;//保存待排序的值

    for(i=1; i<len; i++)//第1个数为已经排好序的序列，从第2个数开始比较，依次插入已经排好序的序列
    {
        tmp = array[i];//待排序的值
        for(j=i-1; (tmp<array[j]) && (j>=0); j--)//j指向已经排好序的最后一个元素，依次和tmp比较，如果tmp比已经排好序中的值小，则依次向后移动
            array[j+1] = array[j];
        //此时j+1的位置即为tmp的位置
        array[j+1] = tmp;
    }
}

 冒泡排序

/*
* @function: 冒泡排序
* @author: 成鹏致远
* @net: infodown.tap.cn
*/

#include "myinclude.h"

void bubble_sort(int n,int before[])
{
    int i,j,temp;
    for(i=0; i<n; i++)
    {
        for(j=0; j<n-i-1; j++)
        {
            if(before[j] > before[j+1])
            {
                temp = before[j+1];
                before[j+1] = before[j];
                before[j] = temp;
            }
        }
    }

}