一、交换方法(被调用来交换值)
/**
* 交换方法
* @param a
* @param j
* @param i
*/
private static void swap(int[] a, int j, int i) {
// TODO Auto-generated method stub
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}二、交换算法
1.选择排序
/**
* 选择排序 每次都选择最小的
* 时间复杂度O(N^2)
* 空间复杂度O(1)
*/
public static void selectionSort(int[] a) {
if(a==null||a.length<2)
return;
for(int i = 0;i < a.length-1;i++) {
int min = i;
for(int j = i+1;j < a.length;j++) {
min = a[j]<a[min]?j:min; //选择最小的
}
swap(a,i,min); //交换值
}
}2.冒泡算法
/**
* 冒泡排序 每次选择最大的，放到最后
* 时间复杂度O(N^2)
* 空间复杂度O(1)
*/
public static int[] bubleSort(int[] a) {
if(a==null||a.length<2) {
return a;
}else {
for(int i = a.length-1;i > 0; i--) {
for(int j = 0;j<i;j++) {
if(a[j]>a[j+1]) {
swap(a,j,j+1);//交换值
}
}
}
return a;
}
}3.插入排序
/**
* 插入排序 每次都往已经排好的队列插入数据
* 时间复杂度O(N^2)
* 空间复杂度O(1)
*/
public static int[] insertionSort(int[] a) {
if(a==null||a.length<2)
return a;
for(int i = 1;i < a.length;i++) {
for(int j = i-1;j >= 0 && a[j] > a [j+1];j--) {
swap(a, j, j+1);
}
}
return a;
}4.希尔排序
/**
*最坏时间复杂度：O(n2)
*稳定想：不稳定
*/
public static void shellSort(int[] a){
int len = a.length;
int gap = len/2;
while(gap>0){
for(int j = gap;j<len;j++){
int i = j;
while(i>=gap&&a[i-gap]>a[i]){
int tmp = a[i];
a[i] = a[i-gap];
a[i-gap] = tmp;
i = i-gap;
}
}
gap = gap/2;
}
}5.归并排序
/**
* 归并排序 运用递归
* 时间复杂度:O(nlogn)
* 空间复杂度O(n)
* @param a
* @param begin
* @param end
*/
public static void mergeSort(int[] a,int begin,int end) {
if (begin < end) {
int mid = begin+((end-begin)>>1);
mergeSort(a,begin,mid);
mergeSort(a,mid+1,end);
merge(a,begin,mid,end);
}
}
/**
* 归并运算合起来
* @param a
* @param begin
* @param mid
* @param end
*/
private static void merge(int[] a, int begin, int mid, int end) {
// TODO Auto-generated method stub
int[] help = new int[end-begin+1];
int i = 0;
int p1 = begin;
int p2 = mid+1;
while(p1<=mid && p2<=end) {
help[i++] = a[p1]<a[p2]?a[p1++]:a[p2++];
}
while(p1<=mid) {
help[i++] = a[p1++];
}
while(p2<=end) {
help[i++] = a[p2++];
}
for(i = 0;i<help.length;i++)
a[begin+i] = help[i];
}6.快速排序
/**
*找一个基准，left和right，将基准赋值给left和right重合的位置
*左边都比它小，右边都大于它
*继续递归排序
* 时间复杂度 nlogn
* 空间复杂度 nlogn
*/
public static void quickSort2(int a[], int low, int hight) {
int i, j, index;
if (low > hight) {
return;
}
i = low;
j = hight;
index = a[i]; // 用子表的第一个记录做基准
while(i<j) {
while(i<j && a[j]>=index) {
j--;
}
if(i<j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
while(i<j && a[i]<index) {
i++;
}
if(i<j) {
int temp = a[i];
a[i] = a[j];
a[j] = temp;
}
}
quickSort2(a, low, i-1);
quickSort2(a, i+1, hight);
}7.堆排序
/**
* 堆排序
* 1）将数组变成大根堆
* 2）把最后一个和堆顶位置交换 堆长度减1
* 3）从0到最后做 heapify
* 解决贪心问题，优先性排序
*时间复杂度O(N*logN) 额外空间 O(1)
* @author hasee
*
*/
public static void heapSort(int[] arr) {
if(arr == null || arr.length < 2) {
return;
}
for(int i = 0;i < arr.length;i++) {
heapInsert(arr, i);//先调成大根堆
}
//开始排序，每次都将最大值调到最后
int heapSize = arr.length;
swap(arr,0,--heapSize);
while(heapSize > 0) {
heapify(arr, 0, heapSize);
swap(arr, 0, --heapSize);
}
}
/**子节点上升
* 将每个子节点与父类进行比较，并交换
* @param arr
* @param index
*/
public static void heapInsert(int[]arr,int index) {
while(arr[index]>arr[(index-1)/2]) {
swap(arr,index,(index-1)/2);
index=(index-1)/2;
}
}
/**
* 父节点下沉过程
* @param arr
* @param index
* @param heapSize
*/
public static void heapify(int[] arr,int index,int heapSize) {
int left = index*2+1;
while(left<heapSize) {
int largest = (left+1<heapSize && arr[left+1]>arr[left]) ?(left+1):left;
largest = arr[largest] > arr[index] ? largest : index;
if(largest == index)
break;
swap(arr,index,largest);
index = largest;
left = index*2+1;
}
}