前言
接上一篇，从最基本的开始，算法，数据结构~
排序算法
排序算法是最基本要求的，
冒泡排序
冒泡排序（Bubble Sort）是一种简单的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端。
/**
* 丨最好情况 丨最坏情况丨平均情况丨
* 丨--------丨-------丨-------丨
* 冒泡排序 丨 O(n) 丨O(n^2) 丨 O(n^2)丨下同
*/
private static int[] bubbleSort(int[] array) {
if (array.length == 0) {
return array;
}
for (int i = 0; i < array.length; i++) {
for (int j = 0; j < array.length - 1 - i; j++) {
if (array[j + 1] < array[j]) {
int temp = array[j + 1];
array[j + 1] = array[j];
array[j] = temp;
}
}
}
return array;
}
选择排序
选择排序的基本思想：比较 + 交换。
在未排序序列中找到最小（大）元素，存放到未排序序列的起始位置。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。
/**
* 选择排序 O(n) O(n) O(n)
*/
private static int[] selectSort(int[] array) {
if (array.length == 0) {
return array;
}
for (int i = 0; i < array.length; i++) {
int minNumIndex = i;
// 找出最小数下标
for (int j = i; j < array.length; j++) {
minNumIndex = array[j] < array[minNumIndex] ? j : minNumIndex;
}
// 把找出最小数与未排序最前端数交换
int temp = array[i];
array[i] = array[minNumIndex];
array[minNumIndex] = temp;
}
return array;
}
插入排序
直接插入排序的基本思想是：将数组中的所有元素依次跟前面已经排好的元素相比较，如果选择的元素比已排序的元素小，则交换，直到全部元素都比较过为止。
/**
* 插入排序 O(n) O(n^2) O(n^2)
*/
private static int[] insertSort(int[] array) {
if (array.length == 0) {
return array;
}
int current;
for (int i = 0; i < array.length - 1; i++) {
current = array[i + 1];
int preIndex = i;
// 对数组进行移动
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + 1] = array[preIndex];
preIndex--;
}
// 找到属于数的正确位置并替换
array[preIndex + 1] = current;
}
return array;
}
希尔排序
希尔排序，也称递减增量排序算法，1959年Shell发明。是插入排序的一种高速而稳定的改进版本。
希尔排序是先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
/**
* 希尔排序 O(nlog2 n) O(nlog2 n) O(nlog2 n)
*/
private static int[] sellSort(int[] array) {
if (array.length == 0) {
return array;
}
int gap = array.length / 2;
while (gap > 0) {
for (int i = gap; i < array.length; i++) {
int current = array[i];
int preIndex = i - gap;
while (preIndex >= 0 && current < array[preIndex]) {
array[preIndex + gap] = array[preIndex];
preIndex -= gap;
}
array[preIndex + gap] = current;
}
gap /= 2;
}
return array;
}
归并排序
算法思想是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。具有分而治之的思想。
/**
* 归并排序 O(n) O(nlog n) O(nlog n)
*
* @param array
* @return
*/
private static int[] mergeSort(int[] array) {
if (array.length < 2) {
return array;
}
int mid = array.length / 2;
int[] left = Arrays.copyOfRange(array, 0, mid);
int[] right = Arrays.copyOfRange(array, mid, array.length);
return Merge(mergeSort(left), mergeSort(right));
}
/**
* 将排序好的两个数组合并排序
*
* @param left
* @param right
* @return
*/
private static int[] Merge(int[] left, int[] right) {
int[] newArr = new int[left.length + right.length];
for (int index = 0, l = 0, f = 0; index < newArr.length; index++) {
if (l > left.length - 1) {
newArr[index] = right[f++];
} else if (f > right.length - 1) {
newArr[index] = left[l++];
} else if (left[l] > right[f]) {
newArr[index] = right[f++];
} else {
newArr[index] = left[l++];
}
}
return newArr;
}
快速排序
快速排序基本思想就是选择一个基准数（比如第一个数），所有数字和它比较，小的放前大的放后，然后继续选择基准数对两部分比较直到变成一个有序数列。
/**
* 快速排序 O(nlogn) O(n^2) O(nlogn)
* @param arrays
* @return
*/
private static int[] quickSort(int[] arrays){
if (arrays.length==0){
return arrays;
}
quickSort(arrays,0,arrays.length-1);
return arrays;
}
private static void quickSort(int[] arr,int start,int end){
int mid=arr[start];
int low=start;
int high=end;
if(low>=high)
return ;
while(low<high){
while(arr[high]>=mid&&low<high){
high--;
}
arr[low]=arr[high];
while(arr[low]<=mid&&low<high){
low++;
}
arr[high]=arr[low];
}
arr[low]=mid;
quickSort(arr,start,low-1);
quickSort(arr,low+1>end?end:low+1,end);
}
堆排序
堆可以看成一颗完全的二叉树
把此序列对应的二维数组看成一个完全二叉树。那么堆的含义就是：完全二叉树中任何一个非叶子节点的值均不大于（或不小于）其左，右孩子节点的值。由上述性质可知大顶堆的堆顶的关键字肯定是所有关键字中最大的，小顶堆的堆顶的关键字是所有关键字中最小的。因此我们可使用大顶堆进行升序排序, 使用小顶堆进行降序排序。
)
/**
* 堆排序 O(nlog n) O(nlog n) O(nlog n)
* @param
* @return
*/
public static void headSort(int[] list) {
// 构造初始堆,从第一个非叶子节点开始调整,左右孩子节点中较大的交换到父节点中
for (int i = (list.length) / 2 - 1; i >= 0; i--) {
headAdjust(list, list.length, i);
}
// 排序，将最大的节点放在堆尾，然后从根节点重新调整
for (int i = list.length - 1; i >= 1; i--) {
int temp = list[0];
list[0] = list[i];
list[i] = temp;
headAdjust(list, i, 0);
}
}
private static void headAdjust(int[] list, int len, int i) {
int k = i, temp = list[i], index = 2 * k + 1;
while (index < len) {
if (index + 1 < len) {
if (list[index] < list[index + 1]) {
index = index + 1;
}
}
if (list[index] > temp) {
list[k] = list[index];
k = index;
index = 2 * k + 1;
} else {
break;
}
}
list[k] = temp;
}
不积跬步无以至千里，不积小流无以成江海
