排序算法Java实现

package meify.sort;




/**
 * @description  排序(以下默认均为升序排列)
 * 1、冒泡排序
 * 2、插入排序
 * 3、折半排序
 * 4、快速排序
 * 5、简单选择排序
 * 6、堆排序
 * 7、归并排序
 * 8、希尔排序
 * 9、基数排序
 * @version 1.0
 * @author meify  2013-7-30 下午4:44:23 
 */
public class SortDemo {


/*
* 冒泡排序
     *排序过程
     *将第一个记录的关键字与第二个记录的关键字进行比较，若为逆序r[1].key>r[2].key，则交换；然后比较第二个记录与第三个记录；依次类推，直至第n-1个记录和第n个记录比较为止——第一趟冒泡排序，结果关键字最大的记录被安置在最后一个记录上
     *对前n-1个记录进行第二趟冒泡排序，结果使关键字次大的记录被安置在第n-1个记录位置
     *重复上述过程，直到“在一趟排序过程中没有进行过交换记录的操作”为止
*/
public void bubbleSort(int[] array){
int i=array.length;
while(i>1){
int exchangeIndex=1;
for(int j=0;j<i-1;j++){
if(array[j]>array[j+1]){
int temp=array[j+1];
array[j+1]=array[j];
array[j]=temp;
exchangeIndex=j;
}
}
i=exchangeIndex;
}
}

/**
* 
* @param array
* @version 1.0
* @description  直接插入排序
* @author meify  2013-7-31 上午10:01:55
*/
public void insertSort(int[] array){
int len=array.length;
for(int i=1;i<=len-1;i++){
int index=i;
//从后往前一一比较
for(int j=i-1;j>=0;j--){
if(array[i]<array[j]){
index=j;break;
}
}
if(index<i){
//将array[i]插入到array[index]位置
int temp=array[i];
for(int k=i-1;k>=index;k--){//从index开始全部后移
array[k+1]=array[k];
}
array[index]=temp;
}
}
}

/**
* 
* @param array
* @version 1.0
* @description 折半排序
* @author meify  2013-7-31 上午10:02:12
*/


/**
* 选择排序
* @param array
* @version 1.0
* @description   每一趟从待排序的数据元素中选出最小（或最大）的一个元素，顺序放在已排好序的数列的最后，
* 直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
* @author meify  2013-7-31 上午10:03:38
*/
public void selectSort(int[] array){
int len=array.length;
for(int i=0;i<len;i++){
int index=min(array,i);
if(index!=i){
int temp=array[index];
array[index]=array[i];
array[i]=temp;
}
}
}
/**
* 找出数组中从start位置开始最小元素的index
*/
public int min(int[] array,int start){
int index=start;
int min=array[start];
for(int i=start;i<array.length;i++){
if(array[i]<min){
index=i;
}
}
return index;
}


/**
* 快速排序
* @param array
* @version 1.0
* @description 它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，
*  其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，
*  整个排序过程可以递归进行，以此达到整个数据变成有序序列。
* @author meify  2013-7-31 上午10:21:36
*/
public void quickSort(int[] array, int low, int high) {  
        if(low < high) {  
            int pa = partition(array, low, high); 
            //递归快排左右两边的数组
            quickSort(array, low, pa-1);  
            quickSort(array, pa+1, high);  
        }  
    }  
/*
* 一趟快速排序: 
* 注意:关键key永远不变，永远是和key进行比较，无论在什么位置，最后的目的就是把key放在中间，小的放前面大的放后面。
*/
    private int partition(int[] array, int low, int high) {  
        int key = array[low];  
        while(low < high) { 
       
            while(array[high]>key) high--; 
            //交换low和high位置的值
            int temp=array[low];
            array[low] = array[high];  
            array[high]=temp;
            //交换low和high位置的值
            while(array[low]<key ) low++; 
            int temp1=array[high];
            array[high] = array[low];
            array[low]=temp1;
        }  
        show(array);
        //此时low==high 且array[low]==key
        return low;  
    }  
    
 
    /**
     * 归并排序（递归算法）
     * @param array
     * @version 1.0
     * @description 归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，
     * 即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。
     * @author meify  2013-7-31 下午3:33:48
     */
    public void mergeSort(int[] r, int low, int high) {  
        if(low<high) {  
            mergeSort(r, low, (high+low)/2);  
            mergeSort(r, (high+low)/2+1, high);  
            merge(r, low, (high+low)/2, high);  
        }  
    }  
    /*
     * 合并两个有序数组
     */
    private void merge(int[] a, int low, int middle, int high) {  
    int[] new_array = new int[high-low+1];  
        int p1 = low;  
        int p2 = middle+1;  
        int k=0;  
        while(p1<=middle && p2<=high) {  
            if(a[p1]<a[p2])  
            new_array[k++] = a[p1++];  
            else   
            new_array[k++] = a[p2++];  
        }  
        while(p1<=middle)  
        new_array[k++] = a[p1++];  
        while(p2<=high)   
        new_array[k++] = a[p2++]; 
        //再将合并后的数组赋给原数组
        for(int i=0; i<new_array.length; i++)  
            a[low+i] = new_array[i];  
    }  
 

/**
* 遍历数组
* @param array
* @version 1.0
* @description 
* @author meify  2013-7-31 上午10:07:50
*/
public void show(int[] array){
for(int i:array){
System.out.print(i+"t");
}
System.out.println();
}

public static void main(String[] args) {
int[] arr={49,38,65,97,76,13,27};

SortDemo sort=new SortDemo();
// sort.bubbleSort(arr);
// sort.insertSort(arr);
// sort.selectSort(arr);
// System.out.println("快速排序前");
// sort.show(arr);
// System.out.println("快速排序");
// sort.quickSort(arr,0,arr.length-1);
System.out.println("归并排序前");
sort.show(arr);
System.out.println("归并排序");
sort.mergeSort(arr,0,arr.length-1);
sort.show(arr);
//sort.show(arr);
}

}