java 数组排序

import java.util.Arrays;

/**
 * Created by asus on 2019/9/4.
 */
public class MyArraySort {
    public static void main(String[] args) {
        int[] data = {2,1,3,4,-1, 9 , 8};
        MyArraySort m = new MyArraySort();
        m.selectSort(data);
        System.out.println(Arrays.toString(data));
    }

    private void swap(int[] data, int i, int j) {
        int temp = data[i];
        data[i] = data[j];
        data[j] = temp;
    }

    //冒泡排序
    private void bubbleSort(int[] data) {
        int len = data.length;
        if(len <= 1) return;

        boolean isOrdered = true;       //默认是有序的
        for(int i = 0; i < len; i ++) {
            if(i == 0 || !isOrdered ) {         //但是第一次总得去排一排序
                isOrdered = true;           //默认是有序的
                for(int j = 0; j < len - 1 - i; j ++) {
                    if(data[j] > data[j + 1]) {
                        swap(data,j, j + 1);
                        isOrdered = false;
                    }
                }
            }

            if (isOrdered == true) break;

        }
    }


    //选择排序
    //扫描一遍，选一个最小的元素放置在首位
    private void selectSort(int[] data) {
        int len = data.length;
        if(len <= 1) return;

        for(int i = 0; i < len; i ++) {
            int minIndex = i;
            for(int j = i + 1; j < len; j ++) {
                if(data[j] < data[i]) {
                    minIndex = j;
                }
            }
            if(minIndex != i) swap(data, minIndex, i);
        }
    }


    //插入排序
    //当前这个数往前比较，如果比前面的数大，则插入后面一个位置，如果比前面的数小，则前面的数后移一位继续向前比较
    private void insertSort(int[] data) {
        int len = data.length;
        if(len <= 1) return;

        for(int i = 0; i < len; i ++) {
            int cur = data[i];
            for(int j = i - 1; j >= 0; j --) {
                if(cur >= data[j]) {
                    data[j + 1] = cur;
                    break;
                }else {
                    data[j + 1] = data[j];
                    if(j == 0) {
                        data[j] = cur;
                    }
                }
            }
        }
    }


    //快速排序
    private void quickSort(int[] data) {
        int len = data.length;
        if(len <= 1) return;

        quickSortCore(data, 0, len - 1);



    }

    private void quickSortCore(int[] data, int st, int ed) {
        if(ed > st) {
            int index = partition(data, st, ed);

            quickSortCore(data, st, index - 1);
            quickSortCore(data, index + 1, ed);
        }
    }

    private int partition(int[] data, int st, int ed) {
        int piv = data[st];

        while(st < ed) {
            while(st < ed && data[ed] >= piv) ed --;
            data[st] = data[ed];
            while(st < ed && data[st] <= piv) st ++;
            data[ed] = data[st];
        }

        data[st] = piv;
        return st;
    }

    //归并排序
    private void mergeSort(int[] data) {
        int len = data.length;
        if(len <= 1) return;

        int[] temp = new int[len];

        mergeSortCore(data, 0, len - 1, temp);



    }

    private void mergeSortCore(int[] data, int st, int ed, int[] temp) {
        if(ed > st) {
            int mid = st + (ed - st) / 2;
            mergeSortCore(data, st, mid, temp);
            mergeSortCore(data,mid + 1, ed, temp);
            merge(data, st, mid, ed, temp);
        }
    }

    private void merge(int[] data, int st, int mid, int ed, int[] temp) {
        int i = st, j = mid + 1;

        for(int k = st; k <= ed; k ++) {
            temp[k] = data[k];
        }

        for(int k = st; k <= ed; k ++) {
            if(i > mid) {
                data[k] = temp[j ++];
            }else if(j > ed) {
                data[k] = temp[i ++];

            }else if(temp[i] <= temp[j]) {
                data[k] = temp[i ++];
            }else {
                data[k] = temp[j ++];
            }
        }
    }


    //堆排序
    private void heapSort(int[] data) {
        int len = data.length;
        if(len <= 1) return;

        //建堆
        buildHeap(data);

        //取出来最大元素并调整堆
        for(int i = len - 1; i >= 0; i --) {
            swap(data, 0, i);
            adjustHeap(data, 0, i - 1);
        }
    }

    private void buildHeap(int[] data) {
        int len = data.length;
        //从后一个非叶节点调整堆
        for(int i = len / 2 - 1; i >= 0; i --) {
            adjustHeap(data, i, len - 1);
        }
    }

    private void adjustHeap(int[] data, int i, int lastPos) {
        int l = i * 2 + 1;
        int r = i * 2 + 2;
        int max = i;

        if(l <= lastPos && data[l] > data[max]) max = l;
        if(r <= lastPos && data[r] > data[max]) max = r;

        if(max != i) {
            swap(data, max, i);
            adjustHeap(data, max, lastPos);
        }
    }
}