一些常見的排序算法的事項以及java實現
由于時間上的原因沒有計算時間復雜度，以后有時間補上，或者大家有興趣的可以自己算算

package com.sgcc.cn;import java.util.Arrays;/***　插入排序：直接插入排序、二分法插入排序、希爾排序。* *　選擇排序：簡單選擇排序、堆排序。* *　交換排序：冒泡排序、快速排序。* *　歸并排序* *　基數排序* * */// 此處排序都是從小到大 public class SortAlgorithm {/*** 插入排序算法：直接插入排序(從前向后找合適位置插入)* @param array 一個int型的數組* @return int類型的排序后的數組* */public static int[] straightInsertionSort(int[] array) {int temp;//帶插入的元素int i,j;//循環變量for (i = 1; i < array.length; i++) {temp = array[i];// 待插入的元素for (j = i-1; j >= 0 && temp < array[j]; j--) {//從后面到前面比較，第一個元素為當前元素前一個，如果比temp大就向后移動一位array[j+1] = array[j];}array[j+1] = temp;//由于j--因此j+1才是要插入的第j個元素// for(j = i-1; j >= 0; j--){ // if(temp <= array[j]){ // array[j+1] = array[j]; // }else{ // break; // } // } // array[j+1] = temp;}return array;}/*** 插入排序算法：二分排序算法(按二分法找到合適位置插入)* @param array 一個int型的數組* @return int類型的排序后的數組* */public static int[] binaryInsertionSort(int[] array){int i,j;//循環變量int low,mid,heigh;//插入位置變量int temp;//將要插入的元素for(i = 1; i < array.length; i++){temp = array[i];//將要插入的數字low = 0;heigh = i-1;while(low <= heigh){mid = (low+heigh)/2;if(temp<array[mid]){heigh = mid-1; }else {low = mid+1;}}for(j = i-1; j >=low; j--){array[j+1] = array[j];}if(low != i){//如果是自己就不用替換array[low] = temp; }}return array;}/*** 插入排序算法：希爾排序(基本思想：先取一個小于n的整數d1作為第一個增量，把文件的全部記錄分成d1個組。所有距離為d1的倍數的記錄放在同一個組中。先在各組內進行直接插入排序；然后，取第二個增量d2<d1重復上述的分組和排序，直至所取的增量dt=1(dt<dt-l<…<d2<d1)，即所有記錄放在同一組中進行直接插入排序為止。該方法實質上是一種分組插入方法。)* @param array 一個int型的數組* @return int類型的排序后的數組* */public static int[] shellSort(int[] array){int i,j,k;//循環變量int temp;//待插入元素int dt = array.length/2;//初始化變量while(dt != 1){System.out.println("現在dt="+dt);dt = dt/2;for(i = 0; i < dt; i++){//對進行的分組進行循環訪問for(j = i+dt; j < array.length; j = j+dt){//對組內數據進行插入排序temp = array[j];for(k = j-dt; k >= 0; k = k-dt){if(temp < array[k]){array[k+dt] = array[k];}else{break;}}array[k+dt] = temp;//在對第k個位置賦值}}}return array;}/*** 選擇排序：簡單選擇排序(每趟從待排序的記錄序列中選擇關鍵字最大的記錄放置到已排序表的最前位置，直到全部排完)* @param array 一個int型的數組* @return int類型的排序后的數組* */public static int[] simpleSelectionSort(int[] array) {int i, j, k;// 循環的變量int temp;// 待替換的元素for (i = 0; i < array.length; i++) {temp = array[i];k = i;for (j = i + 1; j < array.length; j++) {if (temp > array[j]) {temp = array[j];k = j;}}array[k] = array[i];array[i] = temp;}return array;}/*** 選擇排序：堆排序(1.構建最大堆。2.選擇頂，并與第0位置元素交換。3.由于步驟2的的交換可能破環了最大堆的性質，第0不再是最大元素，需要調用maxHeap調整堆(沉降法)，如果需要重復步驟2)* @param array 一個int型數組* @return int類型的排序后的數組* */public static int[] heapSort(int[] array) {for (int i = 0; i < array.length; i++) {createMaxdHeap(array, array.length - 1 - i);swap(array, 0, array.length - 1 - i);}return array;}public static void swap(int[] array, int i, int j) { if (i == j) {return;}array[i] = array[i] + array[j];array[j] = array[i] - array[j];array[i] = array[i] - array[j];}public static void createMaxdHeap(int[] array, int lastIndex) {for (int i = (lastIndex - 1) / 2; i >= 0; i--) {// 保存當前正在判斷的節點int k = i;// 若當前節點的子節點存在 while (2 * k + 1 <= lastIndex) {// biggerIndex總是記錄較大節點的值,先賦值為當前判斷節點的左子節點int biggerIndex = 2 * k + 1;if (biggerIndex < lastIndex) {// 若右子節點存在，否則此時biggerIndex應該等于 lastIndexif (array[biggerIndex] < array[biggerIndex + 1]) {// 若右子節點值比左子節點值大，則biggerIndex記錄的是右子節點的值biggerIndex++;}}if (array[k] < array[biggerIndex]) {// 若當前節點值比子節點最大值小，則交換2者得值，交換后將biggerIndex值賦值給kswap(array, k, biggerIndex);k = biggerIndex;} else {break;}}}}/*** 交換排序：冒泡排序(在要排序的一組數中，對當前還未排好序的范圍內的全部數，自上而下對相鄰的兩個數依次進行比較和調整，讓較大的數往下沉，較小的往上冒。即：每當兩相鄰的數比較后發現它們的排序與排序要求相反時，就將它們互換。)* @param array 一個int型的數組* @return int類型的排序后的數組* */public static int[] bubbingSort(int[] array){int i,j;//循環變量int temp;//中間元素for(i = 0; i < array.length; i++){//控制數字個數for(j = 0; j < array.length-i-1; j++){//控制比較次數if(array[j] > array[j+1]){temp = array[j];array[j] = array[j+1];array[j+1] = temp;}}}return array;}/*** 交換排序：快速排序(通過一趟排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然后再按此方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此達到整個數據變成有序序列。)* @param array 一個int型的數組* @return int類型的排序后的數組* */public static int[] quicksort(int array[], int left, int right) {int mid;if (left < right) {mid = partition(array, left, right);quicksort(array, left, mid - 1);quicksort(array, mid + 1, right);}return array;}//尋找數組中間的位置public static int partition(int array[], int left, int right) {int pivot = array[left];while (left < right) {while (left < right && array[right] >= pivot)right--;if (left < right)array[left++] = array[right];while (left < right && array[left] <= pivot)left++;if (left < right)array[right--] = array[left];}array[left] = pivot;return left;}/*** 歸并排序* @param array 一個int型數組(歸并排序也是一個遞歸的實現，其關鍵在于合并兩個有序集。數組array從min到mid有序，從mid+1到max有序，合并這兩部分，使得從min到max有序，且這個有序序列仍然放在array的從min到max下標里。)* @return int類型的排序后的數組* */public static int[] mergeSort(int[] array, int left, int right) {if (left >= right)return array;int center = (left + right) / 2;// 找出中間索引mergeSort(array, left, center);// 對左邊數組進行遞歸mergeSort(array, center + 1, right);// 對右邊數組進行遞歸merge(array, left, center, right);//合并,其關鍵在于合并兩個有序集return array;} public static void merge(int[] array, int left, int center, int right) {int[] tmpArr = new int[array.length];// 臨時數組int mid = center + 1; // 右數組第一個元素索引int third = left; // third 記錄臨時數組的索引int tmp = left; // 緩存左數組第一個元素的索引while (left <= center && mid <= right) {// 從兩個數組中取出最小的放入臨時數組if (array[left] <= array[mid]) {tmpArr[third++] = array[left++];} else {tmpArr[third++] = array[mid++];}}while (mid <= right) {// 剩余部分依次放入臨時數組(實際上兩個while只會執行其中一個)tmpArr[third++] = array[mid++];}while (left <= center) {tmpArr[third++] = array[left++];}while (tmp <= right) {// 將臨時數組中的內容拷貝回原數組中(原left-right范圍的內容被復制回原數組)array[tmp] = tmpArr[tmp++];} }/*** 基數排序(基數排序法又稱"桶子法",顧名思義,它是透過鍵值的部份資訊，將要排序的元素分配至某些"桶"中，藉以達到排序的作用)* @param array 一個int型數組* @return int類型的排序后的數組* */public static int[] radixSort(int[] array, int radix, int d) {// 緩存數組int[] tmp = new int[array.length];int[] buckets = new int[radix];//buckets用于記錄待排序元素的信息, buckets數組定義了max-min個桶 for (int i = 0, rate = 1; i < d; i++) { Arrays.fill(buckets, 0);// 重置count數組，開始統計下一個關鍵字System.arraycopy(array, 0, tmp, 0, array.length);// 將array中的元素完全復制到tmp數組中for (int j = 0; j < array.length; j++) {// 計算每個待排序數據的子關鍵字int subKey = (tmp[j] / rate) % radix; buckets[subKey]++; }for (int j = 1; j < radix; j++) {buckets[j] = buckets[j] + buckets[j - 1];}for (int m = array.length - 1; m >= 0; m--) {// 按子關鍵字對指定的數據進行排序int subKey = (tmp[m] / rate) % radix;array[--buckets[subKey]] = tmp[m];}rate *= radix;}return array;}/*** 打印數組* @param array int類型數組* */public static void printArray(int[] array) { for (int i = 0; i < array.length; i++) { System.out.print(array[i] + "\t"); } System.out.println(); }//測試main方法public static void main(String[] agrs) {int[] array = { 2, 7, 8, 21, 23, 23, 1, 65, 12, 33, 112 };System.out.println("排序前的數組：");printArray(array);System.out.println();array = mergeSort(array, 0, array.length - 1);System.out.println("排序后的數組：");printArray(array);}}

只總結了一些常用算法的實現，分享一下，希望共同學習，共同進步。

關于demo的github地址如下

https://github.com/leo825/sortalgorithm.git

總結

以上是生活随笔為你收集整理的java常用的排序算法的思想以及实现的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。