排序

排序算法

先写一下快速排序吧，因为是几个排序中比较重要的排序。。
一下三种排序平均复杂度都是O(nlogn)其中快排的最坏情况时O(n*n),其余的最坏最好都是nlogn.
堆排序和快速排序都是一种不稳定的排序

1. 快速排序

首先，快速排序是通过一趟排序，把数组分成两部分，左边部分全部小于等于某个值，右边部分全部大于等于某个值，即把某个值放在了它应该在的位置，并把所有小于他的数放在他的左边，所有大于他的数放在他的右边。然后在按此方法把两部分继续排序，可以用递归来做

下面附上代码

public class quickSort {
 public static void quickSort(int []a,int begin,int end){
  if(begin<end){
  int i = begin;
  int j = end;
  int key = a[begin];
  while(i<j){
   while(i<j&&a[j]>key)
    j--;
   if(i<j){
    a[i] = a[j];
    i++;
   }
   while(i<j&&a[i]<key)
    i++;
   if(i<j){
    a[j] = a[i];
    j--;
   }
  }
  a[i] = key;
  quickSort(a,begin,i-1);
  quickSort(a,i+1,end);
 }
 }
 public static void main(String []args){
  int a[] = {23,43,287,23,0,24};
  quickSort.quickSort(a, 0, a.length-1);
  for(int i = 0;i<a.length;i++)
   System.out.print(a[i]+" ");
 }
}

有图有真相

2.归并排序

归并排序采用二分法，将数组分成两部分。然后继续对这两部分进行拆分，对于没拆分的两部分，分别对他们进行排序，然后进行合并，最后得到的就是一个排序的数组了，不再过多解释。

public class mergeSort {
 public static void mergeSort(int a[],int low,int high){
  if(low<high){
   mergeSort(a,low,(low+high)/2);
   mergeSort(a,(low+high)/2+1,high);
   merge(a,low,(low+high)/2,high);
  }
 }
 public static void merge(int []a,int low,int mid,int high){
  int b[] = new int[high-low+1];
  int s = low;
  int t = mid+1;
  int k = 0;
  
  while(s<=mid&&t<=high){
   if(a[s]<=a[t])
    b[k++] = a[s++];
   else
    b[k++] = a[t++];
  }
  while(s<=mid)
   b[k++] = a[s++];
  while(t<=high)
   b[k++] = a[t++];
  for(int i = 0;i<b.length;i++){
   a[low+i] = b[i];
  }
 }
 public static void main(String [] args){
  //ArrayList<Integer> a = new ArrayList<Integer>();
  int a[] = {787,98,15,78,65,-28};
  mergeSort.mergeSort(a,0,a.length-1);
  for(int i = 0;i<a.length;i++){
  System.out.print(a[i]+" ");
  } 
 }
}

3.堆排序

堆排序是采用了一种堆的数据结构排序的算法。有大顶堆和小顶堆。他们之间的下标与结点有一个关系
大顶堆：arr[i] >= arr[2i+1] && arr[i] >= arr[2i+2]
小顶堆：arr[i] <= arr[2i+1] && arr[i] <= arr[2i+2]
当要升序排列时要建大顶堆，反之小顶堆
把堆顶元素往最后换，重新调整大顶堆，一只重复此步骤，最后会变成一个升序的数组
附上代码：

public class heapSort {
 public static void heapSort(int [] array){
  for(int i = array.length/2-1;i>=0;i--)
   adjustHeap(array,i,array.length);
  for(int j = array.length-1;j>0;j--){
   int temp = array[j];
   array[j] = array[0];
   array[0] = temp;
   adjustHeap(array,0,j);
  }
    
 }
 public static void adjustHeap(int []array,
   int i,int length){
  int temp = array[i];
  for(int k = 2*i+1;k<length;k=k*2+1){
   if(k+1<length&&array[k]<array[k+1])
    k++;
   if(array[k]>temp){
    array[i] = array[k];
    i = k;
   }
   else
    break;
  }
  array[i] = temp;
 }
 public static void main(String []args){
  int b[] = {83,9,67,4,-2,56,23,18};
  heapSort.heapSort(b);
  for(int i = 0;i<b.length;i++){
   System.out.print(b[i]+" ");
  }
 }
}