2020-08-18

215. 数组中的第K个最大元素

在未排序的数组中找到第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。
示例 1:
输入: [3,2,1,5,6,4] 和 k = 2
输出: 5
示例 2:
输入: [3,2,3,1,2,4,5,5,6] 和 k = 4
输出: 4

  func findKthLargest(_ nums: [Int], _ k: Int) -> Int {
        var nums = nums
        var start = 0, end = nums.count - 1
        var target = partition(&nums, start, end)
        while target != k - 1 {
            if target > k - 1 {
                end = target - 1
            }
            if target < k - 1 {
                start = target + 1
            }
            target = partition(&nums, start, end)
        }
        return nums[target]
    }
    
    // MARK: 左右指针法
    func partition(_ nums: inout [Int], _ start: Int, _ end: Int) -> Int {
        var start = start, end = end
        let pivotElement = nums[start]
        let pre = start
        while start < end {
            
            while start < end && nums[end] < pivotElement {
                end -= 1
            }
            while start < end && nums[start] >= pivotElement {
                start += 1
            }
            
            (nums[start], nums[end]) = (nums[end], nums[start])
        }
        (nums[pre], nums[start]) = (nums[start], nums[pre])
        return start
    }
    
    
    // 这一段与moveZero里的方法很相似 前半部分是稳定的。后半部分不稳定
    // 交换
    func partition_1(_ arr: inout [Int], _ start: Int, _ end: Int) -> Int {
        let pivot = arr[end]
        var i = start
        for j in stride(from: start, to: end, by: 1) {
            if arr[j] > pivot {
                (arr[i], arr[j]) = (arr[j], arr[i])
                i += 1
            }
        }
        (arr[i], arr[end]) = (arr[end], arr[i])
        return i
    }

9. 回文数

判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
示例 1:
输入: 121
输出: true
示例 2:
输入: -121
输出: false
解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
示例 3:
输入: 10
输出: false
解释: 从右向左读, 为 01 。因此它不是一个回文数。

方法一;

/*
  1111           div = 1
 1111 / 1 = 1111 > 10    div = 10
 1111 / 10 = 111 > 10     div = 100
 1111 / 100 = 11    div = 1000
 1111 / 1000 = 1

 left = 1
 
 1111 % 1000   = 111 / 10 = 11
 div = 10
 x = 1111 % 1000 = 111 / 1
 
 div = 11
举个例子：1221 这个数字。

通过计算 1221 / 1000， 得首位1
通过计算 1221 % 10， 可得末位 1
进行比较
再将 22 取出来继续比较

*/
    func isPalindrome(_ x: Int) -> Bool {
        var x = x
        if x < 0 {return false}
        var div = 1
        while x / div >= 10 {
            div *= 10
        }
        
        if x > 0 {
            let left = x / div // 首位
            let right = x % 10  // 末位
            if left != right {return false}
            x = (x % div) / 10 
             // 比如 1111 此时div = 1000 要使得1111变成11就是让1111 / 1000 = 111 % 10 = 11
             // 因为 1111 变成11相等于div除了100所以这时应该让div /= 100 ,div = 10
            div /= 100
        }
        return true
    }

方法二:

直观上来看待回文数的话，就感觉像是将数字进行对折后看能否一一对应。
所以这个解法的操作就是 取出后半段数字进行翻转。
这里需要注意的一个点就是由于回文数的位数可奇可偶，所以当它的长度是偶数时，它对折过来应该是相等的；当它的长度是奇数时，那么它对折过来后，有一个的长度需要去掉一位数（除以 10 并取整）。
具体做法如下：
每次进行取余操作 （ %10），取出最低的数字：y = x % 10
将最低的数字加到取出数的末尾：revertNum = revertNum * 10 + y
每取一个最低位数字，x 都要自除以 10
判断 x 是不是小于 revertNum ，当它小于的时候，说明数字已经对半或者过半了
最后，判断奇偶数情况：如果是偶数的话，revertNum 和 x 相等；如果是奇数的话，最中间的数字就在revertNum 的最低位上，将它除以 10 以后应该和 x 相等。

  func isPalindromr2(_ x: Int) -> Bool {
        if x < 0 || (x % 10 == 0 && x != 0) {return false}
        var x = x
        var reverseNumber = 0
        while x > reverseNumber {
            //  1111  reverseNumber = 1, x = 111
            // 121  reverseNumber = 1, x = 12, => reverseNumber = 12 , x = 1
            reverseNumber = reverseNumber * 10 + x % 10
            x /= 10
        }
        return reverseNumber == x || x == reverseNumber / 10
    }