一些简单的排序、查找算法

一、排序算法

1、插入排序

        算法思想简单描述：在要排序的一组数中，假设前面(n-1)[n>=2] 个数已经是排好顺序的，现在要把第n个数插到前面的有序数中，使得这n个数也是排好顺序的。如此反复循环，直到全部排好顺序。直接插入排序是稳定的。算法时间复杂度O(n²)。

void InsertSort(int array[], int length)
{
　　　 int i, j, key;

　　　 for (i = 1; i < length; i++)
　　　 {
　　　　　　　 key = array[i];
　　　　　　　 // 把i之前大于array[i]的数据向后移动
　　　　　　　 for (j = i - 1; j >= 0 && array[j] > key; j--)
　　　　　　　 {
　　　　　　　　　　　 array[j + 1] = array[j];
　　　　　　　 }
　　　　　　　 // 在合适位置安放当前元素
　　　　　　　 array[j + 1] = key;
　　　 }
}

2、冒泡排序

算法思想简单描述：在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。冒泡排序是稳定的。算法时间复杂度O(n²)。

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


}

3、快速排序

算法思想简单描述：快速排序是对冒泡排序的一种本质改进。它的基本思想是通过一趟扫描后，使得排序序列的长度能大幅度地减少。在冒泡排序中，一次扫描只能确保最大数值的数移到正确位置，而待排序序列的长度可能只减少1。快速排序通过一趟扫描，就能确保以某个数为基准点的左边各数都比它小，右边各数都比它大。然后又用同样的方法处理它左右两边的数，直到基准点的左右只有一个元素为止。显然快速排序可以用递归实现，当然也可以用栈化解递归实现。快速排序是不稳定的。最理想情况算法时间复杂度O(nlog2n)，最坏O(n²)。

void swap(int *a, int *b)
{
        int tmp;

        tmp = *a;
        *a = *b;
        *b = tmp;
}

int partion(int a[], int low, int high)
{
        int pivot = a[low];

        while(low < high)
        {
                while(low < high && a[high] >= pivot)
                {
                        --high;
                }


                swap(&a[low], &a[high]);
                while(low < high && a[low] <= pivot)
                {
                        ++ low;
                }

                swap(&a[low], &a[high]);
        }
        return low;
}

void quick_sort(int a[], int low, int high)
{
        if (low < high)
        {
                int n = partion(a, low, high);
                quick_sort(a,low, n);
                quick_sort(a, n+1, high);
        }

}

void main()
{
        int i;
        int a[10] = {9,2,8,3,7,4,6,5,1,0};

        quick_sort(a, 0, 9);
        for(i=0; i<10; i++)
                printf("%d\n", a[i]);


}

二、查找算法

1、顺序查找

2、二分查找（仅适用于有序查找）

#include <stdio.h>

int binary_search(int arry[], int len, int value)
{
    int low, mid_idx, high;
    
    if((arry == NULL) || (len == 0))
    {
        return -1;
    }

    low = 0;
    high = len-1;

    while(low < high)
    {
        mid_idx = (low + high)/2;

        if(value == arry[mid_idx])
        {
            return mid_idx;
        }
        else if(value > arry[mid_idx])
        {
            low = mid_idx + 1;    
        }
        else
        {
            high = mid_idx -1;
        }        
    }

    return 0;
}

//递归方式
int binary_recursive_search(int arry[], int low, int high, int value)
{    
    int mid_idx;
    
    if((arry == NULL) || (low > high))
    {
        return -1;
    }

    mid_idx = (low + high)/2;
    if(arry[mid_idx] == value)
    {
        printf("idx = %d, value = %d \n", mid_idx, arry[mid_idx]);
        return mid_idx;
    }
    else if(value > arry[mid_idx])
    {
        return binary_recursive_search(arry, mid_idx+1, high, value);
    }
    else
    {
        return binary_recursive_search(arry, low, mid_idx -1, value);
    }

    return 0;
    
}

int main(int argc, char *argv[])
{
    int arry[10] = {1,2,3,4,5,6,7,8,9,10};
    int key;

    scanf("%d", &key);
    binary_search(arry, 10, key);
    binary_recursive_search(arry, 0, 9, key);
}