java排序算法

/**
 * 泡沫排序
 * @author Navy 稳定空间复杂度O(1) 时间复杂度O(n^2) 最差情况：反序，需要交换n*(n-1)/2个元素最好情况：正序，不需要交换元素
 */
public class BubbleSort {
 
 public void bubblesort(int a[], int n) {
  int i, j;
  int tmp;

  for (i = n - 1; i > 0; i--)
   for (j = 0; j < i; j++) {
    if (a[j] > a[j + 1]) {
     tmp = a[j];
     a[j] = a[j + 1];
     a[j + 1] = tmp;
    }
   }
 }

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  BubbleSort bs = new BubbleSort();
  int[] a = {6,3,4,2,9,7,5,1,8};
  bs.bubblesort(a, a.length);
  for (int i = 0; i < a.length; i++) {
   System.out.println(a[i]);
  }
 }

}

/**
 * 希尔排序（缩小增量排序）
 *
 * @author Navy 不稳定空间复杂度O(1) 时间复杂度优于插入排序，最坏情况下O(n^2)
 *         最差情况：有n=2^k个元素，偶数位置上有n/2个同为最大的元素，奇数位置上有n/2个同为最小的元素，此时最优最后一趟进行插入排序（例如：1
 *         5 2 6 3 7 4 8）最好情况：正序，不需要移动元素
 */
public class HillSorting {

 void shellsort(int a[], int n) {
  int i, j, increment;
  int tmp;
  for (increment = n / 2; increment > 0; increment /= 2) {
   for (i = increment; i < n; i++) {
    tmp = a[i];
    for (j = i - increment; j >= 0 && tmp < a[j]; j -= increment) {
     a[j + increment] = a[j];
    }
    a[j + increment] = tmp;
   }
  }
 }

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  HillSorting hs = new HillSorting();
  int[] a = {6,3,4,2,9,7,5,1,8};
  hs.shellsort(a, a.length);
  for (int i = 0; i < a.length; i++) {
   System.out.println(a[i]);
  }
 }

}

/**
 * 插入排序
 * 稳定空间复杂度O(1) 时间复杂度O(n^2) 最差情况：反序，需要移动n*(n-1)/2个元素最好情况：正序，不需要移动元素
 * @author Navy
 *
 */
public class InsertionSort {

 public void insertsort(int a[], int n) {
  int i, j;
  int tmp;

  for (i = 1; i < n; i++) {
   tmp = a[i];
   for (j = i - 1; j >= 0 && a[j] > tmp; j--)
    a[j + 1] = a[j];
   a[j + 1] = tmp;
  }
 }

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  InsertionSort is = new InsertionSort();
  int[] a = {6,3,4,2,9,7,5,1,8};
  is.insertsort(a, a.length);
  for (int i = 0; i < a.length; i++) {
   if(i != a.length-1)
    System.out.print(a[i] + "  ");
   else
    System.out.print(a[i]);
  }
 }

}

/**
 * 归并排序
 * @author Navy
 *
 */
public class MergeSort {

 final static int MAXVALUE = 10000;
 static int[] L;
 static int[] R;
 
 public static void Merge(int[] A,int p,int q,int r){
  int n1=q-p;//correct
  int n2=r-q+1;//correct
  //int n1 = q-p;
  //int n2 = r-q;
  L = new int[n1+1];
  R = new int[n2+1];
  for(int i = 0;i < n1;i++){
   L[i] = A[p+i];
  }
  for(int j = 0;j < n2;j++){
   R[j] = A[q+j];
  }
  
  L[n1]=MAXVALUE;
  R[n2]=MAXVALUE;
  int i = 0,j = 0;
  
  for(int k = p; k <= r ;k++){
   if(L[i]<=R[j]){
    A[k] = L[i];    
    i++;   
   }else{
    A[k] = R[j];    
    j++;
   }
  }
 }
 
 public static void MergeSort(int[] A,int p,int r){ 
  int q;  if(p<r){ 
   q = (p+r)/2;
   MergeSort(A,p,q);  
   MergeSort(A,q+1,r);  
   Merge(A,p,q+1,r);
  }
 }
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  int[] inputArray={1,3,2,6,5,2,4,7,1,3,2,6,5,2,4,7,1,3,2,6,5,2,4,7,1,3};
  MergeSort(inputArray,0,inputArray.length-1);
  for(int i=0;i<inputArray.length;i++){
   System.out.println("intArray["+i+"]="+inputArray[i]);
  }
 }

}

/**
 * 快速排序
 *
 * @author Navy
 */
public class QuickSort {

 public int partition(int[] r, int first, int end) {

  int i = first;
  int j = end;
  int temp;
  while (i < j) {
   while (i < j && r[i] <= r[j]) {
    j--;
   } // 右侧扫描
   if (i < j) {
    temp = r[i];
    r[i] = r[j];
    r[j] = temp;
    i++;
   }

   while (i < j && r[i] <= r[j]) {
    i++;
   }
   ; // 左侧扫描
   if (i < j) {
    temp = r[i];
    r[i] = r[j];
    r[j] = temp;
    j--;
   }
  }
  return i;

 }
  public void quickSort(int[] r, int first, int end) {
  int pivot;
  if (first < end) {
   pivot = partition(r, first, end);
   /*for (int i = 0; i < r.length; i++) {
    System.out.print("r[" + i + "]= " + r[i] + ",");
   }
   System.out.println(pivot);*/
   quickSort(r, first, pivot - 1);
   quickSort(r, pivot + 1, end);

  }
 }

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  QuickSort qs = new QuickSort();
  int[] a = { 6, 3, 4, 2, 9, 7, 5, 1, 8, 10 };
  qs.quickSort(a, 0, 9);
  for (int i = 0; i < a.length; i++) {
   System.out.println(a[i]);
  }
 }

}

/**
 * 选择排序
 * @author Navy
 * 不稳定空间复杂度O(1) 时间复杂度O(n^2) 最差情况：第一个元素为最大元素，其余元素正序，需要交换n-1个元素（例如：4
 *         3 2 1）最好情况：正序，不需要交换元素
 *
 */
public class SelectionSort {

 public void selectsort(int a[], int n) {
  int i, j, k;
  int tmp;

  for (i = 0; i < n - 1; i++) {
   k = i;
   for (j = i + 1; j < n; j++) {
    if (a[j] < a[k])
     k = j;
   }
   if (k != i) {
    tmp = a[i];
    a[i] = a[k];
    a[k] = tmp;
   }
  }
 }

 public static void main(String[] args) {
  // TODO Auto-generated method stub
  SelectionSort ss = new SelectionSort();
  int[] a = {6,3,4,2,9,7,5,1,8};
  ss.selectsort(a, a.length);
  for (int i = 0; i < a.length; i++) {
   System.out.println(a[i]);
  }
 }

}