有关几种排序算法的改写（JAVA实现）

本文链接：https://blog.csdn.net/wangyoucao2003/article/details/1052000

本文参考了treeroot的blog中的代码，做了一些修改。基本的内容没变。特此声明，算法的基本描述是借鉴了treeroot的blog。本文仅仅是作为技术参考。
我一共实现了三个算法，分别是插入排序，冒泡排序，选择排序。
分为三个类进行实现，分别继承自一个抽象类Sort，代码如下：

package org.cao.algorithm;

public abstract class Sort {

public abstract void sort(Object []data)throws ArrayIndexOutOfBoundsException;

public void swap(Object []data , int i , int j)

throws ArrayIndexOutOfBoundsException{

if(i<0 || i>(data.length-1) || j<0 || j>(data.length-1)){

throw new ArrayIndexOutOfBoundsException("要交换的数据下标越界");

}

Object temp = data[i];

data[i] = data[j];

data[j] = temp ;

}

插入排序的类：

package org.cao.algorithm;

/**
* @author xxy
*
*/

/**
* 使用该类的时候只能依靠工厂方法CreateInsertSort方法来创建一个
* InsertSort类型的对象
* */
public class InsertSort extends Sort{
     private InsertSort(){}
     public static InsertSort CreateInsertSort(){
         return new InsertSort();
    }

     /**
     * 算法关键代码：
     *             把待排序的数组作为一个序列。
     *             第一次取前两个数据进行比对，如果第二个小于第一个那么插入第一个之前
     *             第二次取前三个数据进行比对，如果第三个小于第二个那么插入第二个之前。继续和第一个比较，
     *     如果仍小于第一个，那么插入第一个之前，否则停止。
     *             第三次取前四个数据进行比对，依次类推。
     *
     *     初始序列我们可以看成是空的或只有一个元素的序列，然后在循环的过程中，扩充该序列，让每次生成的序列
     *     都是从小到大排列的。
     *
     *         本算法使用了Object对象的hashCode方法作为比较数据大小的标准。如要进行某一种方式的比对，
     *     请实现hashCode方法。
     * */
     public void sort(Object[] data) throws ArrayIndexOutOfBoundsException{
         for ( int i = 1 ; i < data.length ; i ++ ){
             // 第j个元素依次和前i个元素进行比对
             for ( int j = i ; j > 0 && data[j].hashCode() < data[j - 1 ].hashCode() ; j -- ){
                swap(data , j - 1 , j);
            }
        }
    }
}

冒泡排序实现的类：

package org.cao.algorithm;

public class BubbleSort extends Sort{
     private BubbleSort(){}
     public static BubbleSort CreateBubbleSort(){
         return new BubbleSort();
    }
     public void sort(Object[] data) {
         for ( int i = 0 ; i < data.length - 1 ; i ++ ){
             /**
             * 进行排序的趟数为data.length-1次，由于下标从0开始，所以一直到data.length-2结束。
             * 每次进行排序时，从第一个数据一直比较到第data.length-i-2个数据
             * */
             for ( int j = 0 ; j < data.length - i - 1 ; j ++ ){
                 if ( data[j].hashCode() > data[j + 1 ].hashCode() ){
                     this .swap(data , j , j + 1 );
                }
            }
        }
    }
}

选择排序：

package org.cao.algorithm;

public class SelectionSort extends Sort {

private SelectionSort(){}

public static SelectionSort CreateSelectionSort(){

return new SelectionSort();

}

/**

* 算法分析：

* 把待排序数组作为一个逐渐缩短的序列来使用，每次外层循环进行就会缩减一个单位长度。

* 每次找到一个索引的下标，作为当前序列中最小元素的下标。

* 初始情况下，把循环的次数i作为最小元素下标使用。