LeetCode排序数组Swift 冒泡排序、快速排序 面试

给你一个整数数组 nums，请你将该数组升序排列。

 

示例 1：

输入：nums = [5,2,3,1]
输出：[1,2,3,5]

 

冒泡排序

class Solution {
    func sortArray(_ nums: [Int]) -> [Int] {
        guard nums.count > 1 else {
            return nums
        }
        var nums = nums
        //一共需要 nums.count - 1 趟
        for i in 0 ..< nums.count - 1 {
            //一趟冒泡一个最小的数 一趟需要比较的次数
            for j in 0 ..< nums.count - 1 - i {
                if nums[j] > nums[j + 1] {
                    (nums[j + 1],nums[j]) = (nums[j],nums[j + 1])
                }
            }
        }
        return nums
    }
}

 

 

快速排序

快速排序作为分治代表，通常实现由三步

1、数据中选择一个元素作为”基准”（pivot），通常选取最后一个元素；
2、分区(partition) 所有小于”基准”的元素，都移到”基准”的左边；所有大于”基准”的元素，都移到”基准”的右边。分区操作结束后，基准元素所处的位置就是最终排序后它的位置。
3、对”基准”左边和右边的两个子集，不断重复第一步和第二步，直到所有子集只剩下一个元素为止。

 

class Solution {
    //快速排序
    func sortArray(_ nums: [Int]) -> [Int] {
        var arr = nums
        quickSort(&arr, 0, arr.count - 1)
        return arr
    }

    private func quickSort(_ nums: inout [Int], _ left: Int, _ right: Int) {
        if left >= right {
            return
        }
        var i = left;
        var j = right;
        let key = nums[i];
        while i<j {
            while i<j && nums[j] >= key{
                j -= 1;
            }
            nums[i] = nums[j];
            while i<j && nums[i] <= key{
                i += 1;
            }
            nums[j] = nums[i]
        }
        nums[i] = key;
        self.quickSort(&nums, left, i-1)
        self.quickSort(&nums, i+1, right)
    }
}

 

不知道为啥，LeetCode 超出时间限制，我猜测现状是，一个已经排好序的很大的数组，这种情况下排序，是快排最差的情况，时间复杂度是 O(n²) ，有知道怎么解决的网友吗

 

 

 

 

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-an-array
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。