排序算法

排序算法

  • 冒泡排序

  • 選擇排序

  • 插入排序

  • 快速排序（最常見(jiàn)）

  • 希爾排序

  • 歸并排序

源碼：Sorting

冒泡排序

  • 冒泡排序（Bubble Sort）是一種簡(jiǎn)單的排序算法。它重復(fù)地遍歷要排序的數(shù)列，一次比較兩個(gè)元素，如果他們的順序錯(cuò)誤就把他們交換過(guò)來(lái)。遍歷數(shù)列的工作是重復(fù)地進(jìn)行直到?jīng)]有再需要交換，也就是說(shuō)該數(shù)列已經(jīng)排序完成。這個(gè)算法的名字由來(lái)是因?yàn)樵叫〉脑貢?huì)經(jīng)由交換慢慢“浮”到數(shù)列的頂端。

  • 冒泡排序算法的思路如下（升序）：

    • 比較相鄰的元素。如果第一個(gè)比第二個(gè)大，就交換他們兩個(gè)。
    • 對(duì)每一對(duì)相鄰元素作同樣的工作，從開(kāi)始第一對(duì)到結(jié)尾的最后一對(duì)。這步做完后，最后的元素會(huì)是最大的數(shù)。
    • 針對(duì)所有的元素重復(fù)以上的步驟，除了最后一個(gè)。
    • 持續(xù)每次對(duì)越來(lái)越少的元素重復(fù)上面的步驟，直到?jīng)]有任何一對(duì)數(shù)字需要比較。

  • 冒泡排序的分析

    bubblesort

  • 演示

    bubble

  • 時(shí)間復(fù)雜度

    • 最優(yōu)時(shí)間復(fù)雜度：O(n) ——表示遍歷一次發(fā)現(xiàn)沒(méi)有任何可以交換的元素，排序結(jié)束
    • 最壞時(shí)間復(fù)雜度：O(n2)
    • 穩(wěn)定性：穩(wěn)定

  • Python 代碼

      def bubble_sort(L):
      N = len(L)
      if N <= 0 :
          print("Please input correct list.")
          return
      for i in range(N):
          for j in range(0,N-1-i):
              if L[j] > L[j+1] :
                  L[j],L[j+1] = L[j+1],L[j]
                  print(L)
      return L

  if __name__ == '__main__':
      L = [9,8,7,6,5,4,3,2,1]
      print(bubble_sort(L))

  • 輸出

      >>>
  RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\bubble_sort.py
  [8, 9, 7, 6, 5, 4, 3, 2, 1]
  [8, 7, 9, 6, 5, 4, 3, 2, 1]
  [8, 7, 6, 9, 5, 4, 3, 2, 1]
  [8, 7, 6, 5, 9, 4, 3, 2, 1]
  [8, 7, 6, 5, 4, 9, 3, 2, 1]
  [8, 7, 6, 5, 4, 3, 9, 2, 1]
  [8, 7, 6, 5, 4, 3, 2, 9, 1]
  [8, 7, 6, 5, 4, 3, 2, 1, 9]
  [7, 8, 6, 5, 4, 3, 2, 1, 9]
  [7, 6, 8, 5, 4, 3, 2, 1, 9]
  [7, 6, 5, 8, 4, 3, 2, 1, 9]
  [7, 6, 5, 4, 8, 3, 2, 1, 9]
  [7, 6, 5, 4, 3, 8, 2, 1, 9]
  [7, 6, 5, 4, 3, 2, 8, 1, 9]
  [7, 6, 5, 4, 3, 2, 1, 8, 9]
  [6, 7, 5, 4, 3, 2, 1, 8, 9]
  [6, 5, 7, 4, 3, 2, 1, 8, 9]
  [6, 5, 4, 7, 3, 2, 1, 8, 9]
  [6, 5, 4, 3, 7, 2, 1, 8, 9]
  [6, 5, 4, 3, 2, 7, 1, 8, 9]
  [6, 5, 4, 3, 2, 1, 7, 8, 9]
  [5, 6, 4, 3, 2, 1, 7, 8, 9]
  [5, 4, 6, 3, 2, 1, 7, 8, 9]
  [5, 4, 3, 6, 2, 1, 7, 8, 9]
  [5, 4, 3, 2, 6, 1, 7, 8, 9]
  [5, 4, 3, 2, 1, 6, 7, 8, 9]
  [4, 5, 3, 2, 1, 6, 7, 8, 9]
  [4, 3, 5, 2, 1, 6, 7, 8, 9]
  [4, 3, 2, 5, 1, 6, 7, 8, 9]
  [4, 3, 2, 1, 5, 6, 7, 8, 9]
  [3, 4, 2, 1, 5, 6, 7, 8, 9]
  [3, 2, 4, 1, 5, 6, 7, 8, 9]
  [3, 2, 1, 4, 5, 6, 7, 8, 9]
  [2, 3, 1, 4, 5, 6, 7, 8, 9]
  [2, 1, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>>

選擇排序

  • 選擇排序（Selection sort）是一種簡(jiǎn)單直觀的排序算法。

  • 它的工作原理如下：

    • 首先在未排序序列中找到最?。ù螅┰兀娣诺脚判蛐蛄械钠鹗嘉恢?/li>
    • 然后，再?gòu)氖Ｓ辔磁判蛟刂欣^續(xù)尋找最小（大）元素，然后放到已排序序列的末尾
    • 以此類(lèi)推，直到所有元素均排序完畢。

  • 選擇排序的主要優(yōu)點(diǎn)與數(shù)據(jù)移動(dòng)有關(guān)。如果某個(gè)元素位于正確的最終位置上，則它不會(huì)被移動(dòng)。選擇排序每次交換一對(duì)元素，它們當(dāng)中至少有一個(gè)將被移到其最終位置上，因此對(duì)n個(gè)元素的表進(jìn)行排序總共進(jìn)行至多n-1次交換。在所有的完全依靠交換去移動(dòng)元素的排序方法中，選擇排序?qū)儆诜浅：玫囊环N。

  • 選擇排序分析

    selectionsort

  • 演示

    selection

  • 時(shí)間復(fù)雜度

    • 最優(yōu)時(shí)間復(fù)雜度：O(n2)
    • 最壞時(shí)間復(fù)雜度：O(n2)
    • 穩(wěn)定性：不穩(wěn)定（考慮升序每次選擇最大的情況）

  • Python 代碼

      def select_sort(L):
      N = len(L)
      if N <= 0 :
          print("Please input correct list.")
          return
      for i in range(N-1):
          indexOfMax = 0
          for j in range(1,N-i):
              if L[j] > L[indexOfMax] :
                  indexOfMax = j
          L[N-1-i], L[indexOfMax] = L[indexOfMax], L[N-1-i]
          print(L)
      return L

  if __name__ == '__main__':
      L = [9,8,7,6,5,4,3,2,1]
      select_sort(L)

  • 輸出

      >>>
  RESTART: F:/雜/markdown/Python/DataStructure&Algorithm/Sorting/selection_sort.py
  [1, 8, 7, 6, 5, 4, 3, 2, 9]
  [1, 2, 7, 6, 5, 4, 3, 8, 9]
  [1, 2, 3, 6, 5, 4, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>>

插入排序

  • 插入排序（Insertion Sort）是一種簡(jiǎn)單直觀的排序算法，對(duì)于少量元素，它是一種有效的算法。

  • 想像一下，我們?cè)诖驌淇伺?，首先我們手上沒(méi)有牌，然后一張一張從桌上摸牌，每次摸牌都會(huì)按照從小到大的順序排好，所以手上的牌總是有序的。

  • 它的工作原理：

    • 通過(guò)構(gòu)建有序序列，對(duì)于未排序數(shù)據(jù)，在已排序序列中從后向前掃描，找到相應(yīng)位置并插入。
    • 插入排序在實(shí)現(xiàn)上，在從后向前掃描過(guò)程中，需要反復(fù)把已排序元素逐步向后挪位，為最新元素提供插入空間。

  • 演示

    Insertion-sort-example

  • 偽代碼

      INSERTION-SORT(A)
      for j = 2 to A.length
          key = A[j]
          //Insert A[j] into the sorted sequence A[1..j-1].
          i = j - 1
          while i > 0 and A[i] > key
              A[i+1] = A[i]
              i = i - 1
          A[i+1] = key

  • 時(shí)間復(fù)雜度

    • 最優(yōu)時(shí)間復(fù)雜度：O(n) ——升序排列，序列已經(jīng)處于升序狀態(tài)
    • 最壞時(shí)間復(fù)雜度：O(n2) ——序列處于降序狀態(tài)，要轉(zhuǎn)變?yōu)樯?/li>
    • 穩(wěn)定性：穩(wěn)定

  • Python 代碼

      def insertion_sort(L):
      N = len(L)
      if N <= 0:
          print("Please input correct list.")
          return
      for i in range(N): # i指示當(dāng)前待排元素
          if L[i - 1] < L[i]: # 如果待排元素比已排序列的最后一個(gè)元素（最大的元素）還大，則直接加入已排序列
              continue
          temp = L[i]
          for j in range(i - 1, -1, -1): # i-1指示已排序列的最后一項(xiàng)，然后以此與當(dāng)前待排元素比較，往前移動(dòng)
              L[j + 1] = L[j]
              if L[j - 1] <= temp:
                  L[j] = temp
                  print(L)
                  break
      return L

  if __name__ == '__main__':
      L = [1, 8, 7, 6, 5, 4, 3, 2, 1]
      print("ordered sequence =",insertion_sort(L))

  • 輸出

      >>>
  RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\insertion_sort.py
  [8, 9, 7, 6, 5, 4, 3, 2, 1]
  [7, 8, 9, 6, 5, 4, 3, 2, 1]
  [6, 7, 8, 9, 5, 4, 3, 2, 1]
  [5, 6, 7, 8, 9, 4, 3, 2, 1]
  [4, 5, 6, 7, 8, 9, 3, 2, 1]
  [3, 4, 5, 6, 7, 8, 9, 2, 1]
  [2, 3, 4, 5, 6, 7, 8, 9, 1]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>>

快速排序（最常見(jiàn)）

  • 快速排序（英語(yǔ)：Quicksort），又稱(chēng)劃分交換排序（partition-exchange sort），通過(guò)一趟排序?qū)⒁判虻臄?shù)據(jù)分割成獨(dú)立的兩部分，其中一部分的所有數(shù)據(jù)都比另外一部分的所有數(shù)據(jù)都要小，然后再按此方法對(duì)這兩部分?jǐn)?shù)據(jù)分別進(jìn)行快速排序，整個(gè)排序過(guò)程可以遞歸進(jìn)行，以此達(dá)到整個(gè)數(shù)據(jù)變成有序序列。

  • 步驟為：

    • 從數(shù)列中挑出一個(gè)元素，稱(chēng)為"基準(zhǔn)"（pivot），或稱(chēng)樞紐
    • 重新排序數(shù)列，所有元素比基準(zhǔn)值小的擺放在基準(zhǔn)前面，所有元素比基準(zhǔn)值大的擺在基準(zhǔn)的后面（相同的數(shù)可以到任一邊）。在這個(gè)分區(qū)結(jié)束之后，該基準(zhǔn)就處于數(shù)列的中間位置。這個(gè)稱(chēng)為分區(qū)（partition）操作。
    • 遞歸地（recursive）把小于基準(zhǔn)值元素的子數(shù)列和大于基準(zhǔn)值元素的子數(shù)列排序。
    • 遞歸的最底部情形，是數(shù)列的大小是零或一，也就是永遠(yuǎn)都已經(jīng)被排序好了。雖然一直遞歸下去，但是這個(gè)算法總會(huì)結(jié)束，因?yàn)樵诿看蔚牡╥teration）中，它至少會(huì)把一個(gè)元素?cái)[到它最后的位置去。

  • 時(shí)間復(fù)雜度

    • 最優(yōu)時(shí)間復(fù)雜度：O(nlogn)
    • 最壞時(shí)間復(fù)雜度：O(n2) ——每次分區(qū)時(shí)，某個(gè)分區(qū)為空
    • 穩(wěn)定性：不穩(wěn)定

  • 從一開(kāi)始快速排序平均需要花費(fèi)O(n log n)時(shí)間的描述并不明顯。但是不難觀察到的是分區(qū)運(yùn)算，數(shù)組的元素都會(huì)在每次循環(huán)中走訪(fǎng)過(guò)一次，使用O(n)的時(shí)間。在使用結(jié)合（concatenation）的版本中，這項(xiàng)運(yùn)算也是O(n)。

  • 在最好的情況，每次我們運(yùn)行一次分區(qū)，我們會(huì)把一個(gè)數(shù)列分為兩個(gè)幾近相等的片段。這個(gè)意思就是每次遞歸調(diào)用處理一半大小的數(shù)列。因此，在到達(dá)大小為一的數(shù)列前，我們只要作log n次嵌套的調(diào)用。這個(gè)意思就是調(diào)用樹(shù)的深度是O(log n)。但是在同一層次結(jié)構(gòu)的兩個(gè)程序調(diào)用中，不會(huì)處理到原來(lái)數(shù)列的相同部分；因此，程序調(diào)用的每一層次結(jié)構(gòu)總共全部?jī)H需要O(n)的時(shí)間（每個(gè)調(diào)用有某些共同的額外耗費(fèi)，但是因?yàn)樵诿恳粚哟谓Y(jié)構(gòu)僅僅只有O(n)個(gè)調(diào)用，這些被歸納在O(n)系數(shù)中）。結(jié)果是這個(gè)算法僅需使用O(n log n)時(shí)間。

  • Python 代碼

      def quick_sort(L):
      return qsort(L,0,len(L)-1)

  def qsort(L,low,high):
      if(low < high):
          pivotloc = partition(L,low,high)
          qsort(L,low,pivotloc-1)
          qsort(L,pivotloc+1,high)
      return L

  def partition(L,low,high):
      if(low >= high):
          return
      pivotkey = L[low]
      while(low < high):
          while(low < high and L[high] >= pivotkey):
              high = high - 1
          L[low],L[high] = L[high],L[low]
          while(low < high and L[low] <= pivotkey):
              low = low + 1
          L[high],L[low] = L[low],L[high]
          print("pivotkey =",pivotkey)
          print(L,"\n")
      return low

  if __name__ == '__main__':
      L = [9,8,7,6,5,4,3,2,1]
      print(quick_sort(L))

  • 輸出

      >>>
  RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\quick_sort.py
  pivotkey = 9
  [1, 8, 7, 6, 5, 4, 3, 2, 9]

  pivotkey = 1
  [1, 8, 7, 6, 5, 4, 3, 2, 9]

  pivotkey = 8
  [1, 2, 7, 6, 5, 4, 3, 8, 9]

  pivotkey = 2
  [1, 2, 7, 6, 5, 4, 3, 8, 9]

  pivotkey = 7
  [1, 2, 3, 6, 5, 4, 7, 8, 9]

  pivotkey = 3
  [1, 2, 3, 6, 5, 4, 7, 8, 9]

  pivotkey = 6
  [1, 2, 3, 4, 5, 6, 7, 8, 9]

  pivotkey = 4
  [1, 2, 3, 4, 5, 6, 7, 8, 9]

  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>>

希爾排序

  • 希爾排序(Shell Sort)是插入排序的一種。也稱(chēng)縮小增量排序，是直接插入排序算法的一種更高效的改進(jìn)版本。希爾排序是非穩(wěn)定排序算法。該方法因DL．Shell于1959年提出而得名。 希爾排序是把記錄按下標(biāo)的一定增量分組，對(duì)每組使用直接插入排序算法排序；隨著增量逐漸減少，每組包含的關(guān)鍵詞越來(lái)越多，當(dāng)增量減至1時(shí)，整個(gè)文件恰被分成一組，算法便終止。

  • 基本思想：先將整個(gè)待排序列分割稱(chēng)為若干子序列分別進(jìn)行直接插入排序，待整個(gè)序列“基本有序”時(shí)，再對(duì)全體記錄進(jìn)行一次直接插入排序

  • 希爾排序過(guò)程

    • 希爾排序的基本思想是：將數(shù)組列在一個(gè)表中并對(duì)列分別進(jìn)行插入排序，重復(fù)這過(guò)程，不過(guò)每次用更長(zhǎng)的列（步長(zhǎng)更長(zhǎng)了，列數(shù)更少了）來(lái)進(jìn)行。最后整個(gè)表就只有一列了。將數(shù)組轉(zhuǎn)換至表是為了更好地理解這算法，算法本身還是使用數(shù)組進(jìn)行排序。

    • 例如，假設(shè)有這樣一組數(shù)[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，如果我們以步長(zhǎng)為5開(kāi)始進(jìn)行排序，我們可以通過(guò)將這列表放在有5列的表中來(lái)更好地描述算法，這樣他們就應(yīng)該看起來(lái)是這樣(豎著的元素是步長(zhǎng)組成)：

      13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10

      然后我們對(duì)每列進(jìn)行排序：

      10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45

      將上述四行數(shù)字，依序接在一起時(shí)我們得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。這時(shí)10已經(jīng)移至正確位置了，然后再以3為步長(zhǎng)進(jìn)行排序：

      10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45

      排序之后變?yōu)椋?/p> 

      10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94

      最后以1步長(zhǎng)進(jìn)行排序（此時(shí)就是簡(jiǎn)單的插入排序了）

  • 時(shí)間復(fù)雜度

    • 最優(yōu)時(shí)間復(fù)雜度：根據(jù)步長(zhǎng)序列的不同而不同
    • 最壞時(shí)間復(fù)雜度：O(n2)
    • 穩(wěn)定性：不穩(wěn)定

  • Python 代碼

      def shell_sort(L,delta):
      N = len(L)
      for inc in delta:
          L = shell_insert(L,inc)
          print(L,"\n")
      return L

  def shell_insert(L,inc):
      N = len(L)
      for index in range(inc):               # 整個(gè)序列分為若干子序列，index是每個(gè)子序列的頭元素
          for i in range(index+inc,N,inc):   # 默認(rèn)每個(gè)子序列的頭元素為“已排序列”，除了頭元素的子序列為“待排序列”
              temp = L[i]                    # 每個(gè)子序列的排序方式為直接插入排序，所以當(dāng)前待排元素的值給temp
              for j in range(i-inc,-1,-inc): # 在子序列的“已排序列”中找到合適的插入地點(diǎn)，所以是倒序
                  if temp < L[j]:
                      L[j+inc] = L[j]
                  else :
                      break                  # 當(dāng)前待排元素比“已排序列”中的末尾元素還要大，所以直接放入末尾
                  if j == index or L[j-inc] < temp :
                      L[j] = temp
                      print(L)
      return L

  if __name__ == '__main__':
      L = [9,8,7,6,5,4,3,2,1]
      delta = [5,3,1] #構(gòu)造增量序列
      print(shell_sort(L,delta))

  • 輸出

      >>>
  RESTART: F:\雜\markdown\Python\DataStructure&Algorithm\Sorting\shell_sort.py
  [4, 8, 7, 6, 5, 9, 3, 2, 1]
  [4, 3, 7, 6, 5, 9, 8, 2, 1]
  [4, 3, 2, 6, 5, 9, 8, 7, 1]
  [4, 3, 2, 1, 5, 9, 8, 7, 6]
  [4, 3, 2, 1, 5, 9, 8, 7, 6]

  [1, 3, 2, 4, 5, 9, 8, 7, 6]
  [1, 3, 2, 4, 5, 6, 8, 7, 9]
  [1, 3, 2, 4, 5, 6, 8, 7, 9]

  [1, 2, 3, 4, 5, 6, 8, 7, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  [1, 2, 3, 4, 5, 6, 7, 8, 9]

  [1, 2, 3, 4, 5, 6, 7, 8, 9]
  >>>

歸并排序

  • 歸并排序是采用分治法的一個(gè)非常典型的應(yīng)用。歸并排序的思想就是先遞歸分解數(shù)組，再合并數(shù)組。

  • 將數(shù)組分解最小之后，然后合并兩個(gè)有序數(shù)組，基本思路是比較兩個(gè)數(shù)組的最前面的數(shù)，誰(shuí)小就先取誰(shuí)，取了后相應(yīng)的指針就往后移一位。然后再比較，直至一個(gè)數(shù)組為空，最后把另一個(gè)數(shù)組的剩余部分復(fù)制過(guò)來(lái)即可。

  • 歸并排序的分析

    Merge-sort-example

  • 時(shí)間復(fù)雜度

    • 最優(yōu)時(shí)間復(fù)雜度：O(nlogn)
    • 最壞時(shí)間復(fù)雜度：O(nlogn)
    • 穩(wěn)定性：穩(wěn)定
    • 缺點(diǎn):占用了一定的空間，所以歸并算法是用空間換取時(shí)間的典型應(yīng)用

  • Python 代碼

      def merge(left, right):
      lp, rp = 0, 0
      result = []
      while lp < len(left) and rp < len(right):
          if left[lp] <= right[rp]:
              result.append(left[lp])
              lp += 1
          else:
              result.append(right[rp])
              rp += 1
      result += left[lp:]
      result += right[rp:]
      return result

  def merge_sort(alist):
      length = len(alist)
      if length == 1:
          return alist
      mid = length // 2
      left = merge_sort(alist[:mid])
      right = merge_sort(alist[mid:])
      print("left = %s, right = %s"%(left,right))
      result = merge(left, right)
      print("merge:",result)
      return result

  if __name__ == '__main__':
      alist = [9, 8, 7, 6, 5, 4, 3, 2, 1]
      print("ordered sequence =",merge_sort(alist))

  • 輸出

      left = [9], right = [8]
  merge: [8, 9]
  left = [7], right = [6]
  merge: [6, 7]
  left = [8, 9], right = [6, 7]
  merge: [6, 7, 8, 9]
  left = [5], right = [4]
  merge: [4, 5]
  left = [2], right = [1]
  merge: [1, 2]
  left = [3], right = [1, 2]
  merge: [1, 2, 3]
  left = [4, 5], right = [1, 2, 3]
  merge: [1, 2, 3, 4, 5]
  left = [6, 7, 8, 9], right = [1, 2, 3, 4, 5]
  merge: [1, 2, 3, 4, 5, 6, 7, 8, 9]
  ordered sequence = [1, 2, 3, 4, 5, 6, 7, 8, 9]

各種排序算法效率比較

2017911-排序比較
2017911-排序比較

  • 算法是否穩(wěn)定：待排序列中同樣元素的先后順序是否改變

    比如待排序列是：2，3，1，8，9，1'

    排列后的序列是：1'，1，2，3，8，9

  • 快速排序應(yīng)用廣泛的原因：

    • 性能接近 O(nlogn)

    • 輔助空間較歸并排序小

    • 一般不太關(guān)注穩(wěn)定與否

最后編輯于 ：
?著作權(quán)歸作者所有,轉(zhuǎn)載或內(nèi)容合作請(qǐng)聯(lián)系作者
【社區(qū)內(nèi)容提示】社區(qū)部分內(nèi)容疑似由AI輔助生成，瀏覽時(shí)請(qǐng)結(jié)合常識(shí)與多方信息審慎甄別。
平臺(tái)聲明：文章內(nèi)容（如有圖片或視頻亦包括在內(nèi)）由作者上傳并發(fā)布，文章內(nèi)容僅代表作者本人觀點(diǎn)，簡(jiǎn)書(shū)系信息發(fā)布平臺(tái)，僅提供信息存儲(chǔ)服務(wù)。

相關(guān)閱讀更多精彩內(nèi)容

  • 概述 排序有內(nèi)部排序和外部排序，內(nèi)部排序是數(shù)據(jù)記錄在內(nèi)存中進(jìn)行排序，而外部排序是因排序的數(shù)據(jù)很大，一次不能容納全部...
    蟻前閱讀 5,298評(píng)論 0贊 52
  • 概述：排序有內(nèi)部排序和外部排序，內(nèi)部排序是數(shù)據(jù)記錄在內(nèi)存中進(jìn)行排序，而外部排序是因排序的數(shù)據(jù)很大，一次不能容納全部...
    每天刷兩次牙閱讀 3,821評(píng)論 0贊 15
  • 轉(zhuǎn)載自：https://egoistk.github.io/2016/09/10/Java%E6%8E%92%E5...
    chad_it閱讀 1,059評(píng)論 0贊 18
  • 在 淺談 TCP 介紹了 TCP 基礎(chǔ)的理論知識(shí)，這篇主要介紹 TCP 的一些應(yīng)用場(chǎng)景，主要包括（SYN Floo...
    OMSobliga閱讀 1,367評(píng)論 0贊 1
  • 汪曾祺 去年，在公共汽車(chē)上，我的孩子問(wèn)我:"小驢子有舅舅嗎？“他在路上看到一只小驢子；他自己的舅舅前兩天剛從桂林來(lái)...
    美豆豆豆豆閱讀 844評(píng)論 0贊 3

友情鏈接更多精彩內(nèi)容