基本排序算法java实现

/**
 *
 */
package sort;

import java.util.ArrayList;
import java.util.List;
import java.util.Random;



/**
 * 功能描述. 排序算法JAVA实现
 *
 */
public class Sort {

    private List<Integer> list;
    // 数组的数据长度
    private final static int length = 10;

    private int size = 0;

    public Sort(int size) {
        if (size > 0)
            this.size = size;
        else
            this.size = length;
        list = new ArrayList<Integer>(size);
        init();
    }

    public Sort() {
        this(0);
    }

    private void init() {
        for (int i = 0; i < size;) {
            Random r = new Random();
            Integer x = r.nextInt(size);
            // // if (!list.contains(x)) {
            list.add(x);
            i++;
        }

        System.out.println("init complete");
    }

    // 更换数组中i,j下标上的数据
    private void change(int i, int j) {
        int a = list.get(i);
        list.set(i, list.get(j));
        list.set(j, a);
    }

    /**
     * 冒泡排序算法实现
     */
    public void bulleSort() {
        long start = System.currentTimeMillis();
        for (int j = 0; j < list.size() - 1; j++) {
            // 遍历数组，当前数字比后一个数字小，更换数字的坐标
            for (int i = 0; i < list.size() - 1 - j; i++) {
                if (list.get(i) > list.get(i + 1)) {
                    change(i, i + 1);
                }
            }
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    /**
     * 选择排序
     */
    public void selectSort() {
        long start = System.currentTimeMillis();
        for (int j = 0; j < list.size(); j++) {
            int x = j;
            for (int i = j + 1; i < list.size(); i++) {
                if (list.get(i) < list.get(x)) {
                    x = i;
                }
            }
            if (x != j)
                change(j, x);
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    /**
     * 插入排序算法实现
     */
    public void insertSort() {
        long start = System.currentTimeMillis();
        for (int i = 1; i < list.size(); i++) {
            int a = list.get(i);
            // 默认i之前的数据有序
            for (int j = i - 1; j >= 0;) {
                if (list.get(j) > a) {
                    change(j, j + 1);
                    j--;
                } else
                    break;
                // 跳出当前for循环
            }
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    /**
     * 将数组中的数据打印
     */
    public void display() {
        for (Integer i : list) {
            System.out.print(i + " ");
        }
        System.out.println();
    }

    // 希尔排序-选择排序实现
    public void shellSort1() {
        long start = System.currentTimeMillis();
        int h = 1;
        while (h < list.size()) {
            h = 3 * h + 1;
        }
        h = (h - 1) / 3;
        while (h >= 1) {
            for (int j = 0; j < h; j++) {
                for (int y = j; y < list.size(); y += h) {
                    int x = y;
                    for (int i = y + h; i < list.size(); i += h) {
                        if (list.get(i) < list.get(x)) {
                            x = i;
                        }
                    }
                    change(y, x);
                }
            }
            h = (h - 1) / 3;
        }
        System.out.println(System.currentTimeMillis() - start);
    }

    // 希尔排序-插入排序实现
    public void shellSort() {
        long start = System.currentTimeMillis();
        int h = 1;
        while (h < list.size()) {
            h = 3 * h + 1;
        }
        h = (h - 1) / 3;
        while (h >= 1) {
            for (int i = h; i < list.size(); i++) {
                int a = list.get(i);
                for (int j = i - h; j >= 0; j -= h) {
                    if (list.get(j) > a) {
                        list.set(i, list.get(j));
                        i = j;
                    } else
                        j = -i;
                }
                list.set(i, a);
            }
            h = (h - 1) / 3;
        }
        System.out.println(System.currentTimeMillis() - start);
    }
//划分
    public void partition() {
        int x = 0;
        int a = list.get(x);
        int i = x + 1;
        int j = list.size() - 1;
        while (true) {
            while (i < j && list.get(j) > a) {
                j--;
            }
            while (i < j && list.get(i) <= a) {
                i++;
            }
            if (i >= j) {
                if (list.get(j) < a)
                    change(x, j);
                else
                    change(x, j - 1);
                break;
            } else {
                change(i, j);
            }
            this.display();
        }
    }

    private int getMid(int start, int end) {
        int mid = (start + end) >> 1;
        int max = start;
        if (list.get(max) < list.get(mid))
            max = mid;
        if (list.get(max) < list.get(end))
            max = end;
        if (max != end)
            change(max, end);
        if (list.get(start) > list.get(mid))
            change(start, mid);
        return mid;
    }

    private int partition(int start, int end) {
        int a = list.get(start);
        int i = start + 1;
        int j = end;
        while (true) {
            while (i < j && list.get(j) > a) {
                j--;
            }
            while (i < j && list.get(i) <= a) {
                i++;
            }
            if (i >= j) {
                if (list.get(j) < a) {
                    change(start, j);
                    return j;
                } else {
                    change(start, j - 1);
                    return j - 1;
                }
            } else
                change(i, j);
        }
    }
    //快速排序
    public void quickSort() {
        long start = System.currentTimeMillis();
        if (list.size() > 0)
            quickSort(0, list.size() - 1);
        System.out.println(System.currentTimeMillis() - start);
    }

    private void quickSort(int start, int end) {
        if (start >= end)
            return;
        else {
            int partition = this.partition(start, end);
            quickSort(start, partition - 1);
            quickSort(partition + 1, end);
        }
    }
//快速排序
    public void quickSortMid() {
        long start = System.currentTimeMillis();
        quickSortMid(0, list.size() - 1);
        System.out.println(System.currentTimeMillis() - start);
    }

    private void quickSortMid(int start, int end) {
        if (start + 2 >= end)
            getMid(start, end);
        else {
            int partition = partitionMid(start, end);
            quickSortMid(start, partition - 1);
            quickSortMid(partition + 1, end);
        }
    }

    private int partitionMid(int start, int end) {
        int a = list.get(getMid(start, end));
        int i = start + 1;
        int j = end - 1;
        while (true) {
            while (i < j && list.get(i) < a) {
                i++;
            }
            while (i < j && list.get(j) > a) {
                j--;
            }
            if (i >= j) {
                break;
            } else {
                change(j, i);
            }
        }
        return i;
    }

    public static void main(String[] args) {
        Sort sort = new Sort(1000);
        // sort.display();
        // 冒泡排序1134
//        sort.bulleSort();
//        sort.display();

        // 选择排序477
//        sort.selectSort();
//        sort.display();

        // 插入排序773
//        sort.insertSort();
//        sort.display();
        // 1000
//        sort.shellSort();
//        sort.display();

//        sort.shellSort1();
//        sort.display();
        // sort.partition();
        // sort.partition(0, 9);

        // sort.quickSort();
        // sort.display();

        // sort.quickSortMid();
        // sort.display();

        // sort.display();

    }
}