目录
插入排序
希尔排序
归并排序
快速排序
插入排序
排序原理：
1.把所有元素分为两组，第一组是有序已经排好的，第二组是乱序未排序。
2.将未排序一组的第一个元素作为插入元素，倒序与有序组比较。
3.在有序组中找到比插入元素小或者大的元素，将插入元素放入该位置，后面元素向后移动一位。
时间复杂度：O(n^2)
稳定性：当A与B相等，排序前A若在B前，排序后A仍然在B前，就说明该排序是稳定的。
插入排序：稳定
//比较两元素大小方法
private static boolean greater(Comparable v,Comparable w){
return v.compareTo(w)>0;
} //数组中 交换元素位置
private static void exch(Comparable[] a,int i,int j){
Comparable temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}插入排序
public static void insertSort(Comparable[] a){
for (int i = 1; i < a.length-1; i++) {
for (int j = i+1; j >0; j--) {
if (greater(a[j-1],a[j])){
exch(a,j-1,j);
}else break;
}
}
}希尔排序
排序原理：
1.选择一个增长量h，按照h将数据分组。
2.每组进行插入排序。
3.减少增长量h直到h=1，重复步骤2
稳定性：不稳定
public static void shellSort(Comparable[] a){
int h = 1;
//确定h
while (h<a.length/2){
h = 2*h+1;
}
// 希尔排序
while (h>=1){
for (int i = h; i < a.length; i=i+h) {
for (int j = i; j >= h; j=j-h) {
if (greater(a[j-h],a[j])){
exch(a,j-h,j);
}else break;
}
}
h=h/2;
}
}归并排序
排序原理：
1.尽可能的一组数据拆分成两个元素相等的子组，并对每一个子组继续拆分，直到拆分后的每个子
组的元素个数是1为止。
2.将相邻的两个子组进行合并成一个有序的大组；
3.不断的重复步骤2，直到最终只有一个组为止。
时间复杂度：O(nlogn)
稳定性： 稳定
import java.util.Arrays;
public class Merge {
//归并需要的辅助数组
private static Comparable[] assist;
//判断v是否比w小
private static boolean less(Comparable v,Comparable w){
return v.compareTo(w)<0;
}
//交换元素
private static void exch(Comparable[] a,int i,int j){
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
//对数组a排序
public static void sort(Comparable[] a){
// 1.初始化辅助数组assist
assist= new Comparable[a.length];
// 定义lo变量和hi变量。分别记录数组中最小的索引和最大的索引
int lo = 0;
int hi = a.length-1;
sort(a,lo,hi);
}
//对数组a中从lo到hi元素进行排序
private static void sort(Comparable[] a,int lo,int hi){
//安全检验
if (hi<=lo){
return;
}
// 对lo和hi之间的数据进行分为两组
int mid = lo+(hi-lo)/2;
// 分别排序
sort(a,lo,mid);
sort(a,mid+1,hi);
//两组归并
merge(a,lo,mid,hi);
}
//归并
private static void merge(Comparable[] a,int lo,int mid,int hi){
// 定义三个指针
int i = lo;
int p1 = lo;
int p2 = mid+1;
// 遍历移动p1指针和p2指针，比较对应 索引处的值，找出小的，放到辅助数组对应分索引处
while (p1<=mid&&p2<=hi){
if (less(a[p1],a[p2])){
assist[i++] = a[p1++];
}else {
assist[i++] = a[p2++];
}
}
//遍历，如果p1的指针没有走完，将p1剩余遍历到辅助数组中
while (p1<=mid){
assist[i++] = a[p1++];
}
//遍历，如果p2的指针没有走完，将p2剩余遍历到辅助数组中
while (p2<=hi){
assist[i++] = a[p2++];
}
// 把辅助数组中的元素复制到原数组中
for (int index = lo;index<=hi;index++){
a[index] = assist[index];
}
}
public static void main(String[] args) {
Integer[] a={7,8,4,5,6,1,3,9,2};
Merge.sort(a);
System.out.println(Arrays.toString(a));
// [1, 2, 3, 4, 5, 6, 7, 8, 9]
}
}
快速排序
排序原理：
1.首先设定一个分界值，通过该分界值将数组分成左右两部分；
2.将大于或等于分界值的数据放到到数组右边，小于分界值的数据放到数组的左边。此时左边部分
中各元素都小于或等于分界值，而右边部分中各元素都大于或等于分界值；
3.然后，左边和右边的数据可以独立排序。对于左侧的数组数据，又可以取一个分界值，将该部分
数据分成左右两部分，同样在左边放置较小值，右边放置较大值。右侧的数组数据也可以做类似处
理。
4.重复上述过程，可以看出，这是一个递归定义。通过递归将左侧部分排好序后，再递归排好右侧
部分的顺序。当左侧和右侧两个部分的数据排完序后，整个数组的排序也就完成了。
时间复杂度：
平均情况：O(nlogn)，最坏情况：O(n^2)
稳定性：不稳定
import java.util.Arrays;
public class Quick {
private static void exch(Comparable[] a,int i,int j){
Comparable t = a[i];
a[i] = a[j];
a[j] = t;
}
private static boolean less(Comparable v,Comparable w){
return v.compareTo(w)<0;
}
//对数组内的元素进行排序
public static void sort(Comparable[] a){
int lo = 0;
int hi = a.length-1;
sort(a,lo,hi);
}
//对数组a中从索引hi之间的元素进行排序
public static void sort(Comparable[] a,int lo,int hi){
if (lo>=hi)return;
int partition = partition(a,lo,hi);
sort(a,lo,partition-1);
sort(a,partition+1,hi);
}
private static int partition(Comparable[] a,int lo,int hi){
//确定分界值
Comparable key = a[lo];
//定义两个指针，分别指向待切分元素的最小索引处和最大索引处的下一个位置
int left = lo;
int right = hi+1;
//切分 扫描
while (true){
//先从右边向左扫描，移动right指针，找到比分界值小的，停止
while (less(key,a[--right])){
if (right==lo){
break;
}
}
//从左边向右扫描，移动light指针，找到比分界值大的，停止
while (less(a[++left],key)){
if (left==hi){
break;
}
}
//right<right时交换
if (left>=right){
break;
}else {
exch(a,left,right);
}
}
//交换分界值
exch(a,lo,right);
return right;
}
public static void main(String[] args) {
Integer a[] = {3,6,9,2,5,8,4,7,1};
Quick.sort(a);
System.out.println(Arrays.toString(a));
// [1, 2, 3, 4, 5, 6, 7, 8, 9]
}
}
