排序算法

排序算法总结：
插入排序：直接插入排序，二分（折半）插入排序，希尔排序
交换排序：冒泡排序，快速排序
选择排序：简单选择排序，堆排序
归并排序
基数排序
计数排序

1、插入排序

（1）直接插入排序

Java实现：

package com.mian.sort;

public class InsertSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        printArray(arr);
        insertSort(arr);
        printArray(arr);
    }
    private static void insertSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=1;i<size;++i){
            int key=arr[i];
            int j=i-1;
            while(j>=0&&arr[j]>key){
                arr[j+1]=arr[j];
                --j;
            }
            arr[j+1]=key;
        }
    }
    private static void printArray(int[] arr){
        if(arr.length==0||arr==null){
            return;
        }
        for(int i=0;i<arr.length-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[arr.length-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void insertSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 1; i < size; ++i)
    {
        int key = arr[i];
        int j = i - 1;
        while (j >= 0 && arr[j] > key)
        {
            arr[j + 1] = arr[j];
            --j;
        }
        arr[j+1] = key;
    }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    insertSort(arr);
    printArray(arr);

    return 0;
}

（2）二分插入排序

Java实现：

package com.mian.sort;

public class BinaryInsertSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        printArray(arr);
        bianryInsertSort(arr);
        printArray(arr);
    }
    private static void bianryInsertSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=1;i<size;++i){
            int key=arr[i];
            int left=0,right=i-1;
            int mid=left;
            while(left<=right){
                mid=(left+right)>>1;
                if(key<arr[mid]){
                    right=mid-1;
                }else{
                    left=mid+1;
                }
            }
            for(int j=i-1;j>=left;--j){
                arr[j+1]=arr[j];
            }
            arr[left]=key;
        }
    }
    private static void printArray(int[] arr){
        if(arr.length==0||arr==null){
            return;
        }
        for(int i=0;i<arr.length-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[arr.length-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void binaryInsertSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 1; i < size; ++i)
    {
        int key = arr[i];
        int left = 0, right = i - 1;
        while (left <= right)
        {
            int mid = (left + right) / 2;
            if (key < arr[mid])
                right = mid - 1;
            else
                left = mid + 1;
        }
        for (int j = i - 1; j >= left; j--)
            arr[j + 1] = arr[j];
        arr[left] = key;
    }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    binaryInsertSort(arr);
    printArray(arr);

    return 0;
}

（3）希尔排序

Java实现：

package com.mian.sort;

public class ShellSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        printArray(arr);
        insertSort(arr);
        printArray(arr);
    }
    private static void insertSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int group=size/2;group>0;group/=2){
            for(int i=group;i<size;++i){
                int key=arr[i];
                int j=i;
                while(j>=group&&arr[j-group]>key){
                    arr[j]=arr[j-group];
                    j-=group;
                }
                arr[j]=key;
            }
        }
    }
    private static void printArray(int[] arr){
        if(arr.length==0||arr==null){
            return;
        }
        for(int i=0;i<arr.length-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[arr.length-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void shellSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int group = size / 2; group > 0; group /= 2)
    {
        for (int i = group; i < size; ++i)
        {
            int key = arr[i];
            int j = i;
            while (j >= group&&arr[j - group] > key)
            {
                arr[j] = arr[j - group];
                j -= group;
            }
            arr[j] = key;
        }
    }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    shellSort(arr);
    printArray(arr);

    return 0;
}

2、交换排序

（1）冒泡排序

Java实现：

package com.mian.sort;

public class BubbleSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        printArray(arr);
        bubbleSort(arr);
        printArray(arr);
    }
    private static void bubbleSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size;++i){
            for(int j=0;j<size-i-1;++j){
                if(arr[j+1]<arr[j]){
                    arr[j+1]=arr[j]+arr[j+1];
                    arr[j]=arr[j+1]-arr[j];
                    arr[j+1]=arr[j+1]-arr[j];
                }
            }
        }
    }
    private static void printArray(int[] arr){
        if(arr.length==0||arr==null){
            return;
        }
        for(int i=0;i<arr.length-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[arr.length-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void bubbleSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size; ++i)
        for(int j=0;j<size-i-1;++j)
            if (arr[j + 1] < arr[j])
            {
                arr[j + 1] = arr[j + 1] + arr[j];
                arr[j] = arr[j + 1] - arr[j];
                arr[j + 1] = arr[j + 1] - arr[j];
            }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    bubbleSort(arr);
    printArray(arr);

    return 0;
}

（2）带哨兵的冒泡排序

Java实现：

package com.mian.sort;

public class BubbleSortWithPos {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        printArray(arr);
        bubbleSortWithPos(arr);
        printArray(arr);
    }
    private static void bubbleSortWithPos(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        int i=size-1;
        while(i>0){
            int pos=0;
            for(int j=0;j<i;++j){
                if(arr[j+1]<arr[j]){
                    pos=j;
                    arr[j+1]=arr[j+1]+arr[j];
                    arr[j]=arr[j+1]-arr[j];
                    arr[j+1]=arr[j+1]-arr[j];
                }
            }
            i=pos;
        }
    }
    private static void printArray(int[] arr){
        if(arr.length==0||arr==null){
            return;
        }
        for(int i=0;i<arr.length-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[arr.length-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void bubbleSortWithPos(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    int i = size - 1;
    while (i > 0)
    {
        int pos = 0;
        for(int j=0;j<i;++j)
            if (arr[j + 1] < arr[j])
            {
                pos = j;
                arr[j + 1] = arr[j + 1] + arr[j];
                arr[j] = arr[j + 1] - arr[j];
                arr[j + 1] = arr[j + 1] - arr[j];
            }
        i = pos;
    }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    bubbleSortWithPos(arr);
    printArray(arr);

    return 0;
}

（3）快速排序

Java实现：

package com.mian.sort;

public class QuickSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        QuickSort qs=new QuickSort();
        qs.printArray(arr);
        qs.quickSort(arr);
        qs.printArray(arr);
    }
    private  void quickSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        quickSortHelper(arr,0,size-1);
    }
    private void quickSortHelper(int[] arr,int low,int high){
        int pivot=0;
        if(low<high){
            pivot=partition(arr,low,high);
            quickSortHelper(arr,low,pivot-1);
            quickSortHelper(arr,pivot+1,high);
        }
    }
    private int partition(int[] arr,int low,int high){
        int pivot=arr[low];
        while(low<high){
            while(low<high&&arr[high]>=pivot){
                --high;
            }
            arr[low]=arr[high];
            while(low<high&&arr[low]<=pivot){
                ++low;
            }
            arr[high]=arr[low];
        }
        arr[low]=pivot;
        return low;
    }
    private void printArray(int[] arr){
        if(arr.length==0||arr==null){
            return;
        }
        for(int i=0;i<arr.length-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[arr.length-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

/*
void swap(vector<int> &arr, int i, int j)
{
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

int partition(vector<int> &arr, int low, int high)
{
    int key = arr[low];
    while (low < high)
    {
        while (low<high&&arr[high]>=key)
            --high;
        swap(arr, low, high);
        while (low < high&&arr[low] <= key)
            ++low;
        swap(arr, low, high);
    }
    return low;
}
*/

int partition(vector<int> &arr, int low, int high)
{
    int key = arr[low];
    while (low < high)
    {
        while (low < high&&arr[high] >= key)
            --high;
        arr[low] = arr[high];
        while (low < high&&arr[low] <= key)
            ++low;
        arr[high] = arr[low];
    }
    arr[low] = key;
    return low;
}

void quick(vector<int> &arr, int low, int high)
{
    int key = 0;
    if (low < high)
    {
        key = partition(arr, low, high);
        quick(arr, low, key - 1);
        quick(arr, key + 1, high);
    }
}

void quickSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    quick(arr, 0, size - 1);
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    quickSort(arr);
    printArray(arr);

    return 0;
}

3、选择排序

（1）简单选择排序

Java实现：

package com.mian.sort;

import javax.sound.midi.Soundbank;

public class SelectSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        SelectSort selectSort=new SelectSort();
        selectSort.printArray(arr);
        selectSort.selectSort(arr);
        selectSort.printArray(arr);
    }
    private void selectSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        int minIndex=0;
        int tmp=0;
        for(int i=0;i<size;++i){
            minIndex=i;
            for(int j=i;j<size;++j){
                if(arr[minIndex]>arr[j]){
                    minIndex=j;
                }
            }
            if(minIndex!=i){
                tmp=arr[minIndex];
                arr[minIndex]=arr[i];
                arr[i]=tmp;
            }
        }
    }
    private void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void selectSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    int minIndex = 0;
    int tmp = 0;
    for (int i = 0; i < size; ++i)
    {
        minIndex = i;
        for (int j = i; j < size; ++j)
            if (arr[minIndex] > arr[j])
                minIndex = j;
        if (minIndex != i)
        {
            tmp = arr[minIndex];
            arr[minIndex] = arr[i];
            arr[i] = tmp;
        }
    }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    selectSort(arr);
    printArray(arr);

    return 0;
}

（2）堆排序

二叉树的第i层至多有2的（i-1）次方个结点；
深度为k的二叉树至多有2的k次 − 1个结点；
对任何一棵二叉树T，如果其终端结点数为n0，度为2的结点数为n2，则n0 = n2 + 1。
满二叉树:一棵深度为k，且有2的(k)次方－1个节点的二叉树 特点：每一层上的结点数都是最大结点数
若设二叉树的深度为h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，第h层所有的结点都连续集中在最左边，这就是完全二叉树。
平衡二叉树，又称AVL树。它或是一棵空树，或是具有下列性质的二叉树：它的左子树和右子树都是平衡二叉树，且左子树和右子树的高度之差的绝对值不超过1。
堆排序是指利用堆这种数据结构所设计的一种排序算法。
堆积是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。
具体算法描述如下：
①.将初始待排序关键字序列(R1,R2....Rn)构建成大顶堆，此堆为初始的无序区；
②.将堆顶元素R[1]与最后一个元素R[n]交换，此时得到新的无序区(R1,R2,......Rn-1)和新的有序区(Rn),且满足R[1,2...n-1]<=R[n]；
③.由于交换后新的堆顶R[1]可能违反堆的性质，因此需要对当前无序区(R1,R2,......Rn-1)调整为新堆，然后再次将R[1]与无序区最后一个元素交换，得到新的无序区(R1,R2....Rn-2)和新的有序区(Rn-1,Rn)。不断重复此过程直到有序区的元素个数为n-1，则整个排序过程完成。

Java实现：

package com.mian.sort;

public class HeapSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        HeapSort heapSort=new HeapSort();
        heapSort.printArray(arr);
        heapSort.heapSort(arr);
        heapSort.printArray(arr);
    }
    private void heapSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return ;
        }
        for(int i=size/2-1;i>=0;--i){
            adjustMaxHeap(arr,i,size);
        }
        for(int i=size-1;i>0;--i){
            swap(arr,0,i);
            adjustMaxHeap(arr,0,--size);
        }
    }
    private void adjustMaxHeap(int[] arr,int i,int size){
        int left=2*i+1;
        int right=2*i+2;
        int largest=i;
        if(left<size&&arr[left]>=arr[largest]){
            largest=left;
        }
        if(right<size&&arr[right]>=arr[largest]){
            largest=right;
        }
        if(largest!=i){
            swap(arr,largest,i);
            adjustMaxHeap(arr,largest,size);
        }
    }
    private void swap(int[] arr,int i,int j){
        int tmp=arr[i];
        arr[i]=arr[j];
        arr[j]=tmp;
    }
    private void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void swap(vector<int> &arr, int i, int j)
{
    int tmp = arr[i];
    arr[i] = arr[j];
    arr[j] = tmp;
}

void adjustMaxHeap(vector<int> &arr, int i, int size)
{
    int left = 2 * i + 1;
    int right = 2 * i + 2;
    int largest = i;
    if (left < size&&arr[left] >= arr[largest])
        largest = left;
    if (right < size&&arr[right] >= arr[largest])
        largest = right;
    if (largest != i)
    {
        swap(arr, largest, i);
        adjustMaxHeap(arr, largest, size);
    }
}

void heapSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = size/2-1; i >= 0; --i)
        adjustMaxHeap(arr, i, size);
    for (int j = size - 1; j > 0; --j)
    {
        swap(arr, 0, j);
        adjustMaxHeap(arr, 0, --size);
    }
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    heapSort(arr);
    printArray(arr);

    return 0;
}

4、归并排序

Java实现：

package com.mian.sort;

public class MergeSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        MergeSort mergeSort=new MergeSort();
        mergeSort.printArray(arr);
        mergeSort.mergeSort(arr);
        mergeSort.printArray(arr);
    }
    private void mergeSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return ;
        }
       mergeSortHelper(arr,0,size-1);
    }
    private void mergeSortHelper(int[] arr,int low,int high){
        int mid=(low+high)>>1;
        if(low<high){
            mergeSortHelper(arr,low,mid);
            mergeSortHelper(arr,mid+1,high);
            mergeSortCore(arr,low,mid,high);
        }
    }
    private void mergeSortCore(int[] arr,int left,int mid,int right){
        int[] tmp=new int[right-left+1];
        int i=left;
        int j=mid+1;
        int k=0;
        while(i<=mid&&j<=right){
            if(arr[i]<arr[j]) {
                tmp[k++] = arr[i++];
            }else{
                tmp[k++]=arr[j++];
            }
        }
        while(i<=mid){
            tmp[k++]=arr[i++];
        }
        while(j<=right){
            tmp[k++]=arr[j++];
        }
        for(int m=0;m<tmp.length;++m){
            arr[left+m]=tmp[m];
        }
    }

    private void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void helper(vector<int> &arr, int left, int mid, int right)
{
    vector<int> tmp(right - left + 1);
    int i = left;
    int j = mid + 1;
    int k = 0;
    while (i <= mid&&j <= right)
    {
        if (arr[i] < arr[j])
            tmp[k++] = arr[i++];
        else
            tmp[k++] = arr[j++];
    }
    while (i <= mid)
        tmp[k++] = arr[i++];
    while (j <= right)
        tmp[k++] = arr[j++];
    for (int m = 0; m < tmp.size(); ++m)
        arr[left + m] = tmp[m];
}

void merge(vector<int> &arr, int low, int high)
{
    int mid = (low + high) / 2;
    if (low < high)
    {
        merge(arr, low, mid);
        merge(arr, mid + 1, high);
        helper(arr, low, mid, high);
    }
}

void mergeSort(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    merge(arr, 0, size - 1);
}

int main()
{
    vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
    printArray(arr);
    mergeSort(arr);
    printArray(arr);

    return 0;
}

5、基数排序

基数排序的思想：
把待排序的整数按位分，分为个位，十位，百位.....从小到大依次将位数进行排序。实际上分为两个过程：分配和收集。
分配就是：从个位开始，按位数从小到大把数据排好，分别放进0--9这10个桶中。
收集就是：依次将0-9桶中的数据放进数组中。
重复这两个过程直到最高位。

Java实现：

package com.mian.sort;

public class RadixSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        RadixSort radixSort=new RadixSort();
        radixSort.printArray(arr);
        radixSort.radixSort(arr,10);
        radixSort.printArray(arr);
    }
    private void radixSort(int[] arr,int radix){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        int d=1;
        int p=radix;
        for(int i=0;i<size;++i){
            while(arr[i]>=p){
                ++d;
                p*=10;
            }
        }
        int[] tmp=new int[size];
        int[] count=new int[radix];
        int divide=1;
        //进行d次排序
        for(int i=1;i<=d;++i){
            //每次分配前清空计数器
            for(int j=0;j<radix;++j){
                count[j]=0;
            }
            for(int j=0;j<size;++j){
                //统计每个桶中的记录数
                int idx=(arr[j]/divide)%radix;
                ++count[idx];
            }
            /*
            将各个桶中的数字个数，转化成各个桶中最后一个数字的下标索引,
            即将tmp中的位置依次分配给每个桶
             */
            for(int j=1;j<radix;++j){
                count[j]=count[j-1]+count[j];
            }
            //将所有桶中记录依次收集到tmp中
            for(int j=size-1;j>=0;--j){
                int idx=(arr[j]/divide)%radix;
                tmp[count[idx]-1]=arr[j];
                --count[idx];
            }
            //将临时数组的内容复制到arr中
            for(int j=0;j<size;++j){
                arr[j]=tmp[j];
            }
            divide=divide*radix;
        }
    }
    private void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size - 1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

void radixSort(vector<int> &data, int radix)
{
    int size = data.size();
    if (size == 0 || data.empty())
        return;
    //求数据的最大位数, 决定排序次数
    int d = 1;
    int p = radix;
    for (int i = 0; i < size; ++i)
    {
        while (data[i] >= p)
        {
            p *= 10;
            ++d;
        }
    }
    vector<int> tmp(size);
    vector<int> count(radix); //计数器  
    int divide = 1;
    for (int i = 1; i <= d; i++) //进行d次排序  
    {
        for (int j = 0; j < radix; j++)
            count[j] = 0; //每次分配前清空计数器  
        for (int j = 0; j < size; j++)
        {
            int idx = (data[j] / divide) % radix; //统计每个桶中的记录数  
            ++count[idx];
        }
        /*
        将各个桶中的数字个数，转化成各个桶中最后一个数字的下标索引,
        即将tmp中的位置依次分配给每个桶
        */
        for (int j = 1; j < radix; j++)
            count[j] = count[j - 1] + count[j];
        //将所有桶中记录依次收集到tmp中 
        for (int j = size - 1; j >= 0; j--)
        {
            int idx = (data[j] / divide) % radix;
            tmp[count[idx] - 1] = data[j];
            --count[idx];
        }
        //将临时数组的内容复制到data中
        for (int j = 0; j < size; j++)
            data[j] = tmp[j];
        divide = divide * radix;
    }
}

int main()
{
    vector<int> arr = { 73,212,973,43,55,14,28,65,539,81 };
    printArray(arr);
    radixSort(arr, 10);
    printArray(arr);
    return 0;
}

6、计数排序

Java实现：

package com.mian.sort;

public class CountSort {
    public static void main(String[] args){
        int[] arr={ 7,0,1,9,4,6,3,5,2,8 };
        CountSort countSort=new CountSort();
        countSort.printArray(arr);
        int[] res=countSort.countSort(arr);
        countSort.printArray(res);
    }
    private int[] countSort(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return arr;
        }
        int max=Integer.MIN_VALUE;
        int min=Integer.MAX_VALUE;
        for(int i=0;i<size;++i){
            if(arr[i]>max){
                max=arr[i];
            }
            if(arr[i]<min){
                min=arr[i];
            }
        }
        int[] helper=new int[max-min+1];
        for(int i=0;i<size;++i){
            int pos=arr[i]-min;
            ++helper[pos];
        }
        for(int i=1;i<helper.length;++i){
            //确定不比该位置大的数据个数,不比它大的数据个数为它的个数加上前一个的记数。
            helper[i]=helper[i-1]+helper[i];
        }
        int[] res=new int[size];
        for(int i=0;i<size;++i){
            //为什么要先减一，因为保存不比它大数据的个数中包括了它自己，所以要先减一。
            int pos=--helper[arr[i]-min];
            res[pos]=arr[i];
        }
        return res;
    }
    private void printArray(int[] arr){
        int size=arr.length;
        if(size==0||arr==null){
            return;
        }
        for(int i=0;i<size-1;++i){
            System.out.print(arr[i]+" ");
        }
        System.out.println(arr[size-1]);
    }
}

C++实现：

#include<iostream>
#include<vector>

using namespace std;

void printArray(vector<int> &arr)
{
    int size = arr.size();
    if (size == 0 || arr.empty())
        return;
    for (int i = 0; i < size-1; ++i)
        cout << arr[i] << " ";
    cout << arr[size - 1] << endl;
}

vector<int> countSort(vector<int> &arr)
{
    int size = arr.size();
    if (arr.empty() || size == 0)
        return arr;
    int max = INT_MIN;
    int min = INT_MAX;

    for (int i = 0; i < size; ++i)
    {
        if (max < arr[i])
            max = arr[i];
        if (min > arr[i])
            min = arr[i];
    }

    vector<int> help(max - min + 1, 0);
    for (int i = 0; i < size; ++i)
    {
        int pos = arr[i] - min;
        ++help[pos];
    }
    //确定不比该位置大的数据个数,不比它大的数据个数为它的个数加上前一个的记数。
    for (int i = 1; i < help.size(); ++i)
        help[i] = help[i - 1] + help[i];

    vector<int> res(size, 0);
    for (int i = 0; i < size; ++i)
    {
        //为什么要先减一，因为保存不比它大数据的个数中包括了它自己，所以要先减一。
        int pos = --help[arr[i] - min];
        res[pos] = arr[i];
    }
    return res;
}

int main()
{
    vector<int> arr = { 73,212,973,43,55,14,28,65,539,81 };
    printArray(arr);
    vector<int> res=countSort(arr);
    printArray(res);
    return 0;
}