排序算法之選擇排序、冒泡排序、快速排序(C#)

打算學習一下排序算法，記錄一下方便以後複習。首先介紹一下不同種類的排序算法的複雜度

排序法	最差時間分析	平均時間複雜度	穩定度	空間複雜度
冒泡排序	O(n2)	O(n2)	穩定	O(1)
快速排序	O(n2)	O(n*log2n)	不穩定	O(log2n)~O(n)
選擇排序	O(n2)	O(n2)	穩定	O(1)
二叉樹排序	O(n2)	O(n*log2n)	不穩定	O(n)
插入排序	O(n2)	O(n2)	穩定	O(1)
堆排序	O(n*log2n)	O(n*log2n)	不穩定	O(1)
希爾排序	O	O	不穩定	O(1)

選擇排序

選擇排序，兩次for循環，遍歷數組，最外層的for循環假選定i爲最小值的下標。下層for循環遍歷數組，找到最小的下表。對元素交換。繼續遍歷，這就是選擇排序。選擇排序菜鳥教程鏈接
下面是菜鳥教程的動態圖，我直接引用了。

下面是選擇排序的C#代碼

		/// <summary>
        /// 選擇排序
        /// </summary>
        /// <param name="nums"></param>
        /// <returns></returns>
        public int[] selectSort(int[] nums)
        {
            for (int i = 0; i < nums.Length; i++)
            {
                int minVal = i;
                for (int j = i + 1; j < nums.Length; j++)
                {
                    if (nums[j]<nums[i])
                    {
                        minVal = j;
                    }
                }
                if (i!=minVal)
                {
                    int temp = nums[i];
                    nums[i] = nums[minVal];
                    nums[minVal] = temp;
                }
            }
            return nums;
        }

冒泡排序

同樣兩個for循環，比較前後兩個數字大小，按所需排序交換前後兩個數字。

C#代碼如下

		/// <summary>
        /// 冒泡排序
        /// </summary>
        /// <param name="nums"></param>
        public void BubbleSort(int[] nums)
        {
            for (int i = 0; i < nums.Length-1; i++)
            {
                for (int j = 0; j < nums.Length-1-i; j++)
                {
                    if (nums[i]<nums[j])
                    {
                        int temp = nums[j];
                        nums[j] = nums[i];
                        nums[i] = temp;
                    }
                }
            }
        }

快速排序

將數組中的一個元素，該元素爲基準，大於該元素放在右側，小於該元素放在左側。之後對該基準元素左側、右側按同樣方式遞歸。

代碼如下

		
		/// <summary>
        /// 快速排序
        /// </summary>
        /// <param name="nums">數組</param>
        /// <param name="l">數組排序開始位置</param>
        /// <param name="r">排序結束位置</param>
        public void QuickSort(int[] nums, int l, int r)
        {
            //數組爲空結束(特殊情況判斷)
            if (nums == null || nums.Count() == 0)
            {
                return;
            }
            //右側大於左側結束
            if (l >= r)
            {
                return;
            }
            //調用一次 排序 並查找基準值位置
            int pivot = sortOnce(nums, l, r);
            //遞歸
            QuickSort(nums, l, pivot - 1);
            QuickSort(nums, pivot + 1, r);
        }

        public int sortOnce(int[] nums, int left, int right)
        {
            //以最左側爲基準
            int pivot = nums[left];
            while (left < right)
            {
                //右側開始循環 存在小於,就賦值給左側
                while (nums[right] >= pivot && left < right)
                {
                    right--;
                }
                nums[left] = nums[right];
                while (nums[left] <= pivot && left < right)
                {
                    left++;
                }
                nums[right] = nums[left];
            }
            //基準值賦值回數組 並返回基準位置
            nums[left] = pivot;
            return left;
        }