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

排序算法_ios

1、插入排序

(1)直接插入排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void insertSort(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (size == 0 || arr.empty())
20         return;
21     for (int i = 1; i < size; ++i)
22     {
23         int key = arr[i];
24         int j = i - 1;
25         while (j >= 0 && arr[j] > key)
26         {
27             arr[j + 1] = arr[j];
28             --j;
29         }
30         arr[j+1] = key;
31     }
32 }
33 
34 int main()
35 {
36     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
37     printArray(arr);
38     insertSort(arr);
39     printArray(arr);
40 
41     return 0;
42 }
View Code

(2)二分插入排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void binaryInsertSort(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (size == 0 || arr.empty())
20         return;
21     for (int i = 1; i < size; ++i)
22     {
23         int key = arr[i];
24         int left = 0, right = i - 1;
25         while (left <= right)
26         {
27             int mid = (left + right) / 2;
28             if (key < arr[mid])
29                 right = mid - 1;
30             else
31                 left = mid + 1;
32         }
33         for (int j = i - 1; j >= left; j--)
34             arr[j + 1] = arr[j];
35         arr[left] = key;
36     }
37 }
38 
39 int main()
40 {
41     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
42     printArray(arr);
43     binaryInsertSort(arr);
44     printArray(arr);
45 
46     return 0;
47 }
View Code

(3)希尔排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void shellSort(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (size == 0 || arr.empty())
20         return;
21     for (int group = size / 2; group > 0; group /= 2)
22     {
23         for (int i = group; i < size; ++i)
24         {
25             int key = arr[i];
26             int j = i;
27             while (j >= group&&arr[j - group] > key)
28             {
29                 arr[j] = arr[j - group];
30                 j -= group;
31             }
32             arr[j] = key;
33         }
34     }
35 }
36 
37 int main()
38 {
39     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
40     printArray(arr);
41     shellSort(arr);
42     printArray(arr);
43 
44     return 0;
45 }
View Code

2、交换排序

(1)冒泡排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void bubbleSort(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (size == 0 || arr.empty())
20         return;
21     for (int i = 0; i < size; ++i)
22         for(int j=0;j<size-i-1;++j)
23             if (arr[j + 1] < arr[j])
24             {
25                 arr[j + 1] = arr[j + 1] + arr[j];
26                 arr[j] = arr[j + 1] - arr[j];
27                 arr[j + 1] = arr[j + 1] - arr[j];
28             }
29 }
30 
31 int main()
32 {
33     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
34     printArray(arr);
35     bubbleSort(arr);
36     printArray(arr);
37 
38     return 0;
39 }
View Code

(2)带哨兵的冒泡排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void bubbleSortWithPos(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (size == 0 || arr.empty())
20         return;
21     int i = size - 1;
22     while (i > 0)
23     {
24         int pos = 0;
25         for(int j=0;j<i;++j)
26             if (arr[j + 1] < arr[j])
27             {
28                 pos = j;
29                 arr[j + 1] = arr[j + 1] + arr[j];
30                 arr[j] = arr[j + 1] - arr[j];
31                 arr[j + 1] = arr[j + 1] - arr[j];
32             }
33         i = pos;
34     }
35 }
36 
37 int main()
38 {
39     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
40     printArray(arr);
41     bubbleSortWithPos(arr);
42     printArray(arr);
43 
44     return 0;
45 }
View Code

(3)快速排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 /*
17 void swap(vector<int> &arr, int i, int j)
18 {
19     int tmp = arr[i];
20     arr[i] = arr[j];
21     arr[j] = tmp;
22 }
23 
24 int partition(vector<int> &arr, int low, int high)
25 {
26     int key = arr[low];
27     while (low < high)
28     {
29         while (low<high&&arr[high]>=key)
30             --high;
31         swap(arr, low, high);
32         while (low < high&&arr[low] <= key)
33             ++low;
34         swap(arr, low, high);
35     }
36     return low;
37 }
38 */
39 
40 int partition(vector<int> &arr, int low, int high)
41 {
42     int key = arr[low];
43     while (low < high)
44     {
45         while (low < high&&arr[high] >= key)
46             --high;
47         arr[low] = arr[high];
48         while (low < high&&arr[low] <= key)
49             ++low;
50         arr[high] = arr[low];
51     }
52     arr[low] = key;
53     return low;
54 }
55 
56 void quick(vector<int> &arr, int low, int high)
57 {
58     int key = 0;
59     if (low < high)
60     {
61         key = partition(arr, low, high);
62         quick(arr, low, key - 1);
63         quick(arr, key + 1, high);
64     }
65 }
66 
67 void quickSort(vector<int> &arr)
68 {
69     int size = arr.size();
70     if (size == 0 || arr.empty())
71         return;
72     quick(arr, 0, size - 1);
73 }
74 
75 int main()
76 {
77     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
78     printArray(arr);
79     quickSort(arr);
80     printArray(arr);
81 
82     return 0;
83 }
View Code

3、选择排序

(1)简单选择排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void selectSort(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (size == 0 || arr.empty())
20         return;
21     int minIndex = 0;
22     int tmp = 0;
23     for (int i = 0; i < size; ++i)
24     {
25         minIndex = i;
26         for (int j = i; j < size; ++j)
27             if (arr[minIndex] > arr[j])
28                 minIndex = j;
29         if (minIndex != i)
30         {
31             tmp = arr[minIndex];
32             arr[minIndex] = arr[i];
33             arr[i] = tmp;
34         }
35     }
36 }
37 
38 int main()
39 {
40     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
41     printArray(arr);
42     selectSort(arr);
43     printArray(arr);
44 
45     return 0;
46 }
View Code

(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实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void swap(vector<int> &arr, int i, int j)
17 {
18     int tmp = arr[i];
19     arr[i] = arr[j];
20     arr[j] = tmp;
21 }
22 
23 void adjustMaxHeap(vector<int> &arr, int i, int size)
24 {
25     int left = 2 * i + 1;
26     int right = 2 * i + 2;
27     int largest = i;
28     if (left < size&&arr[left] >= arr[largest])
29         largest = left;
30     if (right < size&&arr[right] >= arr[largest])
31         largest = right;
32     if (largest != i)
33     {
34         swap(arr, largest, i);
35         adjustMaxHeap(arr, largest, size);
36     }
37 }
38 
39 void heapSort(vector<int> &arr)
40 {
41     int size = arr.size();
42     if (size == 0 || arr.empty())
43         return;
44     for (int i = size/2-1; i >= 0; --i)
45         adjustMaxHeap(arr, i, size);
46     for (int j = size - 1; j > 0; --j)
47     {
48         swap(arr, 0, j);
49         adjustMaxHeap(arr, 0, --size);
50     }
51 }
52 
53 int main()
54 {
55     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
56     printArray(arr);
57     heapSort(arr);
58     printArray(arr);
59 
60     return 0;
61 }
View Code

4、归并排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void helper(vector<int> &arr, int left, int mid, int right)
17 {
18     vector<int> tmp(right - left + 1);
19     int i = left;
20     int j = mid + 1;
21     int k = 0;
22     while (i <= mid&&j <= right)
23     {
24         if (arr[i] < arr[j])
25             tmp[k++] = arr[i++];
26         else
27             tmp[k++] = arr[j++];
28     }
29     while (i <= mid)
30         tmp[k++] = arr[i++];
31     while (j <= right)
32         tmp[k++] = arr[j++];
33     for (int m = 0; m < tmp.size(); ++m)
34         arr[left + m] = tmp[m];
35 }
36 
37 void merge(vector<int> &arr, int low, int high)
38 {
39     int mid = (low + high) / 2;
40     if (low < high)
41     {
42         merge(arr, low, mid);
43         merge(arr, mid + 1, high);
44         helper(arr, low, mid, high);
45     }
46 }
47 
48 void mergeSort(vector<int> &arr)
49 {
50     int size = arr.size();
51     if (size == 0 || arr.empty())
52         return;
53     merge(arr, 0, size - 1);
54 }
55 
56 int main()
57 {
58     vector<int> arr = { 7,0,1,9,4,6,3,5,2,8 };
59     printArray(arr);
60     mergeSort(arr);
61     printArray(arr);
62 
63     return 0;
64 }
View Code

5、基数排序

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

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size - 1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 void radixSort(vector<int> &data, int radix)
17 {
18     int size = data.size();
19     if (size == 0 || data.empty())
20         return;
21     //求数据的最大位数, 决定排序次数
22     int d = 1;
23     int p = radix;
24     for (int i = 0; i < size; ++i)
25     {
26         while (data[i] >= p)
27         {
28             p *= 10;
29             ++d;
30         }
31     }
32     vector<int> tmp(size);
33     vector<int> count(radix); //计数器  
34     int divide = 1;
35     for (int i = 1; i <= d; i++) //进行d次排序  
36     {
37         for (int j = 0; j < radix; j++)
38             count[j] = 0; //每次分配前清空计数器  
39         for (int j = 0; j < size; j++)
40         {
41             int idx = (data[j] / divide) % radix; //统计每个桶中的记录数  
42             ++count[idx];
43         }
44         /*
45         将各个桶中的数字个数,转化成各个桶中最后一个数字的下标索引,
46         即将tmp中的位置依次分配给每个桶
47         */
48         for (int j = 1; j < radix; j++)
49             count[j] = count[j - 1] + count[j];
50         //将所有桶中记录依次收集到tmp中 
51         for (int j = size - 1; j >= 0; j--)
52         {
53             int idx = (data[j] / divide) % radix;
54             tmp[count[idx] - 1] = data[j];
55             --count[idx];
56         }
57         //将临时数组的内容复制到data中
58         for (int j = 0; j < size; j++)
59             data[j] = tmp[j];
60         divide = divide * radix;
61     }
62 }
63 
64 int main()
65 {
66     vector<int> arr = { 73,212,973,43,55,14,28,65,539,81 };
67     printArray(arr);
68     radixSort(arr, 10);
69     printArray(arr);
70     return 0;
71 }
View Code

6、计数排序

Java实现:

排序算法_#include_02排序算法_c++实现_03
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]);
    }
}
View Code

C++实现:

排序算法_#include_02排序算法_c++实现_03
 1 #include<iostream>
 2 #include<vector>
 3 
 4 using namespace std;
 5 
 6 void printArray(vector<int> &arr)
 7 {
 8     int size = arr.size();
 9     if (size == 0 || arr.empty())
10         return;
11     for (int i = 0; i < size-1; ++i)
12         cout << arr[i] << " ";
13     cout << arr[size - 1] << endl;
14 }
15 
16 vector<int> countSort(vector<int> &arr)
17 {
18     int size = arr.size();
19     if (arr.empty() || size == 0)
20         return arr;
21     int max = INT_MIN;
22     int min = INT_MAX;
23 
24     for (int i = 0; i < size; ++i)
25     {
26         if (max < arr[i])
27             max = arr[i];
28         if (min > arr[i])
29             min = arr[i];
30     }
31 
32     vector<int> help(max - min + 1, 0);
33     for (int i = 0; i < size; ++i)
34     {
35         int pos = arr[i] - min;
36         ++help[pos];
37     }
38     //确定不比该位置大的数据个数,不比它大的数据个数为它的个数加上前一个的记数。
39     for (int i = 1; i < help.size(); ++i)
40         help[i] = help[i - 1] + help[i];
41 
42     vector<int> res(size, 0);
43     for (int i = 0; i < size; ++i)
44     {
45         //为什么要先减一,因为保存不比它大数据的个数中包括了它自己,所以要先减一。
46         int pos = --help[arr[i] - min];
47         res[pos] = arr[i];
48     }
49     return res;
50 }
51 
52 int main()
53 {
54     vector<int> arr = { 73,212,973,43,55,14,28,65,539,81 };
55     printArray(arr);
56     vector<int> res=countSort(arr);
57     printArray(res);
58     return 0;
59 }
View Code