Java的各种排序算法详解

首先最经典的冒泡排序

从第一个元素开始冒泡，即依次与后边的元素进行比较，若是大于后边的则二者进行交换，一直重复这个过程，直到一次完整的迭代后不再有顺序的改变停止，应该就是所有元素的从小至大排列的顺序了。

代码演示：

import java.util.Arrays;

public class SortAr {
public static int[] numbers = {3,5,1,8,9};
public static void main(String[] args){
bubbleSort(numbers);
System.out.print(Arrays.toString(numbers));
}

public static void bubbleSort(int[] numbers){
boolean numbersSwitched;
do{
numbersSwitched = false;
for(int i = 0; i < numbers.length - 1; i++){
if(numbers[i + 1] < numbers[i]){
int temp = numbers[i + 1];
numbers[i + 1] = numbers[i];
numbers[i] = temp;
numbersSwitched = true;
}
}
}while(numbersSwitched);
}
}

插入排序

这个排序算法涉及两个列表，一个是给定的列表一个是新的列表，把给定的列表中的元素逐一插入新的列表（按顺序）直到最后插入结束为止，返回这个新的列表

代码举例：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;

public class SortAr {

private static List<Integer> number = new ArrayList<Integer>() {{
add(3);
add(5);
add(1);
add(9);
add(8);
}};

public static void main(String[] args){
List<Integer> numbers = insertSort(number);
System.out.print(numbers);
}

//插入排序
public static List<Integer> insertSort(final List<Integer> numbers){
final List<Integer> sortedList = new LinkedList<>();
orginalList: for (Integer number : numbers){
for(int i = 0; i < sortedList.size(); i++){
if(number < sortedList.get(i)){
sortedList.add(i, number);
continue orginalList;
}
}
sortedList.add(sortedList.size(), number);
}
return sortedList;
}
}

这个函数返回的是一个新的list所以需要创建一个list来进行接收返回值，然后打印出这个list。
插入排序不好的地方是浪费空间，需要建两个list，这个当数据量变大时显得不划算，而且算法的复杂度最坏情况还是n方，没得说。

快速排序

这个算法的关键思想是随意地找到一个轴，也就是随意地找个元素来做轴，根据其他元素与这个轴的大小比较从而分为两组，一组全比轴的值来的大，另一组则小于轴，接下来使用递归的方式，对每一个组再次任意寻找一个轴分为两组进行排序，反复的进行下去，这样就会得到排序完成的最后结果。

代码举例：

//快速排序
public static List<Integer> quicksort(List<Integer> numbers){
if(numbers.size() < 2){
return numbers;
}

final Integer pivot = numbers.get(0);
final List<Integer> lower = new ArrayList<>();
final List<Integer> higher = new ArrayList<>();
for (int i = 1; i < numbers.size(); i++){
if(numbers.get(i) < pivot){
lower.add(numbers.get(i));
}else{
higher.add(numbers.get(i));
}
}

final List<Integer> sorted = quicksort(lower);
sorted.add(pivot);
sorted.addAll(quicksort(higher));
return sorted;
}

归并排序

典型的分治的思想，将列表分为两个自列表，分别对这两个子列表进行排序，最后将有序的子列表进行归并到一个列表的操作。

具体的操作主要是在归并的过程，每一个子列表有一个指针，选择两个指针中所指较小的一个添加到最终的列表中，然后指针后移一位继续。其中当有一个列表到最后一个时将另一个列表的所有元素直接添加到最终的结果列表中去。

代码举例：

//归并排序
public static List<Integer> mergesort(List<Integer> values){
if(values.size() < 2){
return values;
}

final List<Integer> leftHalf = values.subList(0, values.size()/2);
final List<Integer> rightHalf = values.subList(values.size()/2, values.size());

return merge(mergesort(leftHalf), mergesort(rightHalf));
}
private static List<Integer> merge(final List<Integer> left, final List<Integer> right){
int leftPtr = 0;
int rightPtr = 0;

final List<Integer> merged = new ArrayList<>(left.size()+right.size());

while(leftPtr < left.size() && rightPtr < right.size()){
if(left.get(leftPtr) < right.get(rightPtr)){
merged.add(left.get(leftPtr));
leftPtr++;
}else{
merged.add(right.get(rightPtr));
rightPtr++;
}
}

while(leftPtr < left.size()){
merged.add(left.get(leftPtr));
leftPtr++;
}

while(rightPtr < right.size()){
merged.add(right.get(rightPtr));
rightPtr++;
}

return merged;
}