本科生码农应该会的6种基本排序算法(《数据结构与算法》)

　　如题，本文就《数据结构与算法》书中的7种基本算法做了一个java工程，此处结合工程启发大家其实很多东西做起来并不难，关键在于思想；工程利用coding中常用的继承思想使coder只需关注最重要的算法编码，而不用为每个算法的test一遍遍的复制粘贴：

1.工具类：

package util;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;



public class ReadFromCmd {
    private BufferedReader bin = new BufferedReader(new InputStreamReader(System.in));
    private BufferedWriter bout = new BufferedWriter(new OutputStreamWriter(System.out));
    public int[] read(){
        int[] res = null;
        try {
            String str = bin.readLine();
            String[] strs = str.split(" ");
            res = new int[strs.length];
            for (int i = 0; i < strs.length; i++) {
                res[i] = Integer.valueOf(strs[i]);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return res;
    }
    
    public void write(String out){
        try {
            bout.write(out);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
    public void close(){
        try {
            bin.close();
            bout.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

2.基类：

package sorts;

import java.util.Arrays;

import util.ReadFromCmd;

public abstract class ISort {
    protected int[] needSort = new int[10];

    public String getPrint(){
        return Arrays.toString(needSort);
    }

    public ISort(int[] needSort) {
        super();
        this.needSort = needSort;
    }
    
    public ISort() {
    }
    
    abstract void sort(int[] sortArray);
    
    public void test(){
        ReadFromCmd util = new ReadFromCmd();
        System.out.println("please give a int array using \" \" to split to test:");
        this.needSort = util.read();
        long startTime = System.currentTimeMillis();
        sort(needSort);
        long endTime = System.currentTimeMillis();
        System.out.println("the result is:"+getPrint()+" cose time is "+(endTime-startTime)+" ms");
        util.close();
    }
    
    public void test(int[] sortArray){
        long startTime = System.currentTimeMillis();
        this.needSort = sortArray;
        sort(needSort);
        long endTime = System.currentTimeMillis();
        System.out.println("the result is:"+getPrint()+" cose time is "+(endTime-startTime)+" ms");
    }
}

3.各种排序子类：

　　1).冒泡：

package sorts;

public class BubbleSort extends ISort {

    public BubbleSort() {
        super();
    }
    
    public void sort(int[] sortArray){
        for (int i = sortArray.length - 1; i > 0; i --) {
            for (int j = 0; j < i; j++) {
                if(sortArray[j] > sortArray[j + 1]){
                    int tmp = sortArray[j];
                    sortArray[j] = sortArray[j + 1];
                    sortArray[j + 1] = tmp;
                }
            }
        }
    }
    
    public static void main(String[] args) {
        BubbleSort bsort = new BubbleSort();
        bsort.test();
    }
}

　　2).插入：

package sorts;

public class InsertSort extends ISort{

    @Override
    void sort(int[] sortArray) {
        for (int i = 0; i < sortArray.length; i++) {
            //记录i出错
            int j = i;
            int base = sortArray[i];
            
            while(j > 0 && sortArray[j - 1] > base){
                sortArray[j] = sortArray[j - 1];
                j --;
            }
            
            sortArray[j] = base;
        }
    }
    
    public static void main(String[] args) {
        InsertSort sort = new InsertSort();
        sort.test();
    }
}

　　3).归并排序

package sorts;

public class MergeSort extends ISort{
    private int[] theArray;
    
    @Override
    void sort(int[] sortArray) {
        theArray = new int[sortArray.length];
        recMergeSort(sortArray, 0, sortArray.length - 1);
    }
    
    /**
     * 对数组一份为2进行递归排序，同时，当两个小组排序完成后，对整体进行归并排序
     * 
     * 典型的递归格式
     * @param sortArray
     * @param off
     * @param end
     */
    private void recMergeSort(int[] sortArray, int off, int end){
        //off == end的判断条件出错
        if(off == end){
            return;
        } else {
            int mid = (off + end) / 2;
            recMergeSort(sortArray, off, mid);
            recMergeSort(sortArray, mid + 1, end);
            
            mergeSort(sortArray, off, mid, end);
        }
    }
    
    private void mergeSort(int[] sortArray, int off, int mid, int end){
        int index = 0;
        int firstIndex = off;
        int secondIndex = mid + 1;
        int len = end - off + 1;
        /**
         * 如果完成全部的归并，则：
         *     判断第一段数组中的值跟第二段中的大小，取小的存入中间数据
         * 
         * 如果第一段全部排序完，则直接拷贝第二段的数据至中间数组
         */
        while(index < len - 1){
            if(sortArray[firstIndex] > sortArray[secondIndex]){
                theArray[index ++] = sortArray[secondIndex ++];
            } else {
                theArray[index ++] = sortArray[firstIndex ++];
            }
            
            if(firstIndex > mid){
                for (int i = secondIndex; i <= end; i++) {
                    theArray[index ++] = sortArray[secondIndex ++];
                }
            }
            
            if(secondIndex > end){
                for (int i = firstIndex; i <= mid; i++) {
                    theArray[index ++] = sortArray[firstIndex ++];
                }
            }
        }
        
        /**
         * 将中间数组中的值拷贝到原数组中去
         */
        for (int i = 0; i < len; i++) {
            sortArray[off + i] = theArray[i];
        }
    }
    
    public static void main(String[] args) {
        MergeSort sort = new MergeSort();
        sort.test();
    }
}

　　4).快速排序

package sorts;

public class QuickSort extends ISort{

    @Override
    void sort(int[] sortArray) {
        quickSort(sortArray, 0, sortArray.length - 1);
    }
    
    public void quickSort(int[] needSort, int left, int right){
        int preLeft = left;
        int preRight = right;
        int base = needSort[left];

        while(left < right){
            while(left < right && needSort[right] > base){
                right --;
            }
            needSort[left] = needSort[right];
            
            while(left < right && needSort[left] < base){
                left ++;
            }
            needSort[right] = needSort[left];
        }
        needSort[left] = base;
        
        //这里的大小注意，如果left前面只有一个了 也不用比较
        if(left > preLeft + 1){
            quickSort(needSort, preLeft, left - 1);
        }
        
        if(right < preRight - 1){
            quickSort(needSort, left + 1, preRight);
        }
    }
    
    public static void main(String[] args) {
        QuickSort test = new QuickSort();
        test.test();
    }
}

　　5).选择排序

package sorts;

/*
 * 每一次选出最大的那个与尾部数据进行交换
 */
public class SelectSort extends ISort{

    @Override
    void sort(int[] sortArray) {
        for (int i = sortArray.length - 1; i > 0; i --) {
            int base = 0;
            for (int j = 0; j <= i; j++) {
                if(sortArray[base] < sortArray[j]){
                    base = j;
                }
            }
            
            if(base != i){
                int tmp = sortArray[i];
                sortArray[i] = sortArray[base];
                sortArray[base] = tmp;
            }
        }
    }

    public static void main(String[] args) {
        SelectSort sort = new SelectSort();
        sort.test();
    }
}

　　6).希尔排序：

package sorts;

public class ShellSort extends ISort{

    @Override
    void sort(int[] sortArray) {
        int len = sortArray.length;
        int h = 0;
        if(len < 5){
            h = 1;
        } else if(len < 14){
            h = 4;
        } else if(len < 41){
            h = 13;
        } else if(len < 122){
            h = 40;
        } else if(len < 365){
            h = 121;
        } else if(len < 1093){
            h = 364;
        } else if(len < 3281){
            h = 1093;
        } else if(len < 9842){
            h = 3280;
        } else if(len < 29523){
            h = 9841;
        } else {
            System.out.println("the array's length is too big to sort, please up the h");
            return;
        }
        shellSort(sortArray, h);
    }
    
    private void shellSort(int[] sortArray, int h){
        while(h != 0){
            for (int i = 0; i < sortArray.length; i++) {
                int j = i;
                
                for (;j < sortArray.length; j = j + h){
                    int k = j;
                    //用base存下要比较的数，以免移动的时候被覆盖
                    int base = sortArray[j];
                    
                    //k >= h这里出错过
                    while(k >= h && sortArray[k - h] > base){
                        sortArray[k] = sortArray[k - h];
                        
                        k -= h;
                    }
                    
                    //找到所在的位置后，赋值
                    sortArray[k] = base;
                }
                
                if(1 == h){
                    return;
                }
            }
            h = (h - 1) / 3;
        }
        
        
    }
    
    public static void main(String[] args) {
        ShellSort sort = new ShellSort();
        sort.test();
    }
}

4.所有方法为原始思想的coding实现，不包含变换！