几种排序（c#实现）

最新推荐文章于 2022-09-20 19:00:00 发布

weixin_30326745

最新推荐文章于 2022-09-20 19:00:00 发布

阅读量143

点赞数

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/wskxy/p/10988341.html

版权

　　代码：

            int[] arr = { 2, 3, 4, 6, 1, 5, 4 };
            // 冒泡排序：把最小的往前冒 O(n²)
            //int temp1;
            //for (int i = 0; i < arr.Length - 1; i++)
            //{
            //    for (int j = i + 1; j < arr.Length; j++)
            //    {
            //        if (arr[j] < arr[i])
            //        {
            //            temp1 = arr[j];
            //            arr[j] = arr[i];
            //            arr[i] = temp1;
            //        }
            //    }
            //}
            // 选择排序：从小到大依次选出来 O(n²)
            //for (int i = 0; i < arr.Length - 1; i++)
            //{
            //    int temp2 = arr[i];
            //    int index = i;
            //    for (int j = i + 1; j < arr.Length; j++)
            //    {
            //        if (arr[j] < temp2)
            //        {
            //            temp2 = arr[j];
            //            index = j;
            //        }
            //    }
            //    arr[index] = arr[i];
            //    arr[i] = temp2;
            //}
            // 直接插入排序：适合基本有序 O(n²)
            //for (int i = 1; i < arr.Length; i++)
            //{
            //    int temp = arr[i];
            //    int j;
            //    for (j = i - 1; j >= 0; j--)
            //    {
            //        if (temp > arr[j])
            //        {
            //            break;
            //        }
            //        arr[j + 1] = arr[j];
            //    }
            //    arr[j + 1] = temp;
            //}
            // 希尔排序
            //int gap = arr.Length / 2;
            //while (gap >= 1)
            //{
            //    // 把距离为 gap 的元素编为一个组，扫描所有组
            //    for (int i = gap; i < arr.Length; i++)
            //    {
            //        int j = 0;
            //        int temp = arr[i];
            //        // 对距离为 gap 的元素组进行排序
            //        for (j = i - gap; j >= 0 && temp < arr[j]; j = j - gap)
            //        {
            //            arr[j + gap] = arr[j];
            //        }
            //        arr[j + gap] = temp;
            //    }
            //    gap = gap / 2;
            //}



            for (int i = 0; i < arr.Length; i++)
            {
                Console.WriteLine(arr[i]);
            }
            Console.ReadLine();

　　程序员内功修炼（排序）

        /// <summary>
        /// 直接插入排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static int[] InsertionSort(int[] arr)
        {
            /*
             数据结构-数组
             最差时间复杂度-输入的序列为降序，复杂度为O(n^2)
             最优时间复杂度-输入的序列为升序，复杂度为O(n)
             辅助空间-O(1)
             稳定性-稳定
             */
            for (int i = 1; i < arr.Length; i++)
            {
                int temp = arr[i];
                int j = i - 1;
                while (j >= 0 && temp < arr[j])
                {
                    arr[j + 1] = arr[j];
                    j--;
                }
                arr[j + 1] = temp;
            }
            return arr;
        }
        /// <summary>
        /// 二分插入排序（是对直接插入排序的改进）
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static int[] BinarySort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-输入的序列为降序，复杂度为O(n^2)
            最优时间复杂度-输入的序列为升序，复杂度为O(log2 n)
            辅助空间-O(1)
            稳定性-稳定
            */
            for (int i = 1; i < arr.Length; i++)
            {
                int temp = arr[i];
                int low = 0;
                int high = i - 1;
                while (low <= high)
                {
                    int mid = (low + high) / 2;
                    if (temp >= arr[mid])
                        low = mid + 1;
                    else
                        high = mid - 1;
                }
                for (int j = i - 1; j >= low; j--)
                {
                    arr[j + 1] = arr[j];
                }
                arr[low] = temp;
            }
            return arr;
        }
        /// <summary>
        /// 希尔排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static int[] ShellSort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-根据步长的不同而不同，已知最好的为O(n(log2 n)^2)
            最优时间复杂度-O(n)
            辅助空间-O(1)
            稳定性-不稳定
            */
            for (int gap = arr.Length / 2; gap >= 1; gap = gap / 2)
            {
                for (int i = gap; i < arr.Length; i++)
                {
                    int temp = arr[i];
                    int j = i - gap;
                    while (j >= 0 && temp < arr[j])
                    {
                        arr[j + gap] = arr[j];
                        j = j - gap;
                    }
                    arr[j + gap] = temp;
                }
            }
            return arr;
        }
        /// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static int[] BubbleSort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-O(n^2)
            最优时间复杂度-O(n^2)
            辅助空间-O(1)
            稳定性-稳定
            */
            for (int i = 0; i < arr.Length - 1; i++)
            {
                for (int j = i + 1; j < arr.Length; j++)
                {
                    if (arr[j] < arr[i])
                    {
                        int temp = arr[j];
                        arr[j] = arr[i];
                        arr[i] = temp;
                    }
                }
            }
            return arr;
        }
        /// <summary>
        /// 快速排序（目前最好的排序）
        /// </summary>
        /// <param name="arr"></param>
        /// <param name="low"></param>
        /// <param name="high"></param>
        /// <returns></returns>
        public static int[] QuickSort(int[] arr, int low, int high)
        {
            /*
            数据结构-数组
            最差时间复杂度-每次选取的基准值都是最大或者最小O(n^2)
            最优时间复杂度-每次选取的基准值都是中位数O(nlogn)
            辅助空间-主要是递归造成的栈空间的使用，取决于递归树的深度，一般为O(logn)，最差为O(n)
            稳定性-不稳定
            */
            if (low >= high)
                return arr;
            int i = low;
            int j = high;
            int temp = arr[i];//基准值
            while (i < j)//从两端向中间扫描,跳出循环时i=j
            {
                while (i < j && arr[j] >= temp)//从右往左
                    j--;
                arr[i] = arr[j];
                while (i < j && arr[i] <= temp)//从左往右
                    i++;
                arr[j] = arr[i];
            }
            arr[i] = temp;// 基准值回归正确位置
            QuickSort(arr, low, i - 1);
            QuickSort(arr, i + 1, high);
            return arr;
        }
        /// <summary>
        /// 直接选择排序
        /// </summary>
        /// <param name="arr"></param>
        /// <returns></returns>
        public static int[] SelectionSort(int[] arr)
        {
            /*
            数据结构-数组
            最差时间复杂度-O(n^2)
            最优时间复杂度-O(n^2)
            辅助空间-O(1)
            稳定性-不稳定
            */
            for (int i = 0; i < arr.Length - 1; i++)
            {
                int k = i; // k指向最小值索引
                for (int j = i + 1; j < arr.Length; j++)
                    if (arr[j] < arr[k])
                        k = j;
                if (k != i)
                {
                    int temp = arr[i];
                    arr[i] = arr[k];
                    arr[k] = temp;
                }
            }
            return arr;
        }

转载于:https://www.cnblogs.com/wskxy/p/10988341.html

weixin_30326745

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
几种排序（c#实现）

　　代码： int[] arr = { 2, 3, 4, 6, 1, 5, 4 }; // 冒泡排序：把最小的往前冒 O(n2) //int temp1; //for (int i = 0; i < arr.Length - 1; i++) //{ ...
复制链接

扫一扫