java中幾種常見的排序演算法實現
阿新 • • 發佈：2018-12-18
在Java中得資料結構比較
| 資料機構 | 優點| 缺點 | |陣列 | 插入快，在直到下標得情況下可快速地存取| 查詢慢，刪除慢，大小固定 | |有序陣列 | 比無序得陣列查詢快|刪除和插入慢，大小固定 | |棧 | 提供後進先出方式的存取| 存取其他項很慢 | |佇列 |提供先進先出方式的存取|存取其他項很慢 | |連結串列 | 插入快、刪除快| 查詢慢 | | 二叉樹 |查詢、插入、刪除都快（樹保持平衡）| 刪除演算法複雜 | |紅-黑樹 | 查詢、插入、刪除都快。樹總是平衡的| 演算法複雜 | | 2-3-4樹 | 查詢、插入、刪除都快，樹總是平衡的|演算法複雜 | |雜湊表| 如果關鍵字一隻則存取極快，插入快| 刪除慢，如果不知道關鍵字則存取慢 | |堆 | 插入、刪除快、對最大資料項的存取很快|對其他資料項存取慢 | | 圖 | 對現實世界建模|演算法慢且複雜 |
資料結構是每一門語言中都很重要。在這裡有幾種自己理解的。 簡單排序： package easysort;
public class EasySort {
public static void main(String[] args) { /* // 隨機生成一個數組 Random ran=new Random(); int[] a=new int[5]; for(int i=0;i<5;i++) { a[i]=ran.nextInt(20); } easySort(a); System.out.println(); System.out.println("排序後的陣列為"); for(int i:a) { System.out.println(i+" "); }*/ //這個是輸出一個固定的陣列，對其進行排序 int[] a= {2,4,8,1,3}; easySort(a); for(int i:a) { System.out.println(i+" "); } } // 簡單排序 /* * 思路：按照約定的排序順序，兩兩比較所有的資料 * 演算法複雜度：O(n^2) * 比較次數，無論好壞都是n*(n-1)/2次 * 交換次數：每比較一次就交換一次。n*(n-1)/2次 * */ private static void easySort(int[] a) { for(int i=0;i<a.length;i++) { for(int j=i+1;j<a.length;j++) {//逐個遍歷i後面的數 if(a[j]<a[i]) {//從小到大的排序，如果有比i還笑的數，則交換i和j的位置 int temp=a[j]; a[j]=a[i]; a[i]=temp; } } } }
} 氣泡排序： package bubblesort;
//import java.util.Random;
public class BubbleSort {
public static void main(String[] args) { /* // 隨機生成一個數組 Random ran=new Random(); int[] a=new int[5]; for(int i=0;i<5;i++) { a[i]=ran.nextInt(20); } System.out.println("排序前的陣列為"); for(int i : a) { System.out.println(i+" "); } bubbleSort(a); System.out.println(); System.out.println("排序後的陣列為"); for(int i:a) { System.out.println(i+" "); }*/ //這個是輸入一個固定的陣列，對其進行排序 int[] a= {2,4,8,1,3}; bubbleSort(a); for(int i:a) { System.out.println(i+" "); } } /** * author:zl */ // 氣泡排序的核心 /* * 思路：按照約定的排序順序，兩兩比較相鄰的資料，如果反序則交換，直到沒有反序記錄為止 * 演算法複雜度：O(n^2) * 比較次數，無論好壞都是n*(n-1)/2次 * 交換次數：最好時，無需交換，最壞時，每比較一次就交換一次：n*(n-1)/2次 * */ private static void bubbleSort(int[] a) { for(int i=0;i<a.length;i++) { for(int j=0;j<a.length-i-1;j++) { if(a[j]>a[j+1])//兩兩比較相鄰的數 { int temp=a[j]; a[j]=a[j+1]; a[j+1]=temp; } } } }
} 選擇排序： package selectsort;
//import java.util.Random;
public class SelectSort {
public static void main(String[] args) {
// 隨機生成陣列
/*Random ran=new Random();
int[] a=new int[5];
for(int i=0;i<5;i++) {
a[i]=ran.nextInt(20);
}*/
int[] a= {2,4,8,1,3};
selectSort(a);
for(int i:a) {
System.out.println(i+" ");
}
}
// 選擇排序
/*
* 思路：每次從資料中選出一個最大值或者最小值放在序列的起始位置，直到全部
* 待排序的資料元素排序完
* 演算法特點：交換移動資料的次數少，節約時間
* 演算法複雜度：o(n^2)
* 比較次數：n*(n-1)/2次
* 交換次數：最好時無需交換，最壞時，交換n-1次
* */
private static void selectSort(int[] a) {
for(int i=0;i<a.length-1;i++) {//預設i為最小的，然後和後面的數依次比較
for(int j=i+1;j<a.length;j++) {//從i+1開始
if(a[j]<a[i]) {//依次判斷a[i]與後面資料的大小並交換
int temp=a[j];
a[j]=a[i];
a[i]=temp;
}
}
}
}
} 插入排序： package insertsort;
public class InsertSort {
public static void main(String[] args) {
// 隨機生成陣列
/*Random ran=new Random();
int[] a=new int[5];
for(int i=0;i<5;i++) {
a[i]=ran.nextInt(20);
}*/
int[] a= {2,4,8,1,3};
insertSort(a);
for(int i:a) {
System.out.println(i+" ");
}
}
private static void insertSort(int[] a) {
// 插入排序
/*
* 思路：每次從資料中選出一個數據插入到已經排好序的有序表中，從而得到一個新的
* 演算法複雜讀：O(n^2)
* 比較次數：最好時，n-次，；最壞時，(n+2)(n+1)/2次
* 交換次數：最好時，無需交換；最壞時，(n+2)(n+1)/2次
* */
for(int i=1;i<a.length;i++) { //第一個資料不用插入，從第二個資料開始
for(int j=i;j>0&&a[j]<a[j-1];j--) { //插入的位置為j，判斷和前一個數的大小，並交換
swap(a,j,j-1);//呼叫自定義的函式
}
}
}
private static void swap(int[] a, int j, int i) {
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
快速排序： package quicksort;
public class QuickSort {
public static void main(String[] args) {
// 隨機生成陣列
/*Random ran=new Random();
int[] a=new int[5];
for(int i=0;i<5;i++) {
a[i]=ran.nextInt(20);
}*/
int[] a= {2,4,8,1,3};
quickSort(a,0,4);
for(int i:a) {
System.out.println(i+" ");
}
}
private static void quickSort(int[] a, int start, int end) {
// 快速排序
/*
* 思路：通過一趟排序將要排序的資料分割成獨立的兩部分，其中一部分的所有
* 資料都比另外一部分的所有資料都要小，然後再按此方法對這兩部分數
* 據分別進行快速排序，整個排序過程可以遞迴進行，以此達到整個資料
* 變成有序序列。
* */
// 設定一箇中間值key
int modkey=a[start];
// 設定陣列左邊的索引，往右移動判斷比modkey大的數
int i=start;
// 設定陣列右邊的索引，往左移動判斷比modkey小的數
int j=end;
// 左邊小於右邊則陣列時無序的
while(i<j) {
while(a[j]>modkey&&j>start) {
j--;
}
while(a[i]<modkey&&i<end) {
i++;
}
if(i<j) {
int temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
// 左邊大於右邊，第一次排序完，將a[j]與modkey對換
// 實現了modkey左邊小，右邊大
if(i>j) {
int temp=a[j];
a[j]=a[start];
a[start]=temp;
}
//遞迴呼叫
if(j>start&&j<end) {
quickSort(a,start,j-1);
quickSort(a,j+1,end);
}
}
} 以上的幾種排序演算法只是個人心得。