常用數據結構及算法

翻譯來自：https://github.com/kdn251/interviews#live-coding-practice

數據結構

Linked List

• 鏈表是數據元素的線性集合，稱爲節點，每個元素通過指針指向下一個節點。 它是由一組節點組成的數據結構，它們一起表示一個序列。
• 單鏈表 : 其中每個節點指向下一個節點，而最後一個節點指向null。
• 雙向鏈表 : 其中每個節點具有兩個指針p，n，使得p指向前一個節點，並且n指向下一個節點; 最後一個節點的n個指針指向null。
• 循環鏈表 : 其中每個節點指向下一個節點，並且最後一個節點指向第一個節點。

• 時間複雜度

  索引: O(n)
  查找: O(n)
  插入: O(1)
  移除: O(1)

Stack

• 棧是一個元素的集合，有兩個主要的操作：push，它添加到集合中，而pop，用於刪除最近添加的元素
• Last in, first out data structure (LIFO)後進先出的數據結構
• 時間複雜度:
  索引: O(n)
  查找: O(n)
  插入: O(1)
  刪除: O(1)

Queue

• 隊列是一個元素的集合，支持兩個主要的操作：入隊，將一個元素插入到隊列中，出隊，從隊列中刪除一個元素
• First in, first out data structure (FIFO)先進先出的數據結構
• 時間複雜度:
  索引: O(n)
  查找: O(n)
  插入: O(1)
  刪除: O(1)

tree

• 樹是一個無向，連接的非循環圖

Binary Tree

• 二叉樹是一個樹狀數據結構，其中每個節點最多有兩個子節點，這被稱爲左子節點和右子節點
• 滿二叉樹(Full Tree)：每個節點有 0 或者 2 個子節點
• 完美二叉樹(Perfect Binary Tree):每個節點有兩個子節點，並且所有的葉子節點的深度是一樣的。
• 完全二叉樹(Complete Tree):除最後一層外其他各層的節點數均達到最大值，最後一層的節點都連續集中在最左邊。

Binary Search Tree

• 二叉查找樹（BST）是一種二叉樹。其任何節點的值都大於等於左子樹中的值，小於等於右子樹中的值。
• 時間複雜度:
  索引: O(log(n))
  查找: O(log(n))
  插入: O(log(n))
  刪除: O(log(n))
  

Trie

• 字典樹，又稱爲基數樹或前綴樹，用於存儲鍵值爲字符串的動態集合或關聯數組的查找樹。樹中的節點並不直接存儲關聯鍵值，而是該節點在樹中的位置決定了其關聯鍵值。一個節點的所有子節點都有相同的前綴，根節點則是空字符串。
  

Fenwick Tree

• 樹狀數組，又稱爲二進制索引樹（Binary Indexed Tree，BIT），其概念上是樹，但以數組實現。數組中的下標代表樹中的節點，每個節點的父節點或子節點的下標可以通過位運算獲得。數組中的每個元素都包含了預計算的區間值之和，在整個樹更新的過程中，這些計算的值也同樣會被更新。
• 時間複雜度：
  區間求和: O(log(n))
  跟新: O(log(n))
  

Segment Tree

• 線段樹是用於存儲區間和線段的樹形數據結構。它允許查找一個節點在若干條線段中出現的次數。
• 時間複雜度:
  Range Query: O(log(n))
  Update: O(log(n))

Heap

• 堆是一種基於樹的滿足某些特性的數據結構：整個堆中的所有父子節點的鍵值都滿足相同的排序條件。堆分爲最大堆和最小堆。在最大堆中，父節點的鍵值永遠大於等於所有子節點的鍵值，根節點的鍵值是最大的。最小堆中，父節點的鍵值永遠小於等於所有子節點的鍵值，根節點的鍵值是最小的。
• 時間複雜度
  Access: O(log(n))
  Search: O(log(n))
  Insert: O(log(n))
  Remove: O(log(n))
  Remove Max / Min: O(1)
  

Hashing

• 哈希用於將任意長度的數據映射到固定長度的數據。哈希函數的返回值被稱爲哈希值、哈希碼或者哈希。如果不同的主鍵得到相同的哈希值，則發生了衝突。
• Hash Map：hash map 是一個存儲鍵值間關係的數據結構。HashMap 通過哈希函數將鍵轉化爲桶或者槽中的下標，從而便於指定值的查找。

• 衝突解決：
  鏈地址法（Separate Chaining）：在鏈地址法中，每個桶（bucket）是相互獨立的，每一個索引對應一個元素列表。處理HashMap 的時間就是查找桶的時間（常量）與遍歷列表元素的時間之和。

  開放地址法（Open Addressing）：在開放地址方法中，當插入新值時，會判斷該值對應的哈希桶是否存在，如果存在則根據某種算法依次選擇下一個可能的位置，直到找到一個未被佔用的地址。開放地址即某個元素的位置並不永遠由其哈希值決定。
  

Graph

• 圖是G =（V，E）的有序對，其包括頂點或節點的集合 V 以及邊或弧的集合E，其中E包括了兩個來自V的元素（即邊與兩個頂點相關聯 ，並且該關聯爲這兩個頂點的無序對）。
• 無向圖：圖的鄰接矩陣是對稱的，因此如果存在節點 u 到節點 v 的邊，那節點 v 到節點 u 的邊也一定存在。
• 有向圖：圖的鄰接矩陣不是對稱的。因此如果存在節點 u 到節點 v 的邊並不意味着一定存在節點 v 到節點 u 的邊。
  

算法

排序

快速排序

• 穩定 否
• 時間複雜度
  最優: O(nlog(n))
  最差: O(n^2)
  平均: O(nlog(n))
  

合併排序

• 合併排序是一種分治算法。這個算法不斷地將一個數組分爲兩部分，分別對左子數組和右子數組排序，然後將兩個數組合併爲新的有序數組。
• 穩定： 是

• 時間複雜度:

  最優：O(nlog(n))
  最差：O(nlog(n))
  平均：O(nlog(n))
  

桶排序

• 桶排序是一種將元素分到一定數量的桶中的排序算法。每個桶內部採用其他算法排序，或遞歸調用桶排序。
• 時間複雜度 :
  最優: Ω(n + k)
  最差: O(n^2)
  平均:Θ(n + k)
  

基數排序

• 基數排序類似於桶排序，將元素分發到一定數目的桶中。不同的是，基數排序在分割元素之後沒有讓每個桶單獨進行排序，而是直接做了合併操作。
• 時間複雜度:
  Best Case: Ω(nk)
  Worst Case: O(nk)
  Average Case: Θ(nk)

圖算法

深度優先搜索

• 深度優先搜索是一種先遍歷子節點而不回溯的圖遍歷算法。
• 時間複雜度：O(|V| + |E|)
  

廣度優先搜索

• 廣度優先搜索是一種先遍歷鄰居節點而不是子節點的圖遍歷算法。
• 時間複雜度：O(|V| + |E|)
  

拓撲排序

• 拓撲排序是有向圖節點的線性排序。對於任何一條節點 u 到節點 v 的邊，u 的下標先於 v。
• 時間複雜度：O(|V| + |E|)

Dijkstra算法

• Dijkstra 算法是一種在有向圖中查找單源最短路徑的算法
• 時間複雜度：O(|V|^2)
  

Bellman-Ford算法

• Bellman-Ford 是一種在帶權圖中查找單一源點到其他節點最短路徑的算法。
• 雖然時間複雜度大於 Dijkstra 算法，但它可以處理包含了負值邊的圖
  時間複雜度：
  最優：O(|E|)
  最差：O(|V||E|)
  

Floyd-Warshall 算法

• Floyd-Warshall 算法是一種在無環帶權圖中尋找任意節點間最短路徑的算法。
• 該算法執行一次即可找到所有節點間的最短路徑（路徑權重和）。
• 時間複雜度 :
  Best Case: O(|V|^3)
  Worst Case: O(|V|^3)
  Average Case: O(|V|^3)

最小生成樹算法

• 最小生成樹算法是一種在無向帶權圖中查找最小生成樹的貪心算法。換言之，最小生成樹算法能在一個圖中找到連接所有節點的邊的最小子集
• 時間複雜度 :
  O(|V|^2)

Kruskal’s 算法

• Kruskal 算法也是一個計算最小生成樹的貪心算法，但在 Kruskal 算法中，圖不一定是連通的
• 時間複雜度 ：O(|E|log|V|)
  

貪心算法

• 貪心算法總是做出在當前看來最優的選擇，並希望最後整體也是最優的

• 使用貪心算法可以解決的問題必須具有如下兩種特性：

  最優子結構
  問題的最優解包含其子問題的最優解。
  貪心選擇
  每一步的貪心選擇可以得到問題的整體最優解。

• 實例-硬幣選擇問題

• 給定期望的硬幣總和爲 V 分，以及 n 種硬幣，即類型是 i 的硬幣共有 coinValue[i] 分，i的範圍是 [0…n – 1]。假設每種類型的硬幣都有無限個，求解爲使和爲 V 分最少需要多少硬幣？
• 硬幣：便士（1美分），鎳（5美分），一角（10美分），四分之一（25美分）

• 假設總和 V 爲41,。我們可以使用貪心算法查找小於或者等於 V 的面值最大的硬幣，然後從 V 中減掉該硬幣的值，如此重複進行。

  V = 41 | 使用了0個硬幣
  V = 16 | 使用了1個硬幣(41 – 25 = 16)
  V = 6 | 使用了2個硬幣(16 – 10 = 6)
  V = 1 | 使用了3個硬幣(6 – 5 = 1)
  V = 0 | 使用了4個硬幣(1 – 1 = 0)

位運算

• 位運算即在比特級別進行操作的技術。使用位運算技術可以帶來更快的運行速度與更小的內存使用。
• 測試第 k 位：s & (1 << k);
• 設置第k位：s |= (1 << k);
• 關閉第k位：s &= ~(1 << k);
• 切換第k位：s ^= (1 << k);
• 乘以2n：s << n;
• 除以2n：s >> n;
• 交集：s & t;
• 並集：s | t;
• 減法：s & ~t;
• 提取最小非0位：s & (-s);
• 提取最小0位：~s & (s + 1);
• 交換值：x ^= y; y ^= x; x ^= y;

運行時分析

大 O 表示

• 大 O 表示用於表示某個算法的上界，用於描述最壞的情況。
  

小O表示

• 小 O 表示用於描述某個算法的漸進上界，二者逐漸趨近

大 Ω 表示

• 大 Ω 表示用於描述某個算法的漸進下界。
  

小 ω 表示

• 小 ω 表示用於描述某個算法的漸進下界，二者逐漸趨近。

Theta Θ 表示

• Theta Θ 表示用於描述某個算法的確界，包括最小上界和最大下界。
  
  .
  代碼實現 https://github.com/kdn251/interviews#live-coding-practice 目錄如下
  ├── Array
  │ ├── bestTimeToBuyAndSellStock.java
  │ ├── findTheCelebrity.java
  │ ├── gameOfLife.java
  │ ├── increasingTripletSubsequence.java
  │ ├── insertInterval.java
  │ ├── longestConsecutiveSequence.java
  │ ├── maximumProductSubarray.java
  │ ├── maximumSubarray.java
  │ ├── mergeIntervals.java
  │ ├── missingRanges.java
  │ ├── productOfArrayExceptSelf.java
  │ ├── rotateImage.java
  │ ├── searchInRotatedSortedArray.java
  │ ├── spiralMatrixII.java
  │ ├── subsetsII.java
  │ ├── subsets.java
  │ ├── summaryRanges.java
  │ ├── wiggleSort.java
  │ └── wordSearch.java
  ├── Backtracking
  │ ├── androidUnlockPatterns.java
  │ ├── generalizedAbbreviation.java
  │ └── letterCombinationsOfAPhoneNumber.java
  ├── BinarySearch
  │ ├── closestBinarySearchTreeValue.java
  │ ├── firstBadVersion.java
  │ ├── guessNumberHigherOrLower.java
  │ ├── pow(x,n).java
  │ └── sqrt(x).java
  ├── BitManipulation
  │ ├── binaryWatch.java
  │ ├── countingBits.java
  │ ├── hammingDistance.java
  │ ├── maximumProductOfWordLengths.java
  │ ├── numberOf1Bits.java
  │ ├── sumOfTwoIntegers.java
  │ └── utf-8Validation.java
  ├── BreadthFirstSearch
  │ ├── binaryTreeLevelOrderTraversal.java
  │ ├── cloneGraph.java
  │ ├── pacificAtlanticWaterFlow.java
  │ ├── removeInvalidParentheses.java
  │ ├── shortestDistanceFromAllBuildings.java
  │ ├── symmetricTree.java
  │ └── wallsAndGates.java
  ├── DepthFirstSearch
  │ ├── balancedBinaryTree.java
  │ ├── battleshipsInABoard.java
  │ ├── convertSortedArrayToBinarySearchTree.java
  │ ├── maximumDepthOfABinaryTree.java
  │ ├── numberOfIslands.java
  │ ├── populatingNextRightPointersInEachNode.java
  │ └── sameTree.java
  ├── Design
  │ └── zigzagIterator.java
  ├── DivideAndConquer
  │ ├── expressionAddOperators.java
  │ └── kthLargestElementInAnArray.java
  ├── DynamicProgramming
  │ ├── bombEnemy.java
  │ ├── climbingStairs.java
  │ ├── combinationSumIV.java
  │ ├── countingBits.java
  │ ├── editDistance.java
  │ ├── houseRobber.java
  │ ├── paintFence.java
  │ ├── paintHouseII.java
  │ ├── regularExpressionMatching.java
  │ ├── sentenceScreenFitting.java
  │ ├── uniqueBinarySearchTrees.java
  │ └── wordBreak.java
  ├── HashTable
  │ ├── binaryTreeVerticalOrderTraversal.java
  │ ├── findTheDifference.java
  │ ├── groupAnagrams.java
  │ ├── groupShiftedStrings.java
  │ ├── islandPerimeter.java
  │ ├── loggerRateLimiter.java
  │ ├── maximumSizeSubarraySumEqualsK.java
  │ ├── minimumWindowSubstring.java
  │ ├── sparseMatrixMultiplication.java
  │ ├── strobogrammaticNumber.java
  │ ├── twoSum.java
  │ └── uniqueWordAbbreviation.java
  ├── LinkedList
  │ ├── addTwoNumbers.java
  │ ├── deleteNodeInALinkedList.java
  │ ├── mergeKSortedLists.java
  │ ├── palindromeLinkedList.java
  │ ├── plusOneLinkedList.java
  │ ├── README.md
  │ └── reverseLinkedList.java
  ├── Queue
  │ └── movingAverageFromDataStream.java
  ├── README.md
  ├── Sort
  │ ├── meetingRoomsII.java
  │ └── meetingRooms.java
  ├── Stack
  │ ├── binarySearchTreeIterator.java
  │ ├── decodeString.java
  │ ├── flattenNestedListIterator.java
  │ └── trappingRainWater.java
  ├── String
  │ ├── addBinary.java
  │ ├── countAndSay.java
  │ ├── decodeWays.java
  │ ├── editDistance.java
  │ ├── integerToEnglishWords.java
  │ ├── longestPalindrome.java
  │ ├── longestSubstringWithAtMostKDistinctCharacters.java
  │ ├── minimumWindowSubstring.java
  │ ├── multiplyString.java
  │ ├── oneEditDistance.java
  │ ├── palindromePermutation.java
  │ ├── README.md
  │ ├── reverseVowelsOfAString.java
  │ ├── romanToInteger.java
  │ ├── validPalindrome.java
  │ └── validParentheses.java
  ├── Tree
  │ ├── binaryTreeMaximumPathSum.java
  │ ├── binaryTreePaths.java
  │ ├── inorderSuccessorInBST.java
  │ ├── invertBinaryTree.java
  │ ├── lowestCommonAncestorOfABinaryTree.java
  │ ├── sumOfLeftLeaves.java
  │ └── validateBinarySearchTree.java
  ├── Trie
  │ ├── addAndSearchWordDataStructureDesign.java
  │ ├── implementTrie.java
  │ └── wordSquares.java
  └── TwoPointers
  ├── 3Sum.java
  ├── 3SumSmaller.java
  ├── mergeSortedArray.java
  ├── minimumSizeSubarraySum.java
  ├── moveZeros.java
  ├── removeDuplicatesFromSortedArray.java
  ├── reverseString.java
  └── sortColors.java