Java数组 —— 八大排序
（请观看本人博文——《详解 普通数组 —— Arrays类 与 浅克隆》）
在本人《数据结构与算法》专栏的讲解中，本人讲解了如何去实现数组的八大排序。
但是，在讲解的过程中，我们能够发现：这些几乎都和指针相关
同学们可能就会和本人一样，想到了Java中不存在指针的概念，
那么，该如何去实现呢？
本人在这里要提出的一点是：
虽然Java不存在指针，但是，Java处处都是指针。
这句话可能在本人的《Java SE》专栏的前期博文中大家经常能够看到。
那么，现在，本人就来讲解下在Java中，这八大排序该如何实现：
冒泡排序
时间复杂度：
O(n^2)
基本原理：
每一个数与它后面的数相比较，最终每一轮排完都会将未排序中最大（或最小）的数排在适当的位置
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class BubbleSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
for (int i = array.length - 1; i > 0; i--) {
for (int j = 0; j < i; j++) {
if (array[j] > array[j+1]) {
swapValue(array, j, j+1);
}
}
}
}
private static void swapValue(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
那么，本人来展示下运行结果：
选择排序
时间复杂度：
O(n^2)
基本原理：
用未排序序列的第一个数和后面的所有数相比，
这样一轮下来，最大（或最小）的数就排到了相应的位置
经过最多（array.length - 1）轮后，整个数组就排好了序
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class SelectionSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
for (int i = 0; i < array.length - 1; i++) {
for (int j = i+1; j < array.length; j++) {
if (array[i] > array[j]) {
swapValue(array, i, j);
}
}
}
}
private static void swapValue(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
那么，本人来展示下运行结果：
插入排序
时间复杂度：
O(n^2)
基本原理：
首先将原始数组分成两个数组容器（可通过下标来）
将原始数组的第一个数放在1号容器中，其余放在2号容器中
从2号容器中逐个取出，插在1号容器的适当位置
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class InsertionSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
for (int i = 0; i < array.length; i++) {
for (int j = i; j > 0; j--) {
if (array[j-1] > array[j]) {
swapValue(array, j-1, j);
}
}
}
}
private static void swapValue(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
那么，本人来展示下运行结果：
希尔排序
时间复杂度：
O(n^1.3)
基本原理：
先将原数组中的数据按照增量step分组
分出来的组按照插入排序进行排序
之后再对每个小组按照增量step/2分组
再对每个小组进行插入排序。
如此类推，直到增量step=1时，整个数组就排好序了
那么，看了上面的基本原理，我们就能知道 ：
增量step的选取十分关键
所以，在这里，本人就用了克努特序列来计算增量step。
所谓克努特序列，
就是按照：num = num*3 + 1的顺序排列的序列
例：1， 4， 13， 40， 121， 364 ... ...
由数学推导可得：用这种序列来进行希尔排序，效率极高。
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class ShellSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
int maxStep = calculationStepLength(array.length);
for (int step = maxStep; step > 0; step = (step-1)/3) {
for (int i = step; i < array.length; i++) {
for (int j = i; j > step - 1; j -= step) {
if (array[j-step] > array[j]) {
swapValue(array, j, j - step);
}
}
}
}
}
private static int calculationStepLength(int length) {
int res = 1;
while (res < length / 3) {
res = res * 3 + 1;
}
return res;
}
private static void swapValue(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
那么，本人来展示下运行结果：
快速排序
时间复杂度：
O(nlog n)
基本原理：
首先选取数组中的第一个数作为基准数
然后将比它大的数放在它的左边，比它小的数放在右边
这样一来，这个基准数的位置就找好了
接下来，我们再对左右两个区间的数分别进行如上的操作
重复上面的所有操作，直到每个区间只有一个数为止
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class QuickSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
qiuckSort(array, 0, array.length-1);
}
private static void qiuckSort(int[] array, int start, int end) {
if (start < end) {
int refIndex = getRefIndex(array, start, end);
qiuckSort(array, start, refIndex-1);
qiuckSort(array, refIndex+1, end);
}
}
private static int getRefIndex(int[] array, int start, int end) {
int i = start;
int j = end;
int temp = array[start];
while (i < j) {
while (i<j && (array[j]>=temp)) {
j--;
}
if (i < j) {
array[i] = array[j];
i++;
}
while (i<j && (array[i]<temp)) {
i++;
}
if (i < j) {
array[j] = array[i];
j--;
}
}
array[i] = temp;
return i;
}
}
那么，本人来展示下运行结果：
归并排序
时间复杂度：
O(nlog n)
基本原理：
假设一个数组是由length个有序数组组成的
然后两两排序
之后再将每两个数组元素看作是一个有序序列，再重复上面的步骤
直到将整个数组看作是一个有序序列，那么这个数组就已经排好序了
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class MergeSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
mergeSort(array, 0, array.length - 1);
}
private static void mergeSort(int[] array, int startIndex, int endIndex) {
int centerIndex = (endIndex + startIndex)/2;
if (startIndex < endIndex) {
mergeSort(array, startIndex, centerIndex);
mergeSort(array, centerIndex + 1, endIndex);
merge(array, startIndex ,endIndex);
}
}
/* 合并两个子数组 */
private static void merge(int[] array, int startIndex, int endIndex) {
int centerIndex = (endIndex + startIndex)/2;
int i = startIndex;
int j = centerIndex + 1;
int[] res = new int[endIndex - startIndex + 1];
int index = 0;
//向临时数组中存储元素
while ((i <= centerIndex) && (j <= endIndex)) {
if (array[i] <= array[j]) {
res[index++] = array[i++];
} else {
res[index++] = array[j++];
}
}
//处理剩余元素
while (i <= centerIndex) {
res[index++] = array[i++];
}
while (j <= endIndex) {
res[index++] = array[j++];
}
//将临时数组中的值转交给原数组
for (int k = 0; k < res.length; k++) {
array[k + startIndex] = res[k];
}
}
}
那么，本人来展示下运行结果：
基数排序
时间复杂度：
O(d(r+n))
(d——长度
r —— 关键字基数
n ——关键字个数)
基本原理：
首先来建立编号为0~9的10个数组
然后将原数组中的每个元素通过个位的数值来存放在10个新数组对应的一个当中
然后再按照0~9的顺序将所有存入的数取出
再来按照原数组中的每个值的十位的值，来存放在10个新数组对应的一个当中
重复上面的操作，直到最高位也被这样比较了
等最后一次取出时，这个数组就排好序了
（由于我们设置的数组只能用于识别每一位的值，而不能识别正负，
所以，基数排序只能用于排列正数）
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class RadixSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
int[][] tempArray = new int[10][array.length];
int[] capacity = new int[10];
int max = getMax(array);
int maxLen = String.valueOf(max).length();
for (int i = 0, n = 1; i < maxLen; i++, n *= 10) {
for (int j = 0; j < array.length; j++) {
//取每轮相应的位的值
int remainder = array[j]/n%10;
tempArray[remainder][capacity[remainder]++] = array[j];
}
//取出临时数组中的元素
int index = 0;
for (int k = 0; k < capacity.length; k++) {
if (capacity[k] != 0) {
for (int x = 0; x < capacity[k]; x++) {
array[index++] = tempArray[k][x];
}
//清空临时数组中的记录，以便我们之后再次使用这个数组
capacity[k] = 0;
}
}
}
}
private static int getMax(int[] array) {
int res = array[0];
if (array.length < 2) {
return res;
}
for (int i = 1; i < array.length; i++) {
if (array[i] > res) {
res = array[i];
}
}
return res;
}
}
那么，本人来展示下运行结果：
堆排序
时间复杂度：
O(nlog n)
基本原理：
首先将待排序列构造成一个大根堆，所以，此时的根节点就是整个数组的最大值
然后将根所存储的数值和末尾元素进行交换，这样一来，末尾元素就是本数组的最大值
之后将除末尾元素外的剩余元素再次转换为大根堆，反复进行上述的操作
待剩余最后一个元素时，这个数组就排序完成了
动态演示：
代码实现：
package aboutArraySort;
import java.util.Arrays;
public class HeapSort {
public static void main(String[] args) {
int[] array = {37, 59, 43, -98, -17, 0};
sort(array);
System.out.println(Arrays.toString(array));
}
public static void sort(int[] array) {
for (int i = (array.length-1)/2; i >= 0; i--) {
toBigRootHeap(array, array.length, i);
}
for (int i = array.length-1; i > 0; i--) {
//进行调换
swapValue(array, i, 0);
//再将剩余元素调换成大顶堆
toBigRootHeap(array, i, 0);
}
}
private static void toBigRootHeap(int[] array, int size, int index) {
//获取左右孩子的下标
int leftChildIndex = index * 2 + 1;
int rightChildIndex = index * 2 + 2;
//获得此根与左右孩子中的最大值的下标
int maxIndex = index;
if ((leftChildIndex < size) && (array[leftChildIndex] > array[maxIndex])) {
maxIndex = leftChildIndex;
}
if ((rightChildIndex < size) && (array[rightChildIndex] > array[maxIndex])) {
maxIndex = rightChildIndex;
}
//交换这三个数值的位置，将此节点转换为“大根”
if (maxIndex != index) {
swapValue(array, index, maxIndex);
//排序底下的节点，防止调换完导致底下的节点无法形成大根堆
toBigRootHeap(array, size, maxIndex);
}
}
private static void swapValue(int[] array, int i, int j) {
int temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
那么，本人来展示下运行结果：
