十大基本排序
前言
忙裏偷閒，順手整理一下十大排排序算法。java
冒泡排序
步驟說明：
- 1.比較相鄰的2個元素，若是第一個比第二個大，就交換他們的位置。
- 2.對每一對相鄰元素作一樣的操做，從開始第一對到結尾的最後一對，這步驟完成後，最後的元素會是最大的元素。
- 3.持續每次對愈來愈少的元素重複上面的步驟，直到沒有任何一對數字須要比較。
代碼示例
public class BubbleSort extends BaseSort {
public BubbleSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
for (int i = 0; i < arr.length; i++) {
for (int j = 0; j < arr.length - 1; j++) {
if (arr[j] > arr[j + 1]) {
super.swap(arr, j, j + 1);
}
}
}
return arr;
}
}
選擇排序
步驟說明：
- 1.首先在未排序的序列中找到最小/大的元素，存放到排序序列的起始位置。
- 2.再從剩餘未排序元素中繼續尋找最小/大的元素，而後放到已排序序列的末尾。
- 3.重複2步驟，知道全部元素均排序完畢.
代碼示例
public class SelectionSort extends BaseSort {
public SelectionSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
//總共要進行n-1次比較
for (int i = 0; i < arr.length - 1; i++) {
int min = i;
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[min]) {
//記錄最小元素下標
min = j;
}
}
//交換最小值和i的位圖
if (i != min) {
swap(arr, i, min);
}
}
return arr;
}
}
插入排序
步驟說明：
- 1.將第一待排序序列的第一個元素看作是一個有序的序列，把第二個元素到最後一個元素當成是未排序的序列。
- 2.從頭至尾依次掃描未排序的序列，將掃描到的每一個元素插入有序序列的適當位置，
- 3.若是待插入的元素與有序序列中的某個元素相等，則將待插入的元素插入到相等元素的後面。
代碼示例
public class InsertSort extends BaseSort {
public InsertSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
for (int i = 1; i < arr.length; i++) {
int tmp = arr[i];
int j = i;
while (j > 0 && tmp < arr[j - 1]) {
arr[j] = arr[j -1];
j--;
}
if (j != i) {
arr[j] = tmp;
}
}
return arr;
}
}
希爾排序
步驟說明：
- 1.選擇一個增量序列，t1, t2, ....... , tk,其中 ti>tj, tk = 1。
- 2.按增量序列個數k，對序列進行k躺排序。
- 3.每趟排序，根據對應的增量ti, 將待排序列分割成若干長度爲m的子序列，分別對各子表進行直接插入排序，僅增量因子爲1時，整個序列做爲一個表來處理，表長度即爲整個序列的長度。
代碼示例
public class ShellSort extends BaseSort {
public ShellSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
int gap = 1;
while (gap < arr.length) {
gap = gap * 3 + 1;
}
while (gap > 0) {
for (int i = 0; i < arr.length; i++) {
int temp = arr[i];
int j = i - gap;
while (j >= 0 && arr[j] > temp) {
arr[j + gap] = arr[j];
j -= gap;
}
arr[j + gap] = temp;
}
gap = (int) Math.floor(gap / 3);
}
return arr;
}
}
歸併排序
步驟說明：
- 1.申請空間，使其大小爲兩個已經排序序列之和，該空間用來存放合併後的序列。
- 2.設定兩個指針，最初位置分別爲兩個已經排序序列的起始位置。
- 3.比較兩個指針所指向的元素，選擇相對小的元素放入到合併空間，並移動指針到下一個位置。
- 4.重複步驟3直到某一指針達到序列尾部。
- 5.將另外一個序列剩下的全部元素直接複製到合併隊列的尾部。
代碼示例
public class MergeSort extends BaseSort{
public MergeSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
return mergeSort(arr);
}
public int[] mergeSort(int[] nums) {
if (nums.length < 2) {
return nums;
}
int middle = (int) Math.floor(nums.length / 2);
int[] left = Arrays.copyOfRange(nums, 0, middle);
int[] right = Arrays.copyOfRange(nums, middle, nums.length);
return merge(mergeSort(left), mergeSort(right));
}
private int[] merge(int[] left, int[] right) {
int[] result = new int[left.length + right.length];
int i = 0;
while (left.length > 0 && right.length > 0) {
if (left[0] <= right[0]) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1 , left.length);
} else {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
}
while (left.length > 0) {
result[i++] = left[0];
left = Arrays.copyOfRange(left, 1, left.length);
}
while (right.length > 0) {
result[i++] = right[0];
right = Arrays.copyOfRange(right, 1, right.length);
}
return result;
}
}
快速排序
步驟說明：
- 1.從數列中挑出一個元素，稱爲基準（pivot）。
- 2.從新排序數列，全部元素比基準小的，所有放到基準前邊，比基準大的所有放到基準後面（若是與基準相等，能夠放到任意一邊）。在這個分區退出以後，該基準就處於數列的中間位置，也就是分區操做，每一個分區被稱作一個 partition。
- 3.遞歸排序兩個 partition。
代碼示例
public class QuickSort extends BaseSort {
public QuickSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
return quickSort(arr, 0, arr.length - 1);
}
public int[] quickSort(int[] nums, int left, int right) {
if (left < right) {
int partition = partition(nums, left, right);
quickSort(nums, left, partition - 1);
quickSort(nums, partition + 1, right);
}
return nums;
}
public int partition(int[] nums, int left, int right) {
int pivot = left;
int index = pivot + 1;
for (int i = index; i <= right; i++) {
if (nums[i] < nums[pivot]) {
swap(nums, i, index);
index++;
}
}
swap(nums, pivot, index - 1);
return index - 1;
}
}
堆排序
步驟說明：
- 1.建立一個heap， H[0....n-1] .
- 2.把堆首（最大值）和堆尾互換。
- 3.把堆的大小縮小1，並調用 shift_down(0) ,目的是把新的數組頂端數據調整到相應的位置。
- 4.重複步驟2，直到到堆的大小變爲1。
代碼示例
public class HeapSort extends BaseSort {
public HeapSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
int len = arr.length;
bulidMaxHeap(arr, len);
for (int i = len - 1; i > 0; i--) {
swap(arr, 0, i);
len--;
heapify(arr, 0, len);
}
return arr;
}
public void bulidMaxHeap(int[] nums, int len) {
for (int i = (int) Math.floor(len / 2); i >= 0; i--) {
heapify(nums, i, len);
}
}
private void heapify(int[] nums, int i, int len) {
int left = (2 * i) + 1;
int right = (2 * i) + 2;
int last = i;
if (left < len && nums[left] > nums[last]) {
last = left;
}
if (right < len && nums[right] > nums[last]) {
last = right;
}
if (last != i) {
swap(nums, i, last);
heapify(nums, last, len);
}
}
}
計數排序
步驟說明：
- 1.在 O(n) 的時間掃描一下整個序列 a，找到序列中最大值 max 和最小值 min 。
- 2.開闢一塊新的空間建立新的數組 b*，長度爲 max-min+1。
- 3.數字 b 中的 index 的元素記錄的值是a中元素的出現次數。
- 4.最後輸出目標整數序列，具體的邏輯是遍歷數組b，輸出相應元素以及對應的個數。
代碼示例
public class CountSort extends BaseSort{
public CountSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
return countSort(arr, getMaxValue(arr));
}
public int[] countSort(int[] nums, int max) {
int bucketLen = max + 1;
int[] bucket = new int[bucketLen];
for (int i : nums) {
bucket[i]++;
}
int sortedIndex = 0;
for (int i = 0; i < bucketLen; i++) {
while (bucket[i] > 0) {
nums[sortedIndex++] = i;
bucket[i]--;
}
}
return nums;
}
public int getMaxValue(int[] nums) {
int maxValue = arr[0];
for (int i : nums) {
if (maxValue < i) {
maxValue = i;
}
}
return maxValue;
}
}
桶排序
步驟說明：
- 1.設置固定數量的空桶。
- 2.把數據放到對應的桶中。
- 3.對每一個不爲空的桶進行排序。
- 4.拼接不爲空的桶的數據。
代碼示例
public class BucketSort extends BaseSort {
public BucketSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
return bucketSort(arr, 5);
}
public int[] bucketSort(int[] nums, int bucketSize) {
if (nums.length == 0) {
return nums;
}
int maxValue = nums[0];
int minValue = nums[0];
for (int i : nums) {
if (i < minValue) {
minValue = i;
} else if (i > maxValue) {
maxValue = i;
}
}
int bucketCount = (int) (Math.floor((maxValue - minValue) / bucketSize) + 1);
int[][] buckets = new int[bucketCount][0];
for (int i = 0; i < nums.length; i++) {
int index = (int) Math.floor((nums[i] - minValue) / bucketCount);
buckets[index] = appendBucket(buckets[index], nums[i]);
}
int arrIndex = 0;
for (int[] bucket : buckets) {
if (bucket.length <= 0) {
continue;
}
//對每一個桶進行插入排序
InsertSort insertSort = new InsertSort(bucket);
bucket = insertSort.sort();
for (int i : bucket) {
nums[arrIndex++] = i;
}
}
return nums;
}
/**
* 自動擴容並保存數據
* @param bucket
* @param num
* @return
*/
private int[] appendBucket(int[] bucket, int num) {
bucket = Arrays.copyOf(bucket, bucket.length + 1);
bucket[bucket.length - 1] = num;
return bucket;
}
}
計數排序
步驟說明：
- 1.將全部待比較數值（正整數）統一爲一樣的數位長度，數位較短的數據前面補零。
- 2.從最低位開始，依次進行一次排序。
- 3.從最低位排序一直到最高位排序完成之後，數列就變成一個有序序列。
代碼示例
public class RadixSort extends BaseSort{
public RadixSort(int[] nums) {
super(nums);
}
@Override
public int[] sort() {
return radixSort(arr, getMaxDigit(arr));
}
public int[] radixSort(int[] nums, int maxDigit) {
int mod = 10;
int dev = 1;
for (int i = 0; i < maxDigit; i++, dev *= 10, mod *= 10) {
int[][] counter = new int[mod * 2][0];
for (int j = 0; j < nums.length; j++) {
int bucket = ((nums[j] % mod) / dev) + mod;
counter[bucket] = arrayAppend(counter[bucket], nums[j]);
}
int pos = 0;
for (int[] bucket : counter) {
for (int value : bucket) {
nums[pos++] = value;
}
}
}
return nums;
}
private int[] arrayAppend(int[] ints, int num) {
ints = Arrays.copyOf(ints, ints.length + 1);
ints[ints.length - 1] = num;
return ints;
}
/**
* 獲取最高位數
* @param nums
* @return
*/
public int getMaxDigit(int[] nums) {
int maxValue = getMaxValue(nums);
return getNumLenght(maxValue);
}
private int getNumLenght(int maxValue) {
if (maxValue == 0) {
return 1;
}
int length = 0;
for (long tmp = maxValue; tmp != 0; tmp /= 10) {
length++;
}
return length;
}
private int getMaxValue(int[] nums) {
int maxValue = nums[0];
for (int i : nums) {
if (maxValue < i) {
maxValue = i;
}
}
return maxValue;
}
}
BaseSort類
public abstract class BaseSort {
protected int[] arr;
public BaseSort(int[] nums) {
arr = Arrays.copyOf(nums, nums.length);
}
public void swap(int[] nums, int a, int b) {
int temp = nums[a];
nums[a] = nums[b];
nums[b] = temp;
}
public void execute() {
long t1 = System.currentTimeMillis();
int[] a = sort();
System.out.println("耗時啊：" + (System.currentTimeMillis() - t1) + "ms");
print(a);
}
private void print(int[] a) {
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]);
}
}
public abstract int[] sort();
}
總結
排序算法能夠分爲內部排序和外部排序兩種。
- 內部排序：是指數據在內存中進行排序。
- 外部排序：因排序數據很大，一次不能排序全部記錄，在排序過程當中要訪問外存。
| 排序算法 | 平均時間複雜度 | 最好狀況 | 最壞狀況 | 空間複雜度 | 排序方式 | 穩定性 |
|---|---|---|---|---|---|---|
| 冒泡排序 | $O(n^2)$ | $O(n)$ | $O(n^2)$ | $O(1)$ | In-place | 穩定 |
| 選擇排序 | $O(n^2)$ | $O(n^2)$ | $O(n^2)$ | $O(1)$ | In-place | 不穩定 |
| 插入排序 | $O(n^2)$ | $O(n)$ | $O(n^2)$ | $O(1)$ | In-place | 穩定 |
| 希爾排序 | $O(n log n)$ | $O(n log^2 n)$ | $O(n log^2 n$) | $O(1)v | In-place | 不穩定 |
| 歸併排序 | $O(n log n)$ | $O(n log n)$ | $O(n log n)$ | $O(n)$ | Out-place | 穩定 |
| 快速排序 | $O(n log n)$ | $O(n log n)$ | $O(n^2)$ | $O(log n)$ | In-place | 不穩定 |
| 堆排序 | $O(n log n)$ | $O(n log n)$ | $O(n log n)$ | $O(1)$ | In-place | 不穩定 |
| 計數排序 | $O(n + k)$ | $O(n + k)$ | $O(n + k)$ | $O(k)$ | Out-place | 穩定 |
| 桶排序 | $O(n + k)$ | $O(n + k)$ | $O(n^2)$ | $O(n + k)$ | Out-place | 穩定 |
| 基數排序 | $O(n * k)$ | $O(n * k)$ | $O(n * k)$ | $O(n + k)$ | Out-place | 穩定 |
- 寫做不易，轉載請註明出處，喜歡的小夥伴能夠關注公衆號查看更多喜歡的文章。
- 聯繫方式：4272231@163.com
- QQ:95472323
- 微信:ffj2000
相關文章
- 1. Java十大排序基本信息
- 2. 十大基礎排序 · 十 --- 基數排序（穩定）
- 3. 八大基本排序算法 序
- 4. 十大排序算法基礎1
- 5. 基於Python的十大排序算法
- 6. 八大基本排序詳解(二) 基數排序
- 7. 基本排序
- 8. 十大排序之插入排序
- 9. 十大排序算法之堆排序
- 10. 十大基礎排序 · 二 --- 希爾排序(不穩定）
- 更多相關文章...
- • ADO 排序 - ADO 教程
- • PHP 數組排序 - PHP教程
- • 算法總結-歸併排序
- • Kotlin學習（二）基本類型
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. Java十大排序基本信息
- 2. 十大基礎排序 · 十 --- 基數排序（穩定）
- 3. 八大基本排序算法 序
- 4. 十大排序算法基礎1
- 5. 基於Python的十大排序算法
- 6. 八大基本排序詳解(二) 基數排序
- 7. 基本排序
- 8. 十大排序之插入排序
- 9. 十大排序算法之堆排序
- 10. 十大基礎排序 · 二 --- 希爾排序(不穩定）