学习时用的Java，那就想用Swift实现一下
一、栈
- 本质上是静态数据结构
- 栈是数组的子集
栈需要实现的方法：
Stack
· func push(E)
· func pop() -> E
· var peek -> E
· var count -> int
· var isEmpty -> Bool
栈的swift代码实现：
public struct Stack<T> {
fileprivate var stackArr = [T]()
public var isEmpty: Bool {
return stackArr.isEmpty
}
public var count: Int {
return stackArr.count
}
public var peek: T? {
return isEmpty ? nil : stackArr.last
}
public mutating func push(_ element: T) {
stackArr.append(element)
}
public mutating func pop() -> T? {
return isEmpty ? nil : stackArr.removeLast()
}
public mutating func printElements() {
guard !isEmpty else {
print("stack is empty!")
return
}
print("stack elements: \n")
for (index, value) in stackArr.enumerated() {
print("index: \(index) value: \(value)]")
}
}
}
二、队列
- 本质上是静态数据结构
- 队列是数组的子集
- 牺牲空间换时间
队列要实现的方法：
Queue
· func enqueue(E)
· func dequeue() -> E
· var front -> E
· var count -> int
· var isEmpty -> Bool
队列的swift代码实现：
public struct Queue<T> {
fileprivate var queueArr = [T]()
public var isEmpty: Bool {
return queueArr.isEmpty
}
public var count: Int {
return queueArr.count
}
public var front: T? {
return isEmpty ? nil : queueArr.first
}
public mutating func enqueue(_ element: T) {
queueArr.append(element)
}
public mutating func dequeue() -> T? {
return isEmpty ? nil : queueArr.removeFirst()
}
public mutating func printElements() {
guard !isEmpty else {
print("queue is empty!")
return
}
print("queue elements: \n")
for (index, value) in queueArr.enumerated() {
print("index: \(index) value: \(value)]")
}
}
}
三、链表
-
最简单的动态数据结构
-
通过链表更深入理解引用（指针）
-
通过链表更深入理解递归结构
-
可以实现栈或者队列这两种数据结构
-
组成更加复杂的数据结构
与数组相比：
数组是：
- 牺牲空间换时间：使用复杂度O(1)的随机访问
链表是：
- 牺牲时间换空间：节点存储省空间，但通过遍历节点找元素，丧失了随机访问能力
链表要实现的方法：
class LinkedList {
· class Node {
· var element
· var next
· var previous
}
· var head
· var first -> head
· var last -> node
· var count -> int
· var isEmpty -> Bool
· func node(index) -> Node
· func appendToTail(element)
· func insertToHead(element)
· func insert(node, index)
· func removeAll()
· func removeLast()
· func removeAt(index) -> element
· func remove(Node) -> element
}
链表的swift代码实现：
public class LinkedList<T> {
public class LinkedListNode<T> {
var value: T
var next: LinkedListNode?
weak var previous: LinkedListNode?
public init(value: T) {
self.value = value
}
}
public typealias Node = LinkedListNode<T>
public var isEmpty: Bool {
return head == nil
}
public var count: Int {
guard var node = head else {
return 0
}
var count = 1
while let next = node.next {
node = next
count += 1
}
return count
}
private var head: Node?
public var first: Node? {
return head
}
public var last: Node? {
guard var node = head else {
return nil
}
//until node.next is nil
while let next = node.next {
node = next
}
return node
}
public func node(atIndex index: Int) -> Node? {
if index == 0 {
//head node
return head!
} else {
var node = head!.next
guard index < count else {
return nil;
}
for _ in 1..<index {
node = node?.next
if node == nil {
break
}
}
return node!
}
}
public func appendToTail(value: T) {
let newNode = Node(value: value)
if let lastNode = last {
newNode.previous = lastNode
lastNode.next = newNode
} else {
head = newNode
}
}
public func insertToHead(value: T) {
let newHead = Node(value: value)
if head == nil {
head = newHead
}else {
newHead.next = head
head?.previous = newHead
head = newHead
}
}
public func insert(_ node: Node, atIndex index: Int) {
if index < 0 {
print("invalid input index")
return
}
let newNode = node
if count == 0 {
head = newNode
}else {
if index == 0 {
newNode.next = head
head?.previous = newNode
head = newNode
} else {
if index > count {
print("out of range")
return
}
let prev = self.node(atIndex: index-1)
let next = prev?.next
newNode.previous = prev
newNode.next = prev?.next
prev?.next = newNode
next?.previous = newNode
}
}
}
public func removeAll() {
head = nil
}
public func removeLast() -> T? {
guard !isEmpty else {
return nil
}
return remove(node: last!)
}
public func remove(node: Node) -> T? {
guard head != nil else {
return nil
}
let prev = node.previous
let next = node.next
if let prev = prev {
prev.next = next
} else {
head = next
}
next?.previous = prev
node.previous = nil
node.next = nil
return node.value
}
public func removeAt(_ index: Int) -> T? {
guard head != nil else {
return nil
}
let node = self.node(atIndex: index)
guard node != nil else {
return nil
}
return remove(node: node!)
}
}
四、一句话总结
有了这三个基本的数据结构，之后就可以使用它们作为基础，进一步的学习了。
