- 主要分享最近學(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)和算法
線性表
鏈表
- 鏈表是一種鏈?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)目中是以二叉堆實(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)和算法