排序算法

一.冒泡排序

　　c#(两个相邻的数依次比较大小) 返回结果：2,13,27,38,48,49,49,65,76,92,97

        int[] array = { 49, 38, 65, 97, 76, 13, 27,2,48,92 ,49};
　　　　　public int[] bubbleSort(int[] array)
　　　　　{
         　　int temp=0;
        　　 for (int i = 0; i < array.Length - 1; i++)
        　　 {
            　　for (int j = i+1; j < array.Length; j++)
            　　{
                　　if (array[i] > array[j])
                　　{
                    　　temp = array[i];
                    　　array[i] = array[j];
                    　　array[j] = temp;
                　　}
            　　}
        　　}   
　　　　　　　return array;
　　　　 }

二.简单选择排序

    C#（从第一个数开始从前往后依次比较出最小的数，把最大的数和最小的数相互替换）

    返回结果：2,13,27,38,48,49,49,65,76,92,97

int[] array = { 49, 38, 65, 97, 76, 13, 27,2,48,92 ,49};

public void SimpleSelectSort(int[] array)
{  
        int tmp = 0;
        int t = 0;//最小数标记
        for (int i = 0; i < array.Length; i++)
        {
            t = i;
            for (int j = i + 1; j < array.Length; j++)
            {
                if (array[t] > array[j])
                {
                    t = j;
                }
            }
            tmp = array[i];
            array[i] = array[t];
            array[t] = tmp;
        }
}

三.快速排序

快速排序（Quicksort）是对冒泡排序的一种改进。由C. A. R. Hoare在1962年提出。它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的　所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。

C# 返回结果：2,13,27,38,48,49,49,65,76,92,97

 static void Main(string[] args)
 {
      int[] array={49,38,65,97,76,13,27};
      sort(array,0,array.Length-1);
      Console.ReadLine();
 }
 
 /**一次排序单元，完成此方法，key左边都比key小，key右边都比key大。
        **@paramarray排序数组
        **@paramlow排序起始位置
        **@paramhigh排序结束位置
        **@return单元排序后的数组
        */
    private static int sortUnit(int[] array, int low, int high)
    {
        int key = array[low];
        while (low < high)
        {
            /*从后向前搜索比key小的值*/
            while (array[high] >= key && high > low)
                --high;
            /*比key小的放左边*/
            array[low] = array[high];

            /*从前向后搜索比key大的值，比key大的放右边*/
            while (array[low] <= key && high > low)
                ++low;
            /*比key大的放右边*/
            array[high] = array[low];
        }
        /*左边都比key小，右边都比key大。
        //将key放在游标当前位置。
        //此时low等于high
        */
        array[low] = key;
        Console.WriteLine(string.Join(",", array));
        return high;
    }


    /**快速排序
    *@paramarry
    *@return
    */
    public static void sort(int[] array, int low, int high)
    {
        if (low >= high)
            return;
        /*完成一次单元排序*/
        int index = sortUnit(array, low, high);
        /*对左边单元进行排序*/
        sort(array, low, index - 1);
        /*对右边单元进行排序*/
        sort(array, index + 1, high);
    }

php 返回结果：2,13,27,38,48,49,49,65,76,92,97

    $arr = array (23, 12, 43, 3, 54, 111, 3242, 4, 66, 9, 98, 234, 7, 46, 2 );
    var_dump ( $arr );
    $result = quickSort ( $arr );
    var_dump ( $result );    

    function quickSort($arr) {
        if (count ( $arr ) > 1) {
            $k = $arr [0];
            $x = array ();
            $y = array ();
            $_size = count ( $arr );
            for($i = 1; $i < $_size; $i ++) {
                if ($arr [$i] <= $k) {
                    $x [] = $arr [$i];
                } else {
                    $y [] = $arr [$i];
                }
            }
            $x = $this->quickSort ( $x );
            $y = $this->quickSort ( $y );
            return array_merge ( $x, array ($k ), $y );
        } else {
            return $arr;
        }
    }    

 四.鸡尾酒排序

鸡尾酒排序也就是定向冒泡排序, 鸡尾酒搅拌排序, 搅拌排序 (也可以视作选择排序的一种变形), 涟漪排序, 来回排序 or 快乐小时排序, 是冒泡排序的一种变形。此演算法与冒泡排序的不同处在于排序时是以双向在序列中进行排序

原理：使用鸡尾酒排序为一列数字进行排序的过程可以通过右图形象的展示出来：

数组中的数字本是无规律的排放，先找到最小的数字，把他放到第一位，然后找到最大的数字放到最后一位。然后再找到第二小的数字放到第二位，再找到第二大的数字放到倒数第二位。以此类推，直到完成排序。

与冒泡的区别:

鸡尾酒排序等于是冒泡排序的轻微变形。不同的地方在于从低到高然后从高到低，而冒泡排序则仅从低到高去比较序列里的每个元素。他可以得到比冒泡排序稍微好一点的效能，原因是冒泡排序只从一个方向进行比对(由低到高)，每次循环只移动一个项目。

以序列(2,3,4,5,1)为例，鸡尾酒排序只需要访问两次（升序降序各一次 ）次序列就可以完成排序，但如果使用冒泡排序则需要四次。

java实例：

输出结果：97,92,76,65,49,49,48,38,27,13,2

int[] array = { 49, 38, 65, 97, 76, 13, 27,2,48,92 ,49};

public static int[] cocktailSort(int[] src)
{
    //将最小值排到队尾
    for(int i = 0 ; i < src.length/2 ; i++)
    {
        for(int j = i ; j < src.length-i-1 ; j++)
        {
            if(src[j] < src[j+1])
            {
                int temp = src[j];
                src[j] = src[j+1];
                src[j+1] = temp;
            }
            System.out.println("交换小"+Arrays.toString(src));
        }
        //将最大值排到队头
        for(int j = src.length-1-(i+1); j > i ; j--)
        {
            if(src[j] > src[j-1])
            {
                int temp = src[j];
                src[j] = src[j-1];
                src[j-1] = temp;
            }
            System.out.println("交换大"+Arrays.toString(src));
        }
        System.out.println("第"+i+"次排序结果："+Arrays.toString(src));
    }
    return src;
}

c#实例：

输出结果：2,13,27,38,48,49,49,65,76,92,97

    int myArray={ 49, 38, 65, 97, 76, 13, 27,2,48,92 ,49};

    public static void CockTailSort(int[] myArray)
    {
        int low, up, index, i;
        low = 0;//数组起始索引
        up = myArray.Length - 1;//数组索引最大值
        index = low;//临时变量
        //判断数组中是否有多个元素
        while (up > low)//每一次进入while循环都会找出相应范围内最大最小的元素并分别放到相应的位置
        {
            //进入该for循环会将索引限定范围内最大的元素放到最右边
            for (i = low; i < up; i++)//从上向下扫描
            {
                if (myArray[i] > myArray[i + 1])
                {
                    int temp;
                    temp = myArray[i];
                    myArray[i] = myArray[i + 1];
                    myArray[i +1] = temp;
                    index = i;//记录当前索引
                }
            }
            up = index;//记录最后一个交换的位置
            //进入该for循环会将索引限定范围内最小的元素放到最左边
            for (i = up; i > low; i--)//从最后一个交换位置从下往上扫描
            {
                if (myArray[i] < myArray[i - 1])
                {
                    int temp;
                    temp = myArray[i];
                    myArray[i] = myArray[i - 1];
                    myArray[i - 1] = temp;
                    index = i;
                }
            }
            low = index;//记录最后一个交换的位置
        }
    }