來一次有側重點的區分Swift與Objective-C

class Class {
    // class definition goes here
}

struct Structure {
    // structure definition goes here
}

NSObject *v1 = [NSObject new];
NSString *v2 = [NSString new];
NSNumber *v3 = [NSNumber new];
NSArray *array = @[v1, v2, v3];
for (id obj in array) {
    [obj boolValue];
}

@protocol SafeProtocol <NSObject>
- (void)func;
@end

@interface SafeObj : NSObject<SafeProtocol>
@end
@implementation SafeObj
- (void)func {

}
@end

@interface UnSafeObj : NSObject
@end
@implementation UnSafeObj
@end

SafeObj *v1 = [[SafeObj alloc] init];
UnSafeObj *v2 = [[UnSafeObj alloc] init];
// 由於v2沒有實現協議SafeProtocol，所以此處Xcode會有警告
// Object of type 'UnSafeObj *' is not compatible with array element type 'id'
NSArray> *array = @[v1, v2];
for (id obj in array) {
    [obj func];
}

// 直接報錯，而不是警告
// Cannot convert value of type 'String' to expected argument type 'NSNumber'
var array: [NSNumber] = []
array.append(1)
array.append("a")

class ViewCotroller: UIViewController {   
    func myMethod() {

    }
}

class AnotherViewController: UITableViewController {
    func myMethod() {

    }
}

protocol P {
    func myMethod()
}
extension P {
    func myMethod() {
        doWork()
    }
}

extension ViewController: P { }
extension AnotherViewController: P { }

viewController.myMethod()
anotherViewController.myMethod()

import UIKit

protocol ChainListAble {
    associatedtype T: Equatable
    // 列印
    var description: String{get}
    // 數量
    var count: Int{get}

    /// 插入
    func insertToHead(node: Node)
    func insertToHead(value: T)
    func insertToTail(node: Node)
    func insertToTail(value: T)
    func insert(node: Node, afterNode: Node) -> Bool
    func insert(value: T, afterNode: Node) -> Bool
    func insert(node: Node, beforNode: Node) -> Bool
    func insert(value: T, beforNode: Node) -> Bool

    /// 刪除(預設第一個符合條件的)
    @discardableResult func delete(node: Node) -> Bool
    @discardableResult func delete(value: T) -> Bool
    @discardableResult func delete(index: Int) -> Bool
    //func delete(fromIndex: Int, toIndex: Int) -> Bool
    //func deleteAll()

    /// 查詢(預設第一個符合條件的)
    func find(value: T) -> Node?
    func find(index: Int) -> Node?

    /// 判斷結點是否在連結串列中
    func isContain(node: Node) -> Bool
}

/// [值型別不能在遞迴裡呼叫](https://www.codetd.com/article/40263)，因此Node型別只能是class而不是struct
// 有些時候你只能使用類而不能使用結構體，那就是遞迴裡
// struct報錯：Value type 'Node' cannot have a stored property that recursively contains it
class Node {
    var value: T
    var next: Node?

    /// 便利構造方法
    ///
    /// - Parameter value: value
    convenience init(value: T) {
        self.init(value: value, next: nil)
    }

    /// 預設指定初始化方法
    ///
    /// - Parameters:
    ///   - value: value
    ///   - next: next
    init(value: T, next: Node?) {
        self.value = value
    }

    // 銷毀函式
    deinit {
        print("(self.value) 釋放")
    }
}

extension Node {
    /// 傳回當前結點到連結串列尾的長度
    var count: Int {
        var idx: Int = 1
        var node: Node? = self
        while node?.value != nil {
            node = node?.next
            idx = idx + 1
        }
        return idx
    }
}

class SingleChainList: ChainListAble {
    typealias T = String
    // 哨兵結點，不儲存資料
    private var dummy: Node = Node.init(value: "")
}
extension SingleChainList {
    var description: String {
        var description: String = ""
        var tempNode = self.dummy
        while let nextNode = tempNode.next {
            description = description + " " + nextNode.value
            tempNode = nextNode
        }
        return description
    }
    var count: Int {
        var count: Int = 0
        var tempNode = self.dummy
        while let nextNode = tempNode.next {
            count = count + 1
            tempNode = nextNode
        }
        return count
    }

    /// 在頭部插入值
    ///
    /// - Parameter value: value
    func insertToHead(value: T) {
        let node: Node = Node.init(value: value)
        self.insertToHead(node: node)
    }
    /// 在頭部插入結點
    ///
    /// - Parameter node: node
    func insertToHead(node: Node) {
        node.next = self.dummy.next
        self.dummy.next = node
    }
    /// 在尾部插入值
    ///
    /// - Parameter value: value
    func insertToTail(value: T) {
        let node: Node = Node.init(value: value)
        self.insertToTail(node: node)
    }
    /// 在尾部插入結點
    ///
    /// - Parameter node: node
    func insertToTail(node: Node) {
        var tailNode: Node = self.dummy
        while let nextNode = tailNode.next {
            tailNode = nextNode
        }
        tailNode.next = node
    }
    /// 在指定結點的後面插入新value
    ///
    /// - Parameters:
    ///   - value: 新值
    ///   - afterNode: 指定結點
    /// - Returns: true or false
    func insert(value: T, afterNode: Node) -> Bool {
        let node: Node = Node.init(value: value)
        return self.insert(node: node, afterNode: afterNode)
    }
    /// 在指定結點的後面插入新結點
    ///
    /// - Parameters:
    ///   - value: 新結點
    ///   - afterNode: 指定結點
    /// - Returns: true or false
    func insert(node: Node, afterNode: Node) -> Bool {
        guard self.isContain(node: afterNode) else {
            return false
        }
        node.next = afterNode.next
        afterNode.next = node
        return true
    }
    /// 在指定結點的前面插入新value(雙向連結串列實現這種插入方式速度比單向鏈錶快)
    ///
    /// - Parameters:
    ///   - value: 新值
    ///   - beforNode: 指定結點
    /// - Returns: true or false
    func insert(value: T, beforNode: Node) -> Bool {
        let node: Node = Node.init(value: value)
        return self.insert(node: node, beforNode: beforNode)
    }
    /// 在指定結點的前面插入新結點(雙向連結串列實現這種插入方式速度比單向鏈錶快)
    ///
    /// - Parameters:
    ///   - node: 新結點
    ///   - beforNode: 指定結點
    /// - Returns: true or false
    func insert(node: Node, beforNode: Node) -> Bool {
        var tempNode: Node = self.dummy
        while let nextNode = tempNode.next {
            if nextNode === beforNode {
                node.next = beforNode
                tempNode.next = node
                return true
            }
            tempNode = nextNode
        }
        return false
    }
    /// 刪除指定value的結點
    ///
    /// - Parameter value: value
    /// - Returns: true or false
    func delete(value: T) -> Bool {
        var tempNode: Node = self.dummy
        while let nextNode = tempNode.next {
            // 此處判斷 == 是否合理
            if nextNode.value == value {
                tempNode.next = nextNode.next
                return true
            }
            tempNode = nextNode
        }
        return false
    }
    /// 刪除指定的結點
    ///
    /// - Parameter node: node
    /// - Returns: true or false
    func delete(node: Node) -> Bool {
        var tempNode = self.dummy
        while let nextNode = tempNode.next {
            if nextNode === node {
                tempNode.next = nextNode.next
                return true
            }
            tempNode = nextNode
        }
        return false
    }
    /// 刪除指定下標的結點
    ///
    /// - Parameter index: index
    /// - Returns: true or false
    func delete(index: Int) -> Bool {
        var idx: Int = 0
        var tempNode: Node = self.dummy
        while let nextNode = tempNode.next {
            if index == idx {
                tempNode.next = nextNode.next
                return true
            }
            tempNode = nextNode
            idx = idx + 1
        }
        return false
    }

    /// 查詢指定值的node
    ///
    /// - Parameter value: value
    /// - Returns: node
    func find(value: T) -> Node? {
        var tempNode = self.dummy
        while let nextNode = tempNode.next {
            if nextNode.value == value {
                return nextNode
            }
            tempNode = nextNode
        }
        return nil
    }
    /// 查詢指定下標的結點
    ///
    /// - Parameter index: index
    /// - Returns: node
    func find(index: Int) -> Node? {
        var idx: Int = 0
        var tempNode: Node = self.dummy
        while let nextNode = tempNode.next {
            if index == idx {
                return nextNode
            }
            tempNode = nextNode
            idx = idx + 1
        }
        return nil
    }
    /// 判斷給定的連結串列是否在連結串列中
    ///
    /// - Parameter node: node
    /// - Returns: true or false
    func isContain(node: Node) -> Bool {
        var tempNode = self.dummy.next
        while tempNode != nil {
            if tempNode === node {
                return true
            }
            tempNode = tempNode?.next
        }
        return false
    }
    /// 單向連結串列反轉：方式一非遞迴實現
    ///
    /// - Parameter chainList: 源連結串列
    /// - Returns: 反轉後的連結串列
    func reverseList() {
        var prevNode: Node? = self.dummy.next
        var curNode: Node? = prevNode?.next
        var tempNode: Node? = curNode?.next
        prevNode?.next = nil
        while curNode != nil {            
            tempNode = curNode?.next
            curNode?.next = prevNode
            prevNode = curNode
            curNode = tempNode
        }
        self.dummy.next = prevNode
    }
    /// 單向連結串列反轉：方式二遞迴實現
    ///
    /// - Parameter chainList: 源連結串列
    /// - Returns: 反轉後的連結串列
    func reverseListUseRecursion(head: Node?, isFirst: Bool) {
        var tHead = head
        if isFirst {
            tHead = self.dummy.next
        }
        guard let rHead = tHead else { return }
        if rHead.next == nil {
            self.dummy.next = rHead
            return
        }
        else {
            self.reverseListUseRecursion(head:rHead.next, isFirst: false)
            rHead.next?.next = rHead
            rHead.next = nil
        }
    }
}

class LinkedListVC: UIViewController {
    var chainList: SingleChainList = SingleChainList.init()
    override func viewDidLoad() {
        super.viewDidLoad()
        // 初始化連結串列
        for i in 0..<10 {
            let node: Node = Node.init(value: String(i))
            chainList.insertToTail(node: node)
        }
        // 查詢結點
        for i in 0..<12 {
            if let find: Node = chainList.find(index: i) {
                debugPrint("find = (find.value)")
            }
            else {
                debugPrint("not find idx = (i)")
            }
        }
        // 刪除結點
        if chainList.delete(index: 10) {
            debugPrint("刪除 index = (index)成功")
        }
        else {
            debugPrint("刪除 index = (index)失敗")
        }
        // 列印結點value資訊
        debugPrint(chainList.description)
        // 列印結點個數
        debugPrint(chainList.count)
        // 單向連結串列反轉
        chainList.reverseList()
        // 列印結點value資訊
        debugPrint(chainList.description)
        // 單向連結串列反轉
        chainList.reverseListUseRecursion(head: nil, isFirst: true)
        // 列印結點value資訊
        debugPrint(chainList.description)
    }
}