http://jpkc.nwpu.edu.cn/jp2006/rjjs/work/dzjc/rppt/CHAP12/12CH0001.htm

 http://sjjp.tjuci.edu.cn/sjjg/DataStructure/DS/web/paixu/paixu8.1.1.1.htm

 //二叉树：

http://blog.csdn.net/sunboy_2050/article/details/5686810

排序算法在程序中会用到很多，这里介绍几种常见的排序方法以及比较 

 

冒泡排序：对一个队列里的数据，挨个进行轮询和交换，每次轮询出一个当前最大或者最小的值放在队尾，然后继续下次轮询，轮询长度-1，就跟冒泡一样，所以称为冒泡排序，运算时间复杂度N平方

 

选择排序：对一个队列里的数据，选出当前最大或者最小的值，然后将他与队首的数据交换，然后从第二个开始，进行相同的操作，运算时间复杂度N平方，但由于他不像冒泡一样需要不停的交换位置，所以会比冒泡快一些

 

插入排序：对一个队列里的数据，从第二个开始，与此位置之前的数据进行比较，形成局部有序的队列，循环此操作，直到队尾，运算时间复杂度依然为N平方，但他由于保证了局部的有序性，所以比较的次数会更少一些，相对前两种会更快

 

希尔排序：其实就是用步长控制的插入排序，希尔排序通过加大插入排序中元素之间的间隔，并在这些有间隔的元素中进行插入排序，从而让数据项可以大幅度移动，这样的方式可以使每次移动之后的数据离他们在最终序列中的位置相差不大，保证数据的基本有序，大大提升了排序速度，运算时间复杂度N*logN

 

快速排序：对一个队列，以他队尾的数据为基准值，先划分成两块数据，一块都大于这个值，一块小于这个值，然后对这两块进行同样的操作，这是最快的排序方法，运算时间复杂度N*logN

 #include <stdio.h>
 
//顺序查找 
int FindInTurn(int Arr[],int Len,int Data)
{
    int i;
    for(i=0;i<Len;i++)
    {
        if(Data == Arr[i])
        {
            return i;//查找成功 
            break;    
        }    
    }
    return -1;     //查找失败 
}
 
//折半法查找
//只能用于已经排列有序的序列 
int Bin_Search(int Arr[],int Len,int Data)
{
    int Low = 0,High = Len-1, Mid;
    while(Low <= High)
    {
        Mid    = (Low + High)/2;
        if(Arr[Mid] == Data)
        {
            return Mid;    //查找成功，返回Mid 
        }
        if(Data > Arr[Mid])
        {
            Low = Mid +1; //在后半序列中查找 
        }
        else
        {
            High = Mid -1;//在前半序列中查找 
        }
    }
    return -1;//查找失败 
}
 
//直接插入排序
void InsertSort(int Arr[],int Len)
{
    int i,j;
    int temp;
    for(i=1;i<=Len;i++)
    {
        temp = Arr[i];//将Arr[i]保存在临时变量temp中 
        j = i-1;
        while(j>=0 && temp < Arr[j])//找到temp的插入位置 
        {
            Arr[j+1] = Arr[j--];    //将Arr[j]后移 ,再将j值减1 
        }
        Arr[j+1] = temp; //将元素temp插入到指定位置，第i-1趟插入完成 
    }    
} 
 
//选择排序
void SelectSort(int Arr[],int Len) 
{
    int i,j;
    int temp;
    for(i=0;i<Len;i++)
    {
        for(j=i+1;j<=Len;j++)
        {
            if(Arr[i] > Arr[j])
            {
                temp = Arr[i];
                Arr[i] = Arr[j];
                Arr[j] = temp;    
            }    
        }    
    }
}
//冒泡排序 
void BubbleSort(int Arr[],int Len)
{
    int i,j;
    int temp;
    for(i=0;i<Len;i++)
    {
        for(j=0;j<Len-i-1;j++)
        {
            if(Arr[j] > Arr[j+1])
            {
                temp = Arr[j];
                Arr[j] = Arr[j+1];
                Arr[j+1] = temp;
            }
 
        }
    }    
}
 
//希尔排序
void ShellSort(int Arr[],int Len)
{
    int i,j,Flag,Gap = Len;
    int temp;
    while(Gap > 1)
    {
        Gap = Gap / 2;    //缩小增量，每次减半 
    }
    do
    {
        Flag = 0;
        for(i = 0;i<Len - Gap;i++)
        {
            j = i+Gap;
            if(Arr[i] > Arr[j])//子序列用冒泡排序 
            {
                temp = Arr[i];
                Arr[i] = Arr[j];
                Arr[j] = temp;    
                Flag = 1;
            }    
        }
    }while(Flag != 0);
} 
 
void swap(int *a,int *b)//用于交换两个元素的位置 
{
    int temp;
    temp = *a;
    *a = *b;
    *b = temp;    
}
void QuickSort(int Arr[],int Start,int End)
{
    int i,j;
    if(Start < End)
    {
        i = Start;
        j = End;
        while(1)
        {
            do i++;
            while(!(Arr[Start] >=Arr[i] || i==End));//重复执行i++ 
            do j--;
            while(!(Arr[Start] <= Arr[j] || j== Start));//重复执行j--
            if(i < j)
            {
                swap(&Arr[i],&Arr[j]);    //交换Arr[i]和Arr[j]的位置 
            }    
            else
            {
                break;
            }
            swap(&Arr[Start],&Arr[j]);//交换基准元素与Arr[j]的位置 
            QuickSort(Arr,Start,j-1);//递归排序基准元素前面的子序列 
            QuickSort(Arr,j+1,End);//递归排序基准元素后面的子序列 
        }    
    }
 
} 
int main()
{
    int Array[10] = {11,15,0,34,25,39,78,64,27,66};
    int Bin_Array[10] = {0,1,2,3,4,5,6,7,8,9};
 
    printf("顺序查找示例：\n元素7位于数组第%d位置\n",FindInTurn(Array,10,7)+1);
    printf("折半查找示例：\n元素4位于数组第%d位置\n",Bin_Search(Bin_Array,10,4)+1);
 
    printf("直接插入排序示例:\n");
    InsertSort(Array,10);
    for(int i=0;i<10;i++)
    {
        printf("%d ",Array[i]);    
    } 
 
    printf("\n选择排序示例:\n");
    SelectSort(Array,10);
    for(int i=0;i<10;i++)
    {
        printf("%d ",Array[i]);    
    }
 
    printf("\n冒泡排序示例:\n");
    BubbleSort(Array,10);
    for(int i=0;i<10;i++)
    {
        printf("%d ",Array[i]);    
    }  
 
    printf("\n希尔排序示例:\n");
    ShellSort(Array,10);
    for(int i=0;i<10;i++)
    {
        printf("%d ",Array[i]);    
    } 
    printf("\n快速排序示例:\n");
    QuickSort(Array,0,10);
    for(int i=0;i<10;i++)
    {
        printf("%d ",Array[i]);    
    }   
    return 0;
}