基數排序

多排序碼排序的概念

如果每個元素的排序碼都是由多個數據項組成的組項，則依據它進行排序時就需要利用多排序碼排序。實現多排序碼排序有兩種常用的方法，最高位優先(Most Significant Digit (MSD) First)和最低位優先(Least Signnificant Digit(LSD) first)。利用多排序碼排序實現對單個排序碼排序的演算法就稱為基數排序。

MSD基數排序

思想

在基數排序中，將單排序碼Ki看作是一個子排序碼組：(K1i,K2i,...,Kdi)。例如，有一組元素，它們的排序碼取值範圍是0~999，如{332，633，059，598，232，664，179，457，825，714，405，361}，可以把這些排序碼看作是(

步驟

1. 演算法要求事先設定Radix個桶，Radix叫做基數，即排序碼的每一位可能取值的數目。為了知道每個桶中會有多少個元素，在演算法中還設定了一個輔助陣列count[Radix]，用count[k]記憶在處理第i位時第i位取值為k的元素有多少個。k與基數Radix有關。如果k屬於十進位制整數，Radix等於10。例如，在上圖中當i=1時，count各陣列元素記憶了不同取值的元素個數，c
   ount[0]=1表示值為0的元素有1個，count[3]=2表示值為3的元素有2個。
2. 在演算法中還使用了一個輔助陣列auxArray[]存放按桶分配的結果，根據count[]預先算定各桶元素的使用位置。在每一趟向各桶分配結束時，元素都被複制回原表中。

演算法實現

#pragma once
#include<iostream>

#define RADIX 10

class MSDRaixSort
{
public:
    MSDRaixSort(int length);
    void create();
    void sort();
    void print();
    ~MSDRaixSort();

private
 
:
    int *elem;
    int len;

    void radixSort(int left, int right, int d);
    int getDigit(int num, int d);
};

MSDRaixSort::MSDRaixSort(int length) 
{
    len = length;
    elem = new int[len];
}

inline void MSDRaixSort::create()
{
    std::cout << "please input the list" << std::endl;
    for (int i = 0; i < len; i++)
    {
        int temp;
        std::cin >> temp;
        elem[i] = temp;
    }
    std::cout << "finish！" << std::endl;
}

inline void MSDRaixSort::sort()
{
    radixSort(0, len - 1, 3);
}

inline void MSDRaixSort::print()
{
    for (int i = 0; i < len; i++)
    {
        std::cout << elem[i] << " ";
    }
    std::cout << std::endl;
}

MSDRaixSort::~MSDRaixSort()
{
    delete[] elem;
}

inline void MSDRaixSort::radixSort(int left, int right, int d) //MSD基數排序演算法，從高位到低位對序列進行分配，實現排序
{                                                              //其中d時位數，n時待排序元素的個數。left和right時待排序
    int i, j, count[RADIX + 1], p1, p2;                            //元素子序列的始端和尾端，最低位d=1，最高位是d
    int *auxArray = new int[right - left + 1];
    if (d <= 0)
    {
        return;
    }
    for (j = 0; j < RADIX; j++) 
    {
        count[j] = 0;
    }
    for (i = left; i <= right; i++)    //統計各桶元素的個數
    {
        count[getDigit(elem[i], d)]++;
    }
    count[RADIX] = right - left + 1;
    for  (j = 1; j < RADIX; j++)      //安排各桶元素位置
    {   
        count[j] = count[j] + count[j - 1];
    }
    for (i = left; i <= right; ++i) {
        j = getDigit(elem[i], d);
        auxArray[count[j] - 1] = elem[i];
        --count[j];
    }
    for (i = left, j = 0; i <= right; j++, i++)   //從輔助陣列auxArray寫入原陣列。
    {
        elem[i] = auxArray[j];
    }
    for  (j = 0; j < RADIX; j++)  //將各桶內的元素迭代進行MSD基數排序，直到桶內只有一個元素為止。
    {
        p1 = count[j];
        p2 = count[j + 1] - 1;
        if (p1 < p2)
        {
            radixSort(p1, p2, d - 1);
        }
    }
}

inline int MSDRaixSort::getDigit(int num, int d)
{
    int count = 0;
    while (num > 0) {
        count++;
        if (count == d)
        {
            return num % 10;
        }
        num = num / 10;
    }
    return 0;
}

//MSD基數排序main檔案
using namespace std;
#include"MSDRadixSorting.h"
int main() {
    MSDRaixSort m(15);
    m.create();
    m.sort();
    m.print();
    system("pause");
}

演算法分析

時間複雜度

在演算法中呼叫一個getDigit按位獲取用來排序的元素排序碼。在上述例子中，從高位到低位一次取待排序元素的各位作為排序碼，並設定排序的基數RADIX為10。這就相當於定義了10個接收器，分別接受不同排序碼對應的待排序元素。如果待排序元素序列的規模為n，則每個接收器中的待排元素平局為n/RADIX。所以在基數排序演算法中選擇較大的基數有利於得到個數較多而規模較小的子序列劃分，從而提高效率。但實際上，各個接收器中接收到的元素數目不可能是平局分配的，會有較大的差異，有可能出現很多空接收器。空接收器的大量存在會影響基數排序的效率。

空間複雜度

在演算法中用到了兩個陣列，一個是count用於處理第i位的值得元素有多少個，用auxArray陣列存放按桶分配的結果。其空間的大小分別為RADIX+1（桶的大小+1）和n（排序序列的長度）。故空間複雜度為O(RADIX+n+1)。

演算法的穩定性

MSD基數排序演算法是穩定的。

LSD基數排序

思想

LSD基數排序抽取排序碼的順序和MSD基數排序正好相反。使用這種方法，把單排序碼ki看成是一個d元組：利用“分配”和“收集”兩種運算對單排序碼進行排序。(K1i,K2i,...,Kdi)。其中的每一個分量也可以看成是一個排序碼，分量Kji(1≤j≤d)有RADIX種取值，RADIX為基數。針對d元組中的每一位分量Kji，把待排序元素序列中的所有元素按Kji的取值先“分配”到RADIX個桶中去。然後再按各個桶的編號，依次把元素從桶中“收集”起來，這樣所有元素按Kji取值排序完成。
如果對於所有元素的排序碼K0,K1,...,Kn−1，依次對各位的分量Kji，讓j=d,d−1,...,1，分別用這種“分配”和“收集”的運算逐趟進行排序，在最後一趟“分配”和“收集”完成後，所有元素就按其排序碼的值從小到大排好序了。
各個桶都採用鏈式佇列結構，分配到同一桶的排序碼用連結指標連結起來。每一個桶設定兩個佇列指標：一個指向隊頭（第一個進入此佇列的排序碼），記為intf[RADIX]；一個指向隊尾（最後一個進入此佇列的排序碼），記為inte[RADIX]。
待排序的n個元素組織成迴圈連結串列，A[1]到A[n]存放元素，A[0]為表頭結點。這樣在元素重排時不必移動元素，只需要修改各元素的link指標即可。

演算法的實現

//LSD基數排序演算法標頭檔案
#pragma once
#include<iostream>

#define Radix 10
struct ElementType
{
    int data;
    int link;
};

class LSDRadixSort
{
public:
    LSDRadixSort(int length);
     
 

            
  
           

              
              
            
            
相關推薦
			   
            
            
            
 

    

    
    
內部排序演算法5（基數排序）
     
 
							
							
							基數排序



多排序碼排序的概念

如果每個元素的排序碼都是由多個數據項組成的組項，則依據它進行排序時就需要利用多排序碼排序。實現多排序碼排序有兩種常用的方法，最高位優先(Most Significant Digit (MSD) First)和最低位優先(Le 

  
 

    

    
    
【Java】 大話資料結構(18) 排序演算法(5) （直接插入排序） 資料結構與演算法合集 資料結構與演算法合集
     
 本文根據《大話資料結構》一書，實現了Java版的直接插入排序。 
更多：資料結構與演算法合集 
基本概念 
　　直接插入排序思路：類似撲克牌的排序過程，從左到右依次遍歷，如果遇到一個數小於前一個數，則將該數插入到左邊所有比自己大的數之前，也就是說，將該數前面的所有更大的數字都後移一位，空出來的位置放入該數。  

  
 

    

    
    
排序演算法10——圖解基數排序（次位優先法LSD和主位優先法MSD）
     
  
  
  
 排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標） 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非 

  
 

    

    
    
七大內部排序演算法總結（插入排序、希爾排序、氣泡排序、簡單選擇排序、快速排序、歸併排序、堆排序）
     
 
                

寫在前面：


        排序是計算機程式設計中的一種重要操作，它的功能是將一個數據元素的任意序列，重新排列成一個按關鍵字有序的序列。因此排序掌握各種排序演算法非常重要。對下面介紹的各個排序，我們假定所有排序的關鍵字都是整數、對傳入函式的引數預設是已經檢查好了的。只 

  
 

    

    
    
【Java】 大話資料結構(17) 排序演算法(4) （歸併排序） 資料結構與演算法合集 資料結構與演算法合集
     
 本文根據《大話資料結構》一書，實現了Java版的堆排序。 
更多：資料結構與演算法合集 
基本概念 
　　歸併排序：將n個記錄的序列看出n個有序的子序列，每個子序列長度為1，然後不斷兩兩排序歸併，直到得到長度為n的有序序列為止。 
　　歸併方法：每次在兩個子序列中找到較小的那一個賦值給合併序列（通過指標進行操 

  
 

    

    
    
常見排序演算法彙總（C++實現）
     
  
 
 
 插入排序 
 #include<iostream>
using namespace std;
/*
插入排序的細節講解與複雜度分析
時間複雜度O(N ^ 2)，額外空間複雜度O(1)
*/
void InsertSort(int *arr, int length)
{
	int i, 

  
 

    

    
    
這可能是最透徹的氣泡排序演算法解析（java實現）
     
 
							
							
							氣泡排序是一種思想簡單，便於理解和實現的排序演算法，也許是很多人學習的第一個排序演算法，廢話不多說，我們來實現它
演算法詳解
我們以升序排列為例，演算法的思想是，遍歷整個陣列，依次對陣列中的每兩個數進行比較大小，通過兩個數字的交換，達到將最大的元素移動到陣列的最 

  
 

    

    
    
常用排序演算法總結（Java實現）
     
  
 
  
  
 排序演算法比較： 
  
 1. 氣泡排序 
 /**
 * 氣泡排序
 * 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
 * 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
 * 針對所有的元素重複以上的步驟，除了最後一個 

  
 

    

    
    
@快速排序演算法(JAVA)（個人複習）
     
  
  
  
 @快速排序演算法(JAVA) 一趟快速排序過程  
 一趟快速排序程式碼 static int[] arr; public static int quickSort(int l , int h)//一趟快速排序 { 
  int temp = arr[l];//每次去第一個作為支點
 whi 

  
 

    

    
    
九大排序演算法小結（複雜度）
     
 
                


                                 九大排序演算法小結

前面分別實現了幾大排序演算法的程式碼，但並未進行解析
現在就從演算法的時間複雜度，空間複雜度進行談起

下面這幅圖是網上考培得，但很清晰，但少了一個計數排序


         

  
 

    

    
    
八種排序演算法總結（Java實現）
     
 
                
        排序演算法有很多，在特定情景中使用哪一種演算法很重要。本文對幾種常見排序演算法做了簡單的總結。

一、氣泡排序

        氣泡排序（BubbleSort）是一種簡單的排序演算法。它重複地走訪要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交 

  
 

    

    
    
【排序演算法5】歸併排序
     
  
 
 
 歸併排序是分治法的一種典型應用。 
 歸併排序的原理是合併兩個有序序列是簡單的。 
 先對元素進行分割，分割到最後只有單一元素的時候進行歸併。兩兩一組自底向上歸併。 
 #include <stdio.h>
#include <Windows.h>
#include "M 

  
 

    

    
    
排序演算法5——圖解堆排序及其實現
     
  
  
  
 排序演算法1——圖解氣泡排序及其實現（三種方法，基於模板及函式指標） 排序演算法2——圖解簡單選擇排序及其實現 排序演算法3——圖解直接插入排序以及折半（二分）插入排序及其實現 排序演算法4——圖解希爾排序及其實現 排序演算法5——圖解堆排序及其實現 排序演算法6——圖解歸併排序及其遞迴與非 

  
 

    

    
    
排序演算法(5)-希爾排序
     
 
								
								            
							
							
							/*
 排序演算法－希爾排序
 */
void shellSort(int *p,int count) {
    int d = count/2;  // 初始增量，以後逐次減半
    int i, 

  
 

    

    
    
排序演算法5——簡單選擇排序
     
 
							
							
							簡單選擇排序的平均複雜度為 \(O(n^2)\),  但效率通常比相同平均複雜度的直接插入排序還要差。但由於選擇排序是 內部排序，因此在記憶體嚴格受限的情況下還是可以用的。

選擇排序的原理很簡單，如下圖所示：

持續從未處理元素中找到最小值並加入到已排序列中。 

  
 

    

    
    
排序演算法5之快速排序
     
 
							
							
							快速排序

很早就聽說了快速排序的大名，然後看演算法導論的相關視訊也感覺講的很有意思，現在總結一下。針對待排序陣列{a1,a2……an}快速排序可以分解為三步：


尋找基準數，比較通常就是選擇待排序的首專案或者中間專案； 
2.根據與基準數的大小關係， 將待排 

  
 

    

    
    
內部排序演算法比較（超詳解）
     
 
							
							
							一、題目描述 
  通過隨機資料比較各排序演算法的關鍵字比較次數和關鍵字移動次數，以  及執行時間，取得直觀感受。 
二、設計要求

一、需求分析 
實現各排序演算法，分別進行以下各組比較，並進行總結。 
一、各演算法在不同規模下的比較。 
1）比較範圍：直接插 

  
 

    

    
    
常見排序演算法彙總與分析（下）（基數排序與計數排序）
     
 
                


本篇彙總的演算法將不再是基於比較的排序演算法，因此會突破這類演算法的時間複雜度下界O(nlog2n)。如果有朋友對前面的內容感興趣，可以先去看看常見排序演算法彙總與分析（中）（選擇排序與歸併排序）
我們先來總結基數排序演算法，該演算法在排序過程中不進行比較，而是通過“分 

  
 

    

    
    
#006# 快速排序 × 演算法導論（第三版）練習 7.1-1 ~ 7.1-4
     
 快排採用經典的分治思想，具體如下↓ 
分解：快排的核心步驟，其結果是陣列被分成以某個數為基準的左右兩個子陣列（可能為空），其中左邊的數都小於該基準數，右邊的數都大於該基準數。詳細步驟包括計算基準數下標，以及移動陣列內元素。 
解決：通過遞迴呼叫快速排序，對兩個子陣列進行排序。 
合併：因為是原址排序，快速排序 

  
 

    

    
    
O(n*logn)級別的演算法之一（歸併排序及其優化）
     
 原理： 
設兩個有序的子序列(相當於輸入序列)放在同一序列中相鄰的位置上：array[low..m]，array[m + 1..high]，先將它們合併到一個區域性的暫存序列 temp (相當於輸出序列)中，待合併完成後將 temp 複製回 array[low..high]中，從而完成排序。 
在具體的合併過