一、冒泡排序：

package com;import java.util.Arrays;public class BubbleSort {public static Integer[] bubbleSort(Integer[] data) {// 數組長度int len = data.length;// 臨時變量int temp = 0;// 冒泡次數for (int i = 0; i < len-1; i++) {// 交換次數for (int j = 0; j < len-i-1; j++) {if (data[j]>data[j+1]) {temp = data[j];data[j] = data[j+1];data[j+1] = temp;}}}return data;}public static Integer[] bubbleSort2(Integer[] data) {int temp = 0;// 第一層循環是跑的趟數for (int i = 0; i < data.length; i++) {// 第二層循環是比較次數for (int j = i; j < data.length; j++) {if (data[i]>data[j]) {temp = data[i];data[i] = data[j];data[j] = temp;}}}return data;}public static void main(String[] args) {Integer[] data = {9,5,6,2,7,8,1,3}; // int[] result = bubbleSort(data);Integer[] result = bubbleSort(data);System.out.println(Arrays.toString(result));}} View Code

說明：

1.時間復雜度：O(n^2)、空間復雜度：O(1)

2.算法穩定性：穩定

3.算法描述：每一次外層循環結束之后都可以把最大的數放在頂端，所以外層循環就是每趟都把最大的數往頂層放。內層循環就是把兩兩數據進行比較，如果前一個比后一個大，就交換，依次比較完整個數組。

?

二、選擇排序：

package com; import java.util.Arrays;public class SelectSort {public static Integer[] selectSort(Integer[] data) {int len = data.length;for (int i = 0; i < len; i++) {int temp = data[i];int position = i;for (int j = i+1; j < len; j++) {if (data[j]<temp) {temp = data[j];position = j;}}data[position] = data[i];data[i] = temp;}return data;}public static void main(String[] args) {/**5 9 6 2 7 8 1 3**/Integer[] data = {9,5,6,2,7,8,1,3};Integer[] result = selectSort(data);System.out.println(Arrays.toString(result));} } View Code

說明：

1.時間復雜度：O(n^2)、空間復雜度：O(1)

2.算法穩定性：不穩定

3.算法描述：第一次循環先拿第一個數作為基準，依次和后面的數進行比較，每一次外層循環都可以確定出最大或者最小的數，后面依此類推。

?

三、插入排序：

package com;import java.util.Arrays;public class InsertSort{public static Integer[] insertSort(Integer[] data){int len = data.length;int insertNum;for(int i=1;i<len;i++){insertNum = data[i];int j=i-1;while(j>=0&&data[j]>insertNum){data[j+1] = data[j];j--;}data[j+1] = insertNum;}return data;}public static void main(String[] args) {/**5 9 6 2 7 8 1 3**/Integer[] data = {9,5,6,2,7,8,1,3};Integer[] result = insertSort(data);System.out.println(Arrays.toString(result));} } View Code

說明：

1.時間復雜度：O(n^2)、空間復雜度：O(1)

2.算法穩定性：穩定

3.算法描述：第一次循環先拿第二個數和第一個做比較，如果第二個數大于第一個數，就相互交換。第二次循環又把第三個數拿來和前面兩個排好序作比較，看是否交換，依此類推。

三、快速排序：

package com;import java.util.Arrays;public class QuickSort{public static Integer partition(Integer[] data, int start, int end){int temp = data[start];while(start<end){if(start<end&&data[end]>temp){end -= 1;}data[start] = data[end];if(start<end&&data[start]<temp){start += 1;}data[end] = data[start];}data[start] = temp;return start;}public static Integer[] quickSort(Integer[] data, int start, int end){int middle;if(start<end){middle = partition(data,start, end);quickSort(data,start, middle-1);quickSort(data,middle+1,end);}return data;}public static void main(String[] args){Integer[] data = {9,5,6,2,7,8,1,3};Integer[] result = quickSort(data, 0 ,data.length-1);System.out.println(Arrays.toString(result));} } View Code

說明：

1.時間復雜度：O(nlog2n)、空間復雜度：O(nlog2n)

2.算法穩定性：不穩定

3.算法描述：思想是“分而治之”，第一次循環是先拿第一個數作為基準，把比第一個數大的數放在它的右邊，把比第一個數小的數放在它的左邊。

?

轉載于:https://www.cnblogs.com/crazy-xf/p/10024562.html

總結

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

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