排序算法 java实现

为了笔试，用了一下午准备了下各种排序算法的java实现。给大家提供个方便，把代码都贴出来，算法的具体过程以后再补。

冒泡排序

package sort;

public class BubbleSort {
public static void swap(int[] source,int x,int y){
    int temp=source[y];
    source[y]=source[x];
    source[x]=temp;
}
/*
 * 每次将最大的气泡沉底，需要(n-1)趟扫描，每次扫描(n-i)次
 * 复杂度O(n2)
 * 稳定
 */
public static void sort(int[] source){
    for(int i=source.length-1;i>0;i--){
        for(int j=0;j<i;j++){
            if(source[j]>source[j+1])
                swap(source, j, j+1);
        }
    }
}

public static void main(String[] args) {
    int[] source={9,3,6,2,1,8,4,5};
    sort(source);
    for (int i = 0; i < source.length; i++) {
        System.out.print(source[i]);
    }
}
}

　　

改进冒泡排序

package sort;

public class AdvancedBubbleSort {
public static void swap(int[] source,int x,int y){
    int temp=source[y];
    source[y]=source[x];
    source[x]=temp;
}

public static void sort(int[] source){
    for(int i=source.length-1;i>0;i--){
        boolean exchange=false;
        for(int j=0;j<i;j++){
            if(source[j]>source[j+1]){
                swap(source, j, j+1);
                exchange=true;
            }
        }
        if(!exchange)//如果本轮没有发生交换，则终止排序
            return;
    }
}

public static void main(String[] args) {
    int[] source={9,3,6,2,1,8,4,5};
    sort(source);
    for (int i = 0; i < source.length; i++) {
        System.out.print(source[i]);
    }
}
}

选择排序

package sort;

public class SelectionSort {
    public static void swap(int[] source,int x,int y){
        int temp=source[y];
        source[y]=source[x];
        source[x]=temp;
    }
    //第n轮扫描选择没有排序的序列（即n后边的）中最小的数值与第n处交换
    //复杂度O(n2)
    //不稳定
    public static void sort(int[] source){
        for(int i=0;i<source.length-1;i++){
            for(int j=i+1;j<source.length;j++){
                if(source[j]<source[i])
                    swap(source, i, j);
            }
        }
    }
    
    public static void main(String[] args) {
        int[] source={9,3,6,2,1,8,4,5,0,7};
        sort(source);
        for (int i = 0; i < source.length; i++) {
            System.out.print(source[i]);
        }
    }
}

插入排序

package sort;

public class InsertSort {
    public static void swap(int[] source,int x,int y){
        int temp=source[y];
        source[y]=source[x];
        source[x]=temp;
    }
    /*
     * 注意和选择排序的区别，选择排序是每次在剩下没排序序列中选择一个最小的放到当前位置
     * 插入排序是每次将当前位置（待排序）的放到前边已排序序列中的合适位置
     * 复杂度O(n2):这么想，要扫描n-1轮，每轮n-i次
     * 适合数据量级小于千
     */
    public static void sort(int[] source){
        for(int i=0;i<source.length-1;i++){
            for(int j=i+1;j>0;j--){
                if(source[j]<source[j-1])
                    swap(source, j, j-1);
                else 
                    break;
            }
        }
    }
    
    public static void main(String[] args) {
        int[] source={9,3,6,2,1,8,4,5,0,7};
        sort(source);
        for (int i = 0; i < source.length; i++) {
            System.out.print(source[i]);
        }
    }
}

Shell排序

package sort;

public class ShellSort {
    public static void swap(int[] source,int x,int y){
        int temp=source[y];
        source[y]=source[x];
        source[x]=temp;
    }
    /*所谓的分组插入排序，开始时分组多，组内数据少，直接插入排序较快；
     * 逐渐分组少，组内数据量大，但组内数据接近有序状态，所以总体快于直接插入排序
     * O(n2)?
     * 不稳定
     */
    public static void shellPass(int[] source, int d){
        for(int i=d;i<source.length;i++){//from 0
            if(source[i]<source[i-d]){
                swap(source, i, i-d);
            }
        }
    }
    
    public static void sort(int[] source){
        int increment=source.length/2+1;  //保证首次分两组才能保证充分排序
        while(increment>1){
            shellPass(source, increment);
            increment=increment/3+1;      //除以3保证不会再增量等于2时无限循环
            if(increment==1)              //保证最后增量=1，单独处理
                shellPass(source, 1);
        }    
    }
    
    public static void main(String[] args) {
        int[] source={49,38,65,97,76,13,27,49,55,4,18,0,74,06};
        sort(source);
        for (int i = 0; i < source.length; i++) {
            System.out.print(source[i]+" ");
        }
    }
}

二分排序

package sort;

public class BinSort {
/*不要与二分搜索混淆，只是对直接插入排序的改进，每一次在已排序的序列中使用二分查找找到合适位置插入当前待排序那个数值
 * 注意找到位置后该位置全部后移，由于数组实现，所以后移时是倒着进行，这时当前待排序数值会被抹掉，所以temp记住它
 * 查找O(nlog(n)),元素移动次数O(n2),故时间O(n2)
 */
public static void sort(int[] source){
    int low,high,mid;
    int temp;
    for(int i=0;i<source.length;i++){
        temp=source[i];
        low=0;
        high=i-1;
        while(low<=high){
            mid=(low+high)/2;
            if(source[mid]>temp){
                high=mid-1;//要排序元素在已经排过序的数组左边
            }else{
                low=mid+1;
            }
        }
        for(int j=i-1;j>high;j--){//找到了要插入的位置，然后将这个位置以后的所有元素向后移动
            source[j+1]=source[j];
        }
        source[high+1]=temp;
    }
    
}

public static void main(String[] args) {
    int[] source={49,38,65,97,76,13,27,49,55,4,18,0,74,06};
    sort(source);
    for (int i = 0; i < source.length; i++) {
        System.out.print(source[i]+" ");
    }
}
}

快速排序

package sort;

public class QuickSort {
    /*第一趟将起始位置值作为基准，从后向前扫描，找出小于povit的值，替换左边值
     * 立刻从左边开始扫描，查找大于povit的值，替换右边，知道将所有值分到povit两边
     * 不稳定
     * 平均时间复杂度O(nlogn),最差复杂度O(n2)
     */
    public static void sort(int[] source, int low, int high){
        int h=high;
        int l=low;
        int povit=source[low];
        
        while(l<h){
            
            while(l<h&&source[h]>=povit){
                h--;
                System.out.println("h="+h);
            }
            
            if(l<h){
                int temp=source[h];
                source[h]=source[l];
                source[l]=temp;
                l++;//加的是左边，因为只能保证左边加入一个不大于povit的值
            }
            
            while(l<h&&source[l]<=povit){
                l++;
            }
            
            if(l<h){
                int temp=source[h];
                source[h]=source[l];
                source[l]=temp;
                h--;//同理，减得右边
            }
        }
        System.out.print("l="+(l+1)+"h="+(h+1)+"povit="+povit+"
");
        //此时一定有l=h
        if(l>low)
            sort(source, low, h-1);
        if(h<high)
            sort(source, h+1, high);
    }
    
    public static void main(String[] args) {
        int[] source={49,38,65,97,76,13,27,49,55,4,18,0,74,06};
        sort(source,0,source.length-1);
        for (int i = 0; i < source.length; i++) {
            System.out.print(source[i]+" ");
        }
    }
}

归并排序

package sort;

public class MergeSort {

//将有二个有序数列a[first,...,mid]和a[mid+1,...,last]合并。
public static void mergeArray(int a[], int first, int mid, int last, int temp[]){
    int i=first;
    int j=mid+1;
    int k=0;
    
    while(i<=mid&&j<=last){
        if(a[i]<a[j])
            temp[k++]=a[i++];
        else
            temp[k++]=a[j++];
    }
    
    while(i<=mid){
        temp[k++]=a[i++];
    }
    while(j<=last){
        temp[k++]=a[j++];
    }
    
    for(i=0;i<k;i++)//copy
        a[first+i]=temp[i];
}

/*先分割再合并，当数组只有一个元素时为有序，有序数组之间合并得到有序数组
 * 稳定
 * O(nlogn)
 */
public static void mergeSort(int a[],int first,int last,int temp[]){
    if(first<last){
        int mid=(first+last)/2;
        mergeSort(a, first, mid, temp);//左边有序
        mergeSort(a, mid+1, last, temp);//右边有序
        mergeArray(a, first, mid, last, temp); //再将二个有序数列合并  
    }
}

public static void main(String[] args) {
    int[] source={49,38,65,97,76,13,27,49,55,4,18,0,74,06};
    int[] temp=new int[source.length];
    mergeSort(source,0,source.length-1,temp);
    for (int i = 0; i < source.length; i++) {
        System.out.print(source[i]+" ");
    }
}
}