新增leetcode题解--swift版本哦 leetcode题解
先设计一个Queue的协议
protocol Queue{
associatedtype Element
mutating func enqueue(_ newElement: Element)
mutating func dequeue() -> Element?
}
///一个高效的FIFO队列，其元素类型为Element
struct FIFOQueue<Element>:Queue{
private var left: [Element] = []
private var right: [Element] = []
mutating func enquene(_ newElement: Element){
right.append(newElement)
}
mutating func dequenue() -> Element?{
if left.isEmpty{
left = right.reversed()
right.removeAll()
}
return left.popLast()
}
}
为什么我们要用两个数组来实现这个队列呢？其主要原因是为了效率，可以思考一下这样设置的妙处哈！！！
接下啦我们为FIFOQueue添加Collection协议
extension FIFOQueue: Collection{
public var startIndex: Int{return 0}
public var endIndex: Int{return left.count + right .count}
//precondition的用法与assert类似，当条件不满足时，则终止程序，并打印出你设置的message或者默认的错误提示
public func index(after i: Int) -> Int {
precondition(i < endIndex)
return i + 1
}
public subscript(position: Int) -> Element{
precondition((0..<endIndex).contains(position),"Index out of bounds")
if position < left.endIndex{
return left[left.count - position - 1]
}else{
return right[position - left.count]
}
}
typealias Indices = CountableRange<Int>
var indices: CountableRange<Int>{
return startIndex..<endIndex
}
}
为了让我们用熟悉的[value1,value2,ect]语法创建一个队列，我们可以让FIFOQueue遵守ExpressibleByArrayLiteral协议
extension FIFOQueue: ExpressibleByArrayLiteral{
public init(arrayLiteral elements: Element...) {
left = elements.reversed()
right = []
}
}
题目：寻找到100以内同时满足是偶数并且还是其他数字的平方的数字
(1...<10).map{$0 * $0}.filter{ $0 % 2 == 0}
//[4,16,36,64]
还记得我们最常见的for in 循环吗？ 他的实现就是基于迭代器
protocol Sequence {
associatedtype Iteraator: IteratorProtocol
func makeIterator() -> Iterator
//...
}
protocol IteratorProtocol {
associatedtype Element
mutating func next() -> Element?
}
//那么for in 循环是怎么实现的呢？
var iterator = someSequence.makeIterator()
while let element = iterator.next() {
doSomething(with: element)
}
那么斐波那契序列怎么依靠迭代器实现呢？
struct Fibs: ItreatorProtocol {
var state = (0,1)
mutating func next() -> Int? {
let upcomingNumber = state.0
state = (state.1,state.0 + state.1)
return upcomingNumber
}
}
//这样就实现了斐波那契数列
//那么要如何使用呢？
var textFib = Fib()
while let fib = textFib.next(), fib < 1000000000{
print(fib)
}
这样就很顺利的打印了1000000000以内的斐波那契数，而且速度很快
class ListNode{
var val: Int
var next: ListNode?
init(_ val: Int) {
self.val = val
self.next = nil
}
}
class List{
var head: ListNode?
var real: ListNode?
//尾插法
func appendToReal(_ val: Int){
if real == nil {
real = ListNode(val)
head = real
}else{
real!.next = ListNode(val)
real = real!.next
}
}
//头插法
func appendToHead(_ val: Int){
if head == nil{
head = ListNode(val)
real = head
}else{
let temp = ListNode(val)
temp.next = head
head = temp
}
}
func printList(){
var temp = head
while temp != nil {
print(temp!.val)
temp = temp!.next
}
}
}
let textList = List()
[1,2,3,4,5].map{
textList.appendToHead($0)
}
textList.printList()