C#实现冒泡快速排序及二分法查找

冒泡排序

原理：从头开始，每一个元素和它的下一个元素比较，如果它大，就将它与比较的元素交换，否则不动。这意味着，大的元素总是在向后慢慢移动直到遇到比它更大的元素。所以每一轮交换完成都能将最大值冒到最后。

时间复杂度：O(n2)，排序效率是常见几种排序中最慢的。

示例代码

　　     /// <summary>
　　　　 /// 对目标数组进行冒泡排序
        /// </summary>
        /// <param name="arr">目标数组</param>
        public static void BubbleSort(int[] arr)
        {
            for (int i = 0; i < arr.Length - 1; i++)
            {
                for (int j = 0; j < arr.Length - i - 1; j++)
                {
                    if (arr[j] > arr[j + 1])
                    {
                        var tmp = arr[j];
                        arr[j] = arr[j + 1];
                        arr[j + 1] = tmp;
                    }
                }

                Console.WriteLine($"第{i+1}次排序后：{string.Join(' ', arr)}");
            }
        }

快速排序

原理：快速排序是几种排序方法中效率较高，因此经常被采用，采用快速排序思想----分治法 (Divide-and-ConquerMethod)。

时间复杂度：O(n2)，亲测排序还是要快于冒泡的，当然我测试的数据量不大，快速排序的次数比冒泡要少些，数据量大的话效果会明显点。

基本思想：

1. 分解： 在无序区R[low..high]中任选一个记录作为基准(通常选第一个记录，并记为keyValue,其下标为keyValuePosition),以此为基准划分成两个较小的 子区间R[low,keyValuePosition- 1]和R[keyValuePosition+ 1 , high],并使左边子区间的所有记录均小于等于基准记录,右边子区间的所有记录均大于等于基准记录,基准记录无需参加后续的排序。而划分的关键是要求出 基准记录所在的位置keyValuePosition。

2. 求解：

   通过递归调用快速排序对左、右子区间R[low..keyValuePosition-1]和R[keyValuePosition+1..high]快速排序。

3. 组合：

   当"求解"步骤中的两个递归调用结束时，其左、右两个子区间已有序。对快速排序而言，"组合"步骤无须做什么，可看作是空操作。

具体过程：

1. 先从数列中取出一个数作为基准数。

2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。

3. 再对左右区间重复第二步，直到各区间只有一个数。

备注：

　　快速排序是不稳定排序,即相同的关键字排序后，相对位置是不确定的。

示例代码

            private static int _count = 0;

            /// <summary>
            /// 对目标数组进行快速排序
            /// </summary>
            /// <param name="arr">目标数组</param>
            /// <param name="left">开始索引</param>
            /// <param name="right">结束索引</param>
            public static void QuickSort(int[] arr, int left, int right)
            {
                if(left >= right) return;

                int baseNum = arr[left]; //基准数
                int start = left;
                int end = right;

                while (start < end)
                {
                    while (start < end) 
                    {
                        if (arr[end] <= baseNum) //向右比较
                        {
                            arr[start] = arr[end];
                            break;
                        }
                        else
                        {
                            end--;
                        }
                    }

                    while (start < end)
                    {
                        if (arr[start] > baseNum) //向左比较
                        {
                            arr[end] = arr[start];
                            break;
                        }
                        else
                        {
                            start++;
                        }
                    }
                }

                _count++;
                arr[start] = baseNum;
                Console.WriteLine($"第{_count}次排序后：{string.Join(' ', arr)}");

                QuickSort(arr, left, start - 1); //左边比较
                QuickSort(arr, start + 1, right); //右边比较
            }

二分法查找

原理：搜索过程从数组的中间元素开始。如果中间元素正好是要查找的元素，则搜索过程终止；如果某一特定的元素大于或者小于小于中间元素，那就在大于或者小于中间元素的那一半查找，而且跟开始一样也从中间元素开始比较。如果某一步骤数组为空，则代表找不到。

注意：适用于已经排序好的数组。

示例代码

        /// <summary>
        /// 二分法查找指定值
        /// </summary>
        /// <param name="arr">目标数组</param>
        /// <param name="start">开始索引</param>
        /// <param name="end">结束索引</param>
        /// <param name="key">要查找的关键字</param>
        public static void BinarySearch(int[] arr, int start, int end, int key)
        {
            int middle = (start + end) / 2;

            if (start > end)
            {
                Console.WriteLine($"{key}在数组中不存在");
                return;
            }

            if (arr[middle] == key)
            {
                Console.WriteLine($"{key}在数据{string.Join(' ', arr)}中的索引值是{middle}");
                return;
            }
            else if (arr[middle] > key)
            {
                BinarySearch(arr, start, middle - 1, key);
            }
            else
            {
                BinarySearch(arr, middle + 1, end, key);
            }
        }

测试运行

示例代码

        static void Main(string[] args)
        {

            int[] arr1 = { 83, 12, 34, 87, 1, 3, 6, 5, 9, 7, 3, 122, 100, 284, 84 };
            int[] arr2 = { 83, 12, 34, 87, 1, 3, 6, 5, 9, 7, 3, 122, 100, 284, 84 };

            Console.WriteLine($"排序前：{string.Join(' ', arr1)}");

            Console.WriteLine("--------------------------------------------冒泡排序----------------------------------------------");
            Bubble.BubbleSort(arr1);

            Console.WriteLine("--------------------------------------------快速排序----------------------------------------------");
            Quick.QuickSort(arr2, 0, arr2.Length - 1);

            Console.WriteLine("--------------------------------------------二分查找----------------------------------------------");
            int[] arr = { 8, 15, 19, 23, 26, 31, 40, 65, 91 };
            int key = 15;
            Binary.BinarySearch(arr, 0, arr.Length - 1, key);

            Console.ReadLine();
        }

运行结果