Java实现冒泡排序和快速排序，选择…

冒泡：

public class Sort {
  public static void main(String[] args) {
    int[] values = {
        3, 1, 6, 2, 9, 0, 7, 4, 5
    };
    sort(values);
    for (int i = 0; i < values.length; ++i) {
      System.out.println("Index: " + i + "Value: " + values[i]);
    }
  }

  public static void sort(int[] values) {
    int temp;
    for(int i = 0; i < values.length; ++i) {
      for (int j = 0; j < values.length - i - 1; ++j) {
        if (values[j] > values[j + 1]) {
          temp = values[j];
          values[j] = values[j + 1];
          values[j + 1] = temp;
        }
      }
    }
  }
}

 

快速排序

 

public class QuickSort {
 
  public static void swap(int a[], int i, int j) {
    if (i == j) {
      return;
    }
    int tmp = a[i];
    a[i] = a[j];
    a[j] = tmp;
  }

 
  public static int partition(int array[], int low, int high) {
    //当前位置为第一个元素所在位置
    int p_pos = low;
    //采用第一个元素为轴
    int pivot = array[p_pos];
    for (int i = low + 1; i <= high; i++) {
      if (array[i] < pivot) {
        p_pos++;
        swap(array, p_pos, i);
        for (int m = 0; m < array.length; ++m) {
          System.out.println("Index: " + m + "Value: " + array[m]);
        }
      }
    }
    swap(array, low, p_pos);
    return p_pos;
  }

 
  public static void quickSort(int array[], int low, int high) {
    if (low < high) {
      int pivot = partition(array, low, high);
      quickSort(array, low, pivot - 1);
      quickSort(array, pivot + 1, high);
    }
  }

  public static void main(String[] args) {
    QuickSort quicksort = new QuickSort();
    int[] values = {
        3, 1, 6, 2, 9, 0, 7, 4, 5};
    quicksort.quickSort(values, 0, 8);
    for (int i = 0; i < values.length; ++i) {
      System.out.println("Index: " + i + "Value: " + values[i]);
    }
  }
}

福利送另两个算法：

 

java选择排序和二分查找

package cn.com.exception;

public class Search
{

public static void main(String[] args)
{
   int[] arr = {1,3,4,56,34,22,35,87,23};
   Search.searchSort(arr);
   for(int e: arr){
    System.out.print(e + " ");
   }
   System.out.println();
   int index = Search.binarySearch(arr, 22);
   System.out.println(index);
}

// 选择排序(主要是用K记录位置避免多次交换)
public static void searchSort(int[] a){
   int temp, k;
   for(int i = 0; i < a.length; i++){
    k = i;
    for(int j = k + 1; j < a.length; j++){
     if(a[j] < a[k]){
      k = j;
     }
    }
    if(k != i){
     temp = a[i];
     a[i] = a[k];
     a[k] = temp;
    }
   } 
}

// 二分法查找(每次折半根据与中间位置的对比向左向右继续折半)
public static int binarySearch(int[] a, int num){
   if(a.length == 0) return -1;
   int startPos = 0;
   int endPos = a.length - 1;
   int m = (startPos + endPos) / 2; 
   while(startPos <= endPos){
    if(num == a[m]) return m;
    if(num > a[m]){
     startPos = m + 1;
    }
    if(num < a[m]){
     endPos = m - 1;
    }
    m = (startPos + endPos) / 2;   
   }
   return m;  
}
}