刷题思路:
- 判断数据的合法性, 过滤掉非法的情况
- 确定循环跳出条件, 要么找到了(标记位置),要么找不到(跳出循环)
- 难点在于边界的判定,搞清楚边界条件
题目1:
给定⼀个按照升序排列的整数数组 nums，和⼀个⽬标值 target，找出给定⽬标值在数组中的开始位置和结 束位置。如果数组中不存在⽬标值 target，返回 [-1, -1]。
示例 1：
输⼊：nums = [5,7,7,8,8,10], target = 8
输出：[3,4]
示例 2：
输⼊：nums = [5,7,7,8,8,10], target = 6
输出：[-1,-1]
解法:
func getNumber(array:[Int], target: Int) ->(Int, Int) {
//不满足情况 返回
if array.count == 0 ||
array.first! > target ||
array.last! < target {
return (-1, -1)
}
var L = 0, R = array.count - 1, idx = R / 2
while array[idx] != target { //循环条件
if L + 1 == R { return (-1, -1) }//临近边界,找不到的情况
if array[idx] > target {
R = idx
} else {
L = idx
}
idx = (L + R) / 2
}
var tmpIdx = idx//暂存下标值
while L < idx - 1 && array[idx - 1] == target {//向左搜索
idx -= 1
}
while R > tmpIdx + 1 && array[tmpIdx + 1] == target {//向右搜索
tmpIdx += 1
}
return (idx, tmpIdx)
}
print(getNumber(array: [5,7,7,8,8,8,10,11,12,12,12,12,12,12,12,13,13,13,13], target: 12))
题目2:
给定有 n 个元素的升序整型数组 nums 和⼀个⽬标值 target，写⼀个函数搜索 nums 中的 target，如果⽬ 标值存在返回下标，否则返回 -1。
输⼊：nums = [-1,0,3,5,9,12], target = 9
输出：4
解释：9 出现在 nums 中并且下标为 4
示例 2：
输⼊：nums = [-1,0,3,5,9,12], target = 2
输出：-1
解释：2 不存在 nums 中因此返回 -1
解法:
func search(array:[Int], target: Int) -> Int {
var L = 0 , R = array.count - 1
while L <= R {
let idx = (L + R) / 2
if target == array[idx] {
return idx
} else if target < array[idx] {
R = idx - 1
} else {//target > array[idx]
L = idx + 1
}
}
return -1
}
print(search(array: [1,3,5,7,9], target: 1))
题目3:
计算非波拉切数列
1, 1, 2, 3, 5, 8, 13, 12....
解法:
//计算非波拉切数列
//方法1:
func fib(n: Int) -> Int {
//创建一个数组保存 n-1之和
var mem = [1,1]
return calc(mem: &mem, n: n)
}
//1, 1, 2, 3, 5, 8, 13, 21
@discardableResult
func calc(mem : inout [Int], n: Int) -> Int {
//滤
if n < 0 { return 0 }
//限
if mem.count > n { return mem[n] }
//定
mem.append( calc(mem: &mem, n: n - 1) + calc(mem: &mem, n: n - 2))//求第 n 项的非波拉切数列
//查
return mem[n]
}
//方法2: 自底向上推
func fibDp(n: Int) -> Int {
if n < 0 {return 0}
var list = [1, 1]
if n < 2 { return list[n] }
for i in 2...n {
let n = list[i - 1] + list[i - 2]
list.append(n)
}
return list[n]
}
//方法3: 获取第 n 项的值,其实只要获取前两项的就可以了, 于是创建两个变量,分别保存前两个的值
func fibProMax(n: Int) -> Int {
if n < 0 {return 0}
var pre_1 = 1, pre_2 = 1
if n < 2 { return 1 }
for _ in 2...n {
let cur = pre_1 + pre_2
pre_2 = pre_1
pre_1 = cur
}
return pre_1
}
//print(fib(n: -1))
//--------------------------
//前 n 项非波拉切数列之和
func fibSum(n: Int) -> Int {
if n <= 0 {return 0}
var total = 0
for i in 0...n - 1 {
total += fib(n: i)
}
return total
}
print(fibSum(n: 5))
题目4: 凑零钱问题
给你 k 种面值的硬币，面值分别为 c1, c2 ... ck，每种硬币的数量无限，再给一个总金额 amount，问你最少需要几枚硬币凑出这个金额，如果不可能凑出，算法返回 -1 。
比如说 k = 3，面值分别为 1，2，5，总金额 amount = 11。那么最少需要 3 枚硬币凑出，即 11 = 5 + 5 + 1。
/*
动态规划, 寻找最优子问题
*/
var mem = [Int]()
/// 计算最少硬币的个数
/// - Parameters:
/// - coins: 不同面值硬币的数组
/// - amount: 需要凑出的金额
/// - Returns: 需要最少的硬币个数, -1表示凑不出
func coinChange(coins:[UInt], amount:UInt) -> Int {
mem = Array(repeating: -222, count: Int(amount) + 1)
return coinDp(coins: coins, amount: amount)
}
func coinDp(coins:[UInt], amount:UInt) -> Int {
//滤
if amount == 0 {return 0}
if mem[Int(amount)] != -222 {//这个值已经有了不用再算一遍
return mem[Int(amount)]
}
//限
var res = Int.max
coins.forEach({
if amount >= $0 {//因为amount是无符号整形, 所以我要保证 amount - $0 是非负数
let subProblem = coinDp(coins: coins, amount: amount - $0)
if subProblem != -1 {//找到了的情况
res = Swift.min(res, subProblem + 1)//返回的是最少的硬币个数
}
}
})
mem[Int(amount)] = res == Int.max ? -1 : res
return mem[Int(amount)]
}
//print(coinChange(coins: [3,5,7,9], amount: 13))
快速排序 相当于前序遍历(先遍历根节点,再遍历左右节点)
/*
快速排序
*/
func fastSort(array: inout [Int], target: Int) {
sort(array: &array, L: 0, R: array.count - 1)
}
func sort(array: inout [Int], L: Int, R: Int) {
//滤
if L > R {return }
var j = R,i = L, base = array[L]
while i < j {
while i < j && array[j] >= base {
j -= 1
}
while i < j && array[i] <= base {
i += 1
}
if i < j {
array.swapAt(i, j)
}
}
array.swapAt(L, i)//此时 i == j
sort(array: &array, L: L, R: j - 1)
sort(array: &array, L: i + 1, R: R)
}
var tmpArr = [3,2,3,1,2,4,5,5,6]
fastSort(array: &tmpArr, target: 4)
print(tmpArr[tmpArr.count - 4])