Java 8大排序演算法

標籤：插入排序   排序演算法   希爾排序   快速排序   歸併排序   

直接插入排序

//直接插入排序    public int[] insertSort(int[] a) {        for (int i = 1; i < a.length; i++) {            int j = i - 1;            for (; j >= 0 && a[j] > a[i]; j--) {                a[j + 1] = a[j];//往後移            }            a[j + 1] = a[i];        }        return a;    }

希爾排序

 //希爾排序    public int[] shellSort(int[] a) {        int n = a.length;        int gap = n;//數組數        while (gap > 0) {            gap = gap / 2;//將數組縮小一半            for (int x = 0; x < gap; x++) {//將每組數進行直接插入排序                //直接插入排序                for (int i = x + gap; i < n; i += gap) {                    int j = i - gap;                    for (; j >= 0 && a[j] > a[i]; j -= gap) {                        a[j + gap] = a[j];                    }                    a[j + gap] = a[i];                }            }        }        return a;    }

簡單選擇排序

//簡單選擇排序    public int[] simpleSort(int[] a) {        int n = a.length;        for (int i = 0; i < n; i++) {            for (int j = i + 1; j <= n; j++) {                if (a[j] < a[i]) {                    int temp = a[i];                    a[i] = a[j];                    a[j] = temp;                }            }        }        return a;    }

堆排序

 //堆排序    public void heapSort(int[] a) {        System.out.println("開始排序");        int arrayLength = a.length;        //迴圈建堆，每次把最大值放在最後，不參與下一次的建堆        for (int i = 0; i < arrayLength - 1; i++) {            //建堆            buildMaxHeap(a, arrayLength - 1 - i);            //交換堆頂和最後一個元素            swap(a, 0, arrayLength - 1 - i);            System.out.println(Arrays.toString(a));        }    }    private void swap(int[] data, int i, int j) {        int tmp = data[i];        data[i] = data[j];        data[j] = tmp;    }    //對data數組從0到lastIndex建大頂堆    private void buildMaxHeap(int[] data, int lastIndex) {        //從lastIndex處節點（最後一個節點）的父節點開始，(lastIndex - 1) / 2為節點數        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {            //k儲存正在判斷的節點            int k = i;            //如果當前k節點的子節點存在，把堆中最大的數放在對頂            while (k * 2 + 1 <= lastIndex) {                //k節點的左子節點的索引                int biggerIndex = 2 * k + 1;                //如果biggerIndex小於lastIndex，即biggerIndex+1代表的k節點的右子節點存在                if (biggerIndex < lastIndex) {                    //若果右子節點的值較大                    if (data[biggerIndex] < data[biggerIndex + 1]) {                        //biggerIndex總是記錄較大子節點的索引                        biggerIndex++;                    }                }                //如果k節點的值小於其較大的子節點的值                if (data[k] < data[biggerIndex]) {                    //交換他們                    swap(data, k, biggerIndex);                    //將biggerIndex賦予k，開始while迴圈的下一次迴圈，重新保證k節點的值大於其左右子節點的值                    k = biggerIndex;                } else {                    break;                }            }        }    }

冒泡排序

 //冒泡排序    public int[] bubbleSort(int[] a) {        int temp = 0;        for (int i = 0; i < a.length - 1; i++) {            for (int j = 0; j < a.length - 1 - i; j++) {                if (a[j] > a[j + 1]) {                    temp = a[j];                    a[j] = a[j + 1];                    a[j + 1] = temp;                }            }        }        return a;    }

快速排序

 //快速排序    public void quickSort() {        quick(a);        for (int i = 0; i < a.length; i++) {            System.out.println(a[i]);        }    }    public int getMiddle(int[] list, int low, int high) {        int tmp = list[low];    //數組的第一個作為中軸        while (low < high) {            while (low < high && list[high] >= tmp) {                high--;            }            list[low] = list[high];   //比中軸小的記錄移到低端            while (low < high && list[low] <= tmp) {                low++;            }            list[high] = list[low];   //比中軸大的記錄移到高端        }        list[low] = tmp;              //中軸記錄到尾        return low;                   //返回中軸的位置    }    public void _quickSort(int[] list, int low, int high) {        if (low < high) {            int middle = getMiddle(list, low, high);  //將list數組進行一分為二            _quickSort(list, low, middle - 1);       //對低字表進行遞迴排序            _quickSort(list, middle + 1, high);       //對高字表進行遞迴排序        }    }    public void quick(int[] a2) {        if (a2.length > 0) {    //查看數組是否為空白            _quickSort(a2, 0, a2.length - 1);        }    }

歸併排序

//歸併排序    public void mergeSort(int[] arr) {        int[] temp = new int[arr.length];        internalMergeSort(arr, temp, 0, arr.length - 1);    }    private void internalMergeSort(int[] a, int[] b, int left, int right) {        //當left==right的時，已經不需要再劃分了        if (left < right) {            int middle = (left + right) / 2;            internalMergeSort(a, b, left, middle);//左子數組            internalMergeSort(a, b, middle + 1, right);//右子數組            mergeSortedArray(a, b, left, middle, right);//合并兩個子數組        }    }    // 合并兩個有序子序列 arr[left, ..., middle] 和 arr[middle+1, ..., right]，temp是輔助數組。    private void mergeSortedArray(int arr[], int temp[], int left, int middle, int right) {        int i = left;        int j = middle + 1;        int k = 0;        //從兩個數組中取出最小的放入臨時數組        while (i <= middle && j <= right) {            if (arr[i] <= arr[j]) {                temp[k++] = arr[i++];            } else {                temp[k++] = arr[j++];            }        }        //將左數組剩下的資料複製到臨時數組        while (i <= middle) {            temp[k++] = arr[i++];        }        //將右數組剩下的資料複製到臨時數組        while (j <= right) {            temp[k++] = arr[j++];        }        //把資料複製回原數組        for (i = 0; i < k; ++i) {            arr[left + i] = temp[i];        }    }

基數排序

//基數排序    public void  radixSort() {        sort(a);        for (int i = 0; i < a.length; i++) {            System.out.println(a[i]);        }    }    public void sort(int[] array) {        //首先確定排序的趟數;        int max = array[0];        for (int i = 1; i < array.length; i++) {            if (array[i] > max) {                max = array[i];            }        }        int time = 0;        //判斷位元;        while (max > 0) {            max /= 10;            time++;        }        //建立10個隊列;        List<ArrayList> queue = new ArrayList<ArrayList>();        for (int i = 0; i < 10; i++) {            ArrayList<Integer> queue1 = new ArrayList<Integer>();            queue.add(queue1);        }        //進行time次分配和收集;        for (int i = 0; i < time; i++) {            //分配數組元素;            for (int j = 0; j < array.length; j++) {                //得到數位第time+1位元;                int x = array[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);                ArrayList<Integer> queue2 = queue.get(x);                queue2.add(array[j]);                queue.set(x, queue2);            }            int count = 0;//元素計數器;            //收集隊列元素;            for (int k = 0; k < 10; k++) {                while (queue.get(k).size() > 0) {                    ArrayList<Integer> queue3 = queue.get(k);                    array[count] = queue3.get(0);                    queue3.remove(0);                    count++;                }            }        }    }

原文連結： Java常用排序演算法/程式員必須掌握的8大排序演算法

Java 8大排序演算法