Java经典排序算法

1、冒泡排序 Bubble Sort

        最简单的排序方法是冒泡排序方法。这种方法的基本思想是，将待排序的元素看作是竖着排列的 “ 气泡 ” ，较小的元素比较轻，从而要往上浮。在冒泡排序算法 中我们要对这个 “ 气泡 ” 序列处理若干遍。所谓一遍处理，就是自底向上检查一遍这个序列，并时刻注意两个相邻的元素的顺序是否正确。如果发现两个相邻元素的顺序不对，即 “ 轻 ” 的元素在下面，就交换它们的位置。显然，处理一遍之后， “ 最轻 ” 的元素就浮到了最高位置；处理二遍之后， “ 次轻 ” 的元素就浮到了次高位置。在作第二遍处理时，由于最高位置上的元素已是 “ 最轻 ” 元素，所以不必检查。一般地，第 i 遍处理时，不必检查第 i 高位置以上的元素，因为经过前面 i-1 遍的处理，它们已正确地排好序。这个算法可实现如下。

/**
  *冒泡排序
  */
  public void doBubbleSort(int[] srcarray){
       int len= srcarray.length;
       for(int i=0;i<len;i++){
           for(int j=i+1;j<len;j++){
              int temp;
              if(srcarray[i]>srcarray[j]){
                  temp=srcarray[j];
                  srcarray[j]=srcarray[i];
                  srcarray[i]=temp;
              }             
           }
           //printResult(i, srcarray);
       }   
       return srcarray; 
  }

  2、选择排序 Selection Sort

       选择排序的基本思想是：对待排序的记录序列进行 n-1 遍的处理，第 1 遍处理是将 L[1..n] 中最小者与 L[1] 交换位置，第 2 遍处理是将 L[2..n] 中最小者与 L[2] 交换位置， ...... ，第 i 遍处理是将 L[i..n] 中最小者与 L[i] 交换位置。这样，经过 i 遍处理之后，前 i 个记录的位置就已经按从小到大的顺序排列好了。
　　当然，实际操作时，也可以根据需要，通过从待排序的记录中选择最大者与其首记录交换位置，按从大到小的顺序进行排序处理。

/**
  *选择排序
  */
  public void doChooseSort(int[] src){
       int len = src.length;
       int temp;
       for(int i = 0; i < len; i++){
           temp = src[i];
           int j;
           int samllestLocation = i;//最小数的下标
             for(j = i+1; j < len; j++){
              if(src[j] < temp){
                  temp = src[j];//取出最小值
                     samllestLocation = j;//取出最小值所在下标
                }
           }
           src[samllestLocation] = src[i];
           src[i] = temp;
           //printResult(i, src);
       }
       return src;
   }

 3、插入排序 Insertion Sort

       插入排序的基本思想是，经过 i-1 遍处理后 ,L[1..i-1] 己排好序。第 i 遍处理仅将 L[i] 插入 L[1..i-1] 的适当位置，使得 L[1..i] 又是排好序的序列。要达到这个目的，我们可以用顺序比较的方法。首先比较 L[i] 和 L[i-1] ，如果 L[i-1]≤ L[i] 騆 [1..i] 已排好序，第 i 遍处理就结束了；否则交换 L[i] 与 L[i-1] 的位置，继续比较 L[i-1] 和 L[i-2] ，直到找到某一个位置 j(1≤j≤i-1) ，使得 L[j] ≤L[j+1] 时为止。
　　简言之 , 插入排序就是每一步都将一个待排数据按其大小插入到已经排序的数据中的适当位置，直到全部插入完毕。插入排序方法分直接插入排序和折半插入排序两种，这里只介绍直接插入排序，折半插入排序留到 “ 查找 ” 内容中进行。
       在下面的插入排序算法 中，为了写程序方便我们可以引入一个哨兵元素L[0]，它小于L[1..n]中任一记录。所以，我们设元素的类型ElementType中有一个常量-∞，它比可能出现的任何记录都小。如果常量-∞不好事先确定，就必须在决定L[i]是否向前移动之前检查当前位置是否为1，若当前位置已经为1时就应结束第i遍的处理。另一个办法是在第i遍处理开始时，就将L[i]放入L[0]中，这样也可以保证在适当的时候结束第i遍处理。下面的算法中将对当前位置进行判断。

 /**
   *插入排序(WHILE循环实现)
   */
    public void doInsertSort1(int[] src){
       int len = src.length;
       for(int i = 1; i < len; i++){   
           int temp = src[i];
           int j = i;
           
           while(src[j-1] > temp){
              src[j] = src[j-1];
              j--;
              if(j <= 0)
                  break;
           }
           src[j] = temp;
           //printResult(i+1, src);
       }
       return src;
   }

  /**
    *插入排序(FOR循环实现)    
     */
    public void doInsertSort2(int[] src){
       int len = src.length;
       for(int i = 1;i < len; i++) {
           int j;
           int temp = src[i];
           for(j = i; j > 0; j--){
              if(src[j-1] > temp){
                  src[j] = src[j-1];
                  
              }else//如果当前的数，不小前面的数，那就说明不小于前面所有的数，
                     //因为前面已经是排好了序的，所以直接通出当前一轮的比较
                  break;
           }
           src[j] = temp;
           //printResult(i, src);
       }
       return src;
   }

  4、快速排序Quick Sort

选择数组中的一个元素作为标准，将所有比标准小的元素放到左边，所有比标准大的元素放到右边。  并对左边和右边的元素做一样的快速排序过程。

下面是快速排序过程分析。

 

    Java代码实现如下：

/**
  * 快速排序 Quick Sort
  */
public int[] quickSort(int[] result) {
     quick(result, 0, result.length - 1);
     return result;
}

 /**
   * 选择数组中的一个元素作为标准，将所有比标准小的元素放到左边，
   * 所有比标准大的元素放到右边。
   * 并对左边和右边的元素做一样的快速排序过程。
   * @param array
   * @param startIndex
   * @param endIndex
   */
    private void quick(int[] array, int startIndex, int endIndex) {
        int pIndex = startIndex;
        for (int i = startIndex + 1; i <= endIndex; i ++) {
            if (array[i] < array[pIndex]) {
                int temp = array[i];
                for (int j = i; j > pIndex; j --) {
                    array[j] = array[j - 1];
                }
                array[pIndex] = temp;
                pIndex ++;
            }
        }
        if (pIndex - startIndex > 1) {
            quick(array, startIndex, pIndex - 1);
        }
        if (endIndex - pIndex > 1) {
            quick(array, pIndex + 1, endIndex);
        }
    }

 5、简单选择排序 SimpleSelection Sort

   每遍历未排序部分一次都选出一个最小值，并将最小值元素移动到数组前端

 /**
   * 简单选择排序 SimpleSelection Sort
   */
public int[] simpleSelectionSort(int[] result) {
      // 重复此过程：选取最小值，并将其交换至数组前端
        int minIndex = 0;
        for (int i = 0; i < result.length; i ++) {
            minIndex = i;
            for (int j = i + 1; j < result.length; j ++) {
                if (result[j] < result[minIndex]) {
                    minIndex = j;
                }
            }
            swap(result, minIndex, i);
        }
        return result;
}

 /**
   * 交换元素
   */
private void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }
}

 

       评价一个排序算法性能好坏的主要标准是它所需的计算时间和存储空间。影响计算时间的两个重要因素是比较关键字的次数和记录的移动次数。在实际应用中，究竟应该选用何种排序方法，取决于具体的应用和机器条件。