首页 > 编程语言 > 详细

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

时间:2021-02-04 20:59:11      阅读:33      评论:0      收藏:0      [点我收藏+]

冒泡排序

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

时间复杂度: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();
        }

运行结果

技术分享图片

 

 

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

原文:https://www.cnblogs.com/yangdengfeng/p/14374009.html

(0)
(0)
   
举报
评论 一句话评论(0
关于我们 - 联系我们 - 留言反馈 - 联系我们:wmxa8@hotmail.com
© 2014 bubuko.com 版权所有
打开技术之扣,分享程序人生!