冒泡、快速、直接插入、选择排序算法（Java语言实现）

一、冒泡排序

/**
 * win8.1 32位操作系统
 * @author Che‑cars
 * 2015年7月30日 下午8:35:09
 */
public class BubbleSort {
 public static void main(String[] args){
  int a[] = {45,56,4,12,86,75,46};
  for (int i = 0; i < a.length - 1 ; i++) {
   for (int j =  a.length -1; j > i; j--) {
    if(a[j] < a[j-1]){//让小数往上浮
     int temp = a[j];
     a[j] = a[j-1];
     a[j-1] = temp;
    }
   }
  }
  for (int k = 0; k < a.length; k++) {
   System.out.print(a[k] + ",");
  }
//   for (int i = 0; i < a.length - 1; i++) {
//   for (int j = 0; j < a.length - i - 1; j++) {
//    if(a[j] > a[j+1]){//让大的数往下沉
//     int temp = a[j];
//     a[j] = a[j+1];
//     a[j+1] = temp;
//    }
//   }
//  }
//  for (int k = 0; k < a.length; k++) {
//   System.out.print(a[k] + ",");
//  }
 }
}

二、直接插入

/**
 * win8.1 32位操作系统
 * @author Che‑cars
 * 2015年7月28日 下午10:25:58
 */
public class DirectInsert { //直接插入排序
 /**
  * @param args
  */
 public static void main(String args[]) {
  /**
   * 基本思想：在要排序的一组数中，假设前面（n-1）[n >= 2]个数已经排好顺序，现在要把第n个数插到前面的有序数中，
   * 使得这n个数也是排好序的，如此反复循环，直到全部排好序
   */
  
  int[] a = {23,45,32,15,11,46,75,32,25,46,35};
  int temp = 0;
  
  for(int i = 1; i < a.length; i ++){
   int j = i-1;
   temp = a[i]; //把第n个数保存到temp里面，六处空位，给前面排好序的数往后移动一个单位的时候用，不至于第n个数被覆盖
   for(; j >= 0 && temp < a[j]; j --){
    a[j+1] = a[j];//将大于temp的值整体后移一个单位
   }
   a[j+1] = temp;
  
   for(int k = 0; k < a.length; k ++){ //输出每一步的结果
    System.out.print(a[k] + ",");
   }
   System.out.println();
  }
 }
}

三、快速排序

/**
 * win8.1 32位操作系统
 * @author Che‑cars
 * 2015年8月1日 下午3:01:01
 */
public class QuikSort {
 /**
  * @param args
  * 基本思想：选择一个基准元素，通常选择第一个或者最后一个元素，通过一趟扫描，将待排序列分成两部分，一部分比基准元素小，一部分大于等于
  * 基准元素，此基准元素在其排好序后的正确位置。然后再用同样的方法递归地排序划分的两部分
  */
 public static void main(String[] args) {
  int a[] = {22,31,78,100,423,147,1000,0};
  quik(a);
  for (int i = 0; i < a.length; i++) {
   System.out.print(a[i] + ",");
  }
 }
 public static int getMiddle(int[] a, int low, int high){
  int temp = a[low]; //数组的第一个数作为中轴，
  while(low < high){ //直到两个数相遇为止
   while(low < high && a[high] >= temp){
    high --; //从数组后端开始，查找比中轴小的数值，如果>=中轴，则往前走一个
   }
   a[low] = a[high]; /*找到 小于中轴的数，将其放到a[low]的位置，此时a[low]保存在temp里，不会被覆盖，
         high空出来，以便之后找到的比中轴的的数存放*/
   while(low < high && a[low] <= temp){
    low ++; //之后再从低端开始，查找比中轴大的数，如果小于等于中轴，则往后走一个
   }
   a[high] = a[low]; //将其存放到之前空出来的high的位置
  }
  a[low] = temp; //将中轴放在该放的位置
  return low;
 }
 
 public static void _quikSort(int[] a, int low, int high){
  if(low < high){
   int middle = getMiddle(a, low, high); //将数组一分为二
   _quikSort(a, low, middle - 1); //对低端进行递归排序
   _quikSort(a, middle + 1, high); //对高端进行递归排序
  }
 }
 
 public static void quik(int[] a){
  if(a.length > 0){
   _quikSort(a, 0, a.length - 1);
  }
 }
}
四、选择排序

/**
 * win8.1 32位操作系统
 * @author Che‑cars
 * 2015年7月29日 下午9:41:52
 */
public class SelectSort {
 /**
  * @param args
  * 基本思想：在要排序的数中，找到最小的数和第一个数交换，再从剩下的数中找到最小的数和第二个数交换，直到最后两个数交换
  */
 public static void main(String[] args) {
  int a[] = {15,48,45,7,86,4,24,38,87,63};
  int position = 0;
  for (int i = 0; i < a.length; i++) {
   int temp = a[i];
   position = i;
   for (int j = i+1; j < a.length; j++) {//二重循环找到第i+1个最小的数
    if (a[j] < temp) {
     temp = a[j];//循环结束，将剩余的数中最小的数保存到temp里
     position = j;//记录下最小的数的下标，方便之后进行交换
    }
   }
   a[position] = a[i];//此时，最小的数a[j]已经存到temp中，先将a[i]放到a[j]（也就是a[position]）的位置
   a[i] = temp;//再将最小的数放到a[i]的位置，完成交换
  }
  for (int i = 0; i < a.length; i++) {
   System.out.print(a[i] + ",");
  }
 }
}