排序方法統計

原文鏈接：https://www.cnblogs.com/qcxdoit/p/6115165.html https://www.cnblogs.com/dcy521/p/10989064.html https://www.cnblogs.com/flypie/p/4991312.html

1、冒泡排序

相鄰元素之間逐對兩兩比較，若不符合預期則先交換位置再繼續比較，如此，每次比較都能把最大或最小的元素放在預期位置，直到完成排序。

/// <summary>
            /// 冒泡排序
        /// </summary>
        /// <param name="array"></param>
        /// <returns></returns>
        public static int[] PopSort(int[] array)
        {
            int[] arr = new int[array.Length];
            array.CopyTo(arr, 0);
            for (int i = 0; i < arr.Length; i++)
            {
                for (int j = 0; j < arr.Length - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        int temp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = temp;
                        Counts.count1++;
                    }
                    else continue;
                }
            }
            return arr;
        }

 

2、快速排序

1、準備工作：先選定一個參考值，設置兩個指針（設爲i,j，分別指向數字序列的頭和尾）。

2、同時從數字序列的兩頭進行掃描對比，將大於參考值的數字都放於參考值的一側，小於參考值的數字置於另一側。直到i,j指向同一個位置，這個位置即爲參考值的預期位置，設爲m。

3、對大於參考值一側，令i=m+1,對小於參考值的一側，令j=m-1。再分別對參考值的兩側重複步驟1、2。

4、重複步驟1、2、3，直到i>j。

/// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="array"></param>
        /// <param name="left"></param>
        /// <param name="right"></param>
        /// <returns></returns>
        private static int sortUnit(int[] array, int left, int right)
        {
            //以left爲基準數，數組第一個元素
            int key = array[left];
            while (left < right)
            {
                //因爲基準數是第一個元素，所有從右邊開始進行比對
                while (array[right] >= key && right > left)
                {
                    //比基準數大，不變，繼續向左移動指針
                    --right;
                }
                array[left] = array[right];
                Counts.count2++;
                while (array[left] <= key && right > left)
                {
                    //比基準數小，不變，繼續向右移動指針
                    ++left;
                }
                array[right] = array[left];
                Counts.count2++;
            }
            //最後將基準數放到指針重合位置
            array[left] = key;
            return right;
        }
       /// <summary>
       /// 快速排序
       /// </summary>
       /// <param name="array">要排序的無序數組</param>
       /// <param name="left">指針left</param>
       /// <param name="right">指針right</param>
        public static void QuickSort(int[] array, int left, int right)
        {
            //重合就return  因爲左邊的要小於右邊的
            if (left >= right)
            {
                return;
            }
            //調用快速排序方法，將數組和指針傳入
            int index = sortUnit(array, left, right);
            //遞歸調用，分別對排序好的左右兩小部分（左邊小於原先基準數的數列 右邊大於原先基準數的數列）進行重複步驟排序
            QuickSort(array, left, index - 1);//左邊
            QuickSort(array, index + 1, right);//右邊
        }

3.選擇排序

就像打擂臺，把元素一個一個往擂臺上擺，優勝劣汰，從而確定第一名，第二名，第三名。。。直到排序完成。

public static void selectSort(int [] arr,int n)
{
        for (int i = 0; i < n - 1; i++) 
        {
            int index = i;
            int j;
            // 找出最小值得元素下標
            for (j = i + 1; j < n; j++) {
                if (arr[j] < arr[index]) {
                    index = j;
                }
            }
            int tmp = arr[index];
            arr[index] = arr[i];
            arr[i] = tmp;
            System.out.println(Arrays.toString(arr));
        }
}

4、二分查找算法

要求，序列是有序的，思想與快速排序類似，也運用了分而治之。

//遞歸實現二分法查找
int BinarySearch(int * a,int key,int low,int high)
{
    if(low>high||key<a[low]||key>a[high])        //越界處理
    {
        return -1;
    }
    int middle=(low+high)/2;
    if(key==a[middle])
    {
        return middle;
    }
    if(middle==low||middle==high)
    {
        if(key==a[low])
        {
            return low;
        }
        if(key==a[high])
        {
            return high;
        }
        else
        {
            return -1;
        }
    }
    if(key<a[middle])
    {
        return BinarySearch(a,key,low,middle);
    }
    if(key>a[middle])
    {
        return BinarySearch(a,key,middle,high);
    }
}

//循環實現二分法查找
int BinarySearchByCircle(int * a,int key,int high)
{
    int low=0;
    int middle;
    while(high>=low)
    {
        middle=(high+low)/2;
        if(key==a[middle])
        {
            return middle;
        }
        if(key<a[middle])
        {
            high=middle-1;
        }
        if(key>a[middle])
        {
            low=middle+1;
        }
    }
    return -1;
}

記得應用遞歸時，return，否則會一直執行到return -1,結束，導致輸出始終爲-1.

 

參考資料：

1、https://www.cnblogs.com/qcxdoit/p/6115165.html    

2、https://www.cnblogs.com/dcy521/p/10989064.html    

3、https://www.cnblogs.com/flypie/p/4991312.html

4、https://blog.csdn.net/nrsc272420199/article/details/82587933