Swift Tips

[lefex]

public typealias RBNode = RBTreeNode

重命名

[lefex]

private enum RBTreeColor {
case red
case black
}

枚举

[lefex]

public class RBTreeNode<T: Comparable>: Equatable { }

[lefex]

public convenience init(key: T?) {
self.init(key: key, leftChild: RBNode(), rightChild: RBNode(), parent: RBNode())
}

public init(key: T?, leftChild: RBNode?, rightChild: RBNode?, parent: RBNode?) { }

[lefex]

var isLeaf: Bool {
return rightChild == nil && leftChild == nil
}
不是函数哈

[lefex]

var isLeaf: Bool {
return rightChild == nil && leftChild == nil
}

[lefex]

fileprivate(set) var root: RBNode

[lefex]

extension RBTreeNode {
static public func == (lhs: RBTreeNode, rhs: RBTreeNode) -> Bool {
return lhs.key == rhs.key
}
}

[lefex]

if let leftChild = leftChild, !leftChild.isNullLeaf {
return leftChild.maximum()
}

[lefex]

// If node nil -> key not found
guard let node = node else {
return nil
}

guard let inputKey = input.key, let nodeKey = node.key else {
return
}

[lefex]

// MARK: - Inserting new nodes

[lefex]

extension RBTreeNode: CustomStringConvertible {
public var description: String {
var s = ""
if isNullLeaf {
s += "nullLeaf"
} else {
if let left = leftChild {
s += "((left.description)) <- "
}
return s
}
}

[lefex]

extension TreeNode where T: Equatable { }

[lefex]

private func insert(_ key: KeyType, val: Any) { }

[lefex]

private var cache: [KeyType: Any] = [:]

[lefex]

public mutating func sort() -> [T] {}

[lefex]

private var orderCriteria: (T, T) -> Bool

/**

• Creates an empty heap.
• The sort function determines whether this is a min-heap or max-heap.
• For comparable data types, > makes a max-heap, < makes a min-heap.
  */
  public init(sort: @escaping (T, T) -> Bool) {
  self.orderCriteria = sort
  }

[lefex]

@inline(__always) internal func parentIndex(ofIndex i: Int) -> Int {
return (i - 1) / 2
}

[lefex]

public mutating func insert<S: Sequence>(_ sequence: S) where S.Iterator.Element == T {
for value in sequence {
insert(value)
}
}

[lefex]

@discardableResult public mutating func remove() -> T? { }

[lefex]

var h1 = Heap(array: [5, 13, 2, 25, 7, 17, 20, 8, 4], sort: >)

[lefex]

func partitionDutchFlag<T: Comparable>(_ a: inout [T], low: Int, high: Int, pivotIndex: Int) -> (Int, Int) {