使用Swift學(xué)習(xí)數(shù)據(jù)結(jié)構(gòu)和算法

stract.png
  • 主要分享最近學(xué)習(xí)的數(shù)據(jù)結(jié)構(gòu)和排序算法
  • 文章只涉及每一種數(shù)據(jù)結(jié)構(gòu)通過代碼實(shí)現(xiàn)的函數(shù)定義
  • 涉及的每一種數(shù)據(jù)結(jié)構(gòu)或者算法基本都通過代碼實(shí)現(xiàn)了
  • GitHub代碼地址: 數(shù)據(jù)結(jié)構(gòu)和算法

線性表

linear_list.png

鏈表

  • 鏈表是一種鏈?zhǔn)酱鎯Φ木€性結(jié)構(gòu), 所有元素的內(nèi)存地址不一定是連續(xù)的
  • 下表是為四種鏈表和測試項(xiàng)目中對應(yīng)的類名
class List<E: Comparable> {
    /**
     * 清除所有元素
     */
    func clear() {}

    /**
     * 元素的數(shù)量
     * @return
     */
    func size() -> Int { }

    /**
     * 是否為空
     * @return
     */
    func isEmpty() -> Bool { }

    /**
     * 是否包含某個元素
     * @param element
     * @return
     */
    func contains(_ element: E) -> Bool { }

    /**
     * 添加元素到尾部
     * @param element
     */
    func add(_ element: E) {}

    /**
     * 獲取index位置的元素
     * @param index
     * @return
     */
    func get(_ index: Int) -> E? { }

    /**
     * 替換index位置的元素
     * @param index
     * @param element
     * @return 原來的元素?
     */
    func set(by index: Int, element: E) -> E? { }

    /**
     * 在index位置插入一個元素
     * @param index
     * @param element
     */
    func add(by index: Int, element: E) {}

    /**
     * 刪除index位置的元素
     * @param index
     * @return
     */
    func remove(_ index: Int) -> E? { }

    /**
     * 查看元素的索引
     * @param element
     * @return
     */
    func indexOf(_ element: E) -> Int { }
}
鏈表 類名
單向鏈表 SingleLinkList
雙向鏈表 DoubleLinkList
單向循環(huán)鏈表 CircleSingleLineList
雙向循環(huán)鏈表 CircleDoubleLinkList

  • 棧是一種特殊的線性表, 只能在一端進(jìn)行操作
  • 棧遵循后進(jìn)先出的原則, Last in First out
  • Statck
class Statck<E> {
    /// 元素個數(shù)
    func size() -> Int {}
    
    /// 是否為空
    func isEmpty() -> Bool { }
    
    /// 入棧
    func push(_ element: E?) {}
    
    /// 出棧
    @discardableResult
    func pop() -> E? {}
    
    /// 獲取棧頂元素
    func peek() -> E? {}
    
    /// 清空
    func clear() {}
}

隊(duì)列

  • 隊(duì)列是一種特殊的線性表, 只能在頭尾兩端進(jìn)行操作
  • 隊(duì)列遵循后進(jìn)先出的原則(單端隊(duì)列), First in First out
  • 下表是為隊(duì)列和測試項(xiàng)目中對應(yīng)的類名
class Queue<E: Comparable> {
    /// 元素數(shù)量
    func size() -> Int {}
    
    /// 是否為空
    func isEmpty() -> Bool {}
    
    /// 清除所有元素
    func clear() {}
    
    /// 入隊(duì)
    func enQueue(_ element: E?) {}
    
    /// 出隊(duì)
    func deQueue() -> E? {}
    
    /// 獲取隊(duì)列的頭元素
    func front() -> E? {}
    
    func string() -> String {}
}
隊(duì)列 類名
單端隊(duì)列 SingleQueue
雙端隊(duì)列 SingleDeque
單端循環(huán)隊(duì)列 CircleQueue
雙端循環(huán)隊(duì)列 CircleDeque

哈希表

  • 哈希表也稱之為散列表, 童年各國數(shù)組存儲(非單純的數(shù)組)
  • 利用哈希函數(shù)生成key對應(yīng)的index值為數(shù)組索引存儲value值
  • 兩個不同的key值通過哈希函數(shù)可能得到相同的索引, 即哈希沖突
  • 解決哈希沖突的常見方法
    • 開放定址法: 按照一定規(guī)則向其他地址探測, 知道遇到空桶
    • 再哈希法: 設(shè)計(jì)多個復(fù)雜的哈希函數(shù)
    • 鏈地址法: 通過鏈表將同一index索引的與元素串起來, 測試項(xiàng)目中使用的這種方式
class Map<K: Hashable, V: Comparable> {
    /// 元素數(shù)量
    func count() -> Int {}
    
    /// 是否為空
    func isEmpty() -> Bool {}
    
    /// 清除所有元素
    func clear() {}
    
    /// 添加元素
    @discardableResult
    func put(key: K?, val: V?) -> V? {}
    
    /// 刪除元素
    @discardableResult
    func remove(key: K) -> V? {}
    
    /// 根據(jù)元素查詢value
    func get(key: K) -> V? {}

    /// 是否包含Key
    func containsKey(key: K) -> Bool {}
    
    /// 是否包含Value
    func containsValue(val: V) -> Bool {}

    /// 所有key
    func keys() -> [K] {}

    /// 所有value
    func values() -> [V] {}

    /// 遍歷
    func traversal(visitor: ((K?, V?) -> ())) {}
}

二叉樹

  • 二叉樹是n(n>=0)個結(jié)點(diǎn)的有限集合,該集合或者為空集(稱為空二叉樹),或者由一個根結(jié)點(diǎn)和兩棵互不相交的、分別稱為根結(jié)點(diǎn)的左子樹和右子樹組成
二叉樹 類名
二叉樹 BinaryTree
二叉搜索樹 BinarySearchTree

AVL樹和紅黑樹是兩種平衡二叉搜索樹

平衡二叉搜索樹 類名
二叉平衡樹 BinaryBalanceTree
二叉平衡搜索樹 BinaryBalanceSearchTree
紅黑樹 RedBlackTree

集合

測試項(xiàng)目中分別用鏈表, 紅黑樹, 哈希表實(shí)現(xiàn)了三種集合

class Set<E: Comparable & Hashable> {
    /// 元素個數(shù)
    func size() -> Int {}
    
    /// 是否為空
    func isEmpty() -> Bool {}
    
    /// 清除所有元素
    func clear() {}
    
    /// 是否包含某元素
    func contains(_ val: E) -> Bool {}
    
    /// 添加元素
    func add(val: E) {}
    
    /// 刪除元素
    @discardableResult
    func remove(val: E) -> E? {}
    
    /// 獲取所有元素
    func lists() -> [E] {}
}
集合 類名
雙向鏈表集合 ListSet
紅黑樹集合 TreeSet
哈希表集合 HashSet

二叉堆

堆是一種樹狀的數(shù)據(jù)結(jié)構(gòu), 二叉堆只是其中一種, 除此之外還有

  • 多叉堆
  • 索引堆
  • 二項(xiàng)堆
  • ....

測試項(xiàng)目中是以二叉堆實(shí)現(xiàn)了最大堆和最小堆

class AbstractHeap<E: Comparable> {
    /// 元素的數(shù)量
    func count() -> Int {}
    
    /// 是否為空
    func isEmpty() -> Bool {}
    
    /// 清空
    func clear() { }
    
    /// 添加元素
    func add(val: E) { }
    
    /// 添加元素數(shù)組
    func addAll(vals: [E]) { }
    
    /// 獲得堆頂元素
    func top() -> E? {}
    
    /// 刪除堆頂元素
    func remove() -> E? {}
    
    /// 刪除堆頂元素的同時插入一個新元素
    func replace(val: E) -> E? {}
}
二叉堆 類名
二叉堆 BinaryHeap
最大堆 MinHeap
最小堆 MaxHeap

并查集

  • 并查集也叫不相交集合, 有查找和合并兩個核心操作
  • 查找: 查找元素所在的集
  • 合并: 將兩個元素所在的集合并為一個集
class UnionFind {
    /// 查找V所屬的集合(根節(jié)點(diǎn))
    func find(v: Int) -> Int {}
    
    /// 合并v1, v2所在的集合
    func union(v1: Int, v2: Int) { }
    
    /// 檢查v1, v2是否屬于同一個集合
    func isSame(v1: Int, v2: Int) -> Bool {}
}
并查集 類名
Quick Find UnionFind_QF
Quick Union UnionFind_QU
QU基于size優(yōu)化 UnionFind_QU_Size
QU基于size優(yōu)化 UnionFind_QU_Size
QU基于rank優(yōu)化 UnionFind_QU_Rank
QU基于rank的優(yōu)化, 路徑壓縮 UnionFind_QU_Rank_PC
QU基于rank的優(yōu)化, 路徑分裂 UnionFind_QU_Rank_PS
QU基于rank的優(yōu)化, 路徑減半 UnionFind_QU_Rank_PH
泛型并查集 GenericUnionFind

  • 圖由頂點(diǎn)和邊組成, 分有向圖和無向圖 ---> ListGraph
  • ListGraph繼承自Graph
class Graph<V: Comparable & Hashable, E: Comparable & Hashable> {
    
    /// 邊的個數(shù)
    func edgesSize() -> Int {}
    
    /// 頂點(diǎn)個數(shù)
    func verticesSize() -> Int {}
    
    /// 添加頂點(diǎn)
    func addVertex(val: V) {}
    
    /// 添加邊
    func addEdge(from: V, to: V) {}
    
    /// 添加邊(帶權(quán)重)
    func addEdge(from: V, to: V, weight: Double?) {}
    
    /// 刪除頂點(diǎn)
    func removeVertex(val: V) {}
    
    /// 刪除邊
    func removeEdge(from: V, to: V) {}
    
    /// 廣度優(yōu)先搜索(Breadth First Search)
    func breadthFirstSearch(begin: V?, visitor: ((V) -> ())) {}
    
    /// 深度優(yōu)先搜索(Depth First Search)[非遞歸]
    func depthFirstSearch(begin: V?, visitor: ((V) -> ())) {}
    
    /// 深度優(yōu)先搜索(Depth First Search)[遞歸]
    func depthFirstSearchCircle(begin: V?, visitor: ((V) -> ())) {}
    

    /*
     * 拓?fù)渑判?     * AOV網(wǎng)的遍歷, 把AOV的所有活動排成一個序列
     */
    func topologicalSort() -> [V] {}

    /*
     * 最小生成樹
     * 最小權(quán)值生成樹, 最小支撐樹
     * 所有生成樹中, 權(quán)值最小的那顆
     * prim算法方式
     */
    func mstPrim() -> HashSet<EdgeInfo<V, E>>? {}
    
    /*
     * 最小生成樹
     * 最小權(quán)值生成樹, 最小支撐樹
     * 所有生成樹中, 權(quán)值最小的那顆
     * prim算法方式
     */
    func mstKruskal() -> HashSet<EdgeInfo<V, E>>? {}
    
    /*
     * 有向圖
     * 從某一點(diǎn)出發(fā)的最短路徑(權(quán)值最小)
     * 返回權(quán)值
     */
    func shortestPath(_ begin: V) -> HashMap<V, Double>? {}
    
    /*
     * Dijkstra: 單源最短路徑算法,用于計(jì)算一個頂點(diǎn)到其他所有頂點(diǎn)的最短路徑
     * 不支持有負(fù)權(quán)邊
     */
    func dijkstraShortPath(_ begin: V) -> HashMap<V, PathInfo<V, E>>? {}
    
    /*
     * bellmanFord: 單源最短路徑算法,用于計(jì)算一個頂點(diǎn)到其他所有頂點(diǎn)的最短路徑
     * 支持有負(fù)權(quán)邊
     * 支持檢測是否有負(fù)權(quán)環(huán)
     */
    func bellmanFordShortPath(_ begin: V) -> HashMap<V, PathInfo<V, E>>? {}
    
    /*
     * Floyd: 多源最短路徑算法,用于計(jì)算任意兩個頂點(diǎn)的最短路徑
     * 支持有負(fù)權(quán)邊
     */
    func floydShortPath() -> HashMap<V, HashMap<V, PathInfo<V, E>>>? {}
    
    /// 輸出字符串
    func printString() {}
}

排序

排序 類名
冒泡排序 BubbleSorted2
選擇排序 SelectedSorted
插入排序 InsertionSorted1
歸并排序 MergeSort
希爾排序 ShellSort
快速排序 QuickSorted
堆排序 HeapSorted
計(jì)數(shù)排序 CountingSorted
基數(shù)排序 RadixSorted
桶排序 BucketSorted
/// 快速排序
let arr = [126, 69, 593, 23, 6, 89, 54, 8]
let quick = QuickSorted<Int>()
print(quick.sorted(by: arr))

/// 桶排序
let sort = BucketSorted()
let array = [0.34, 0.47, 0.29, 0.84, 0.45, 0.38, 0.35, 0.76]
print(sort.sorted(by: array))

總結(jié)

  • 數(shù)據(jù)結(jié)構(gòu)部分除了跳表和串其他的基本都實(shí)現(xiàn)了
  • 算法部分除了排序, 其他都暫時還沒有學(xué)習(xí)
  • 這部分的學(xué)習(xí)就暫時告一段落, 接下來我要準(zhǔn)備11月份的考試
  • GitHub代碼地址: 數(shù)據(jù)結(jié)構(gòu)和算法

?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請聯(lián)系作者
平臺聲明:文章內(nèi)容(如有圖片或視頻亦包括在內(nèi))由作者上傳并發(fā)布,文章內(nèi)容僅代表作者本人觀點(diǎn),簡書系信息發(fā)布平臺,僅提供信息存儲服務(wù)。

推薦閱讀更多精彩內(nèi)容