排序方法统计

原文链接：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