java中幾種簡單的排序算法,java中的排序算法有哪些

本文目錄一覽：

• 1、請給出java幾種排序方法
• 2、JAVA中有哪幾種常用的排序方法
• 3、JAVA中有哪幾種常用的排序方法？每個排序方法的實現思路是如何的？每個方法的思想是什麼？？
• 4、Java數組排序 幾種排序方法詳細一點
• 5、Java排序一共有幾種？

請給出java幾種排序方法

java常見的排序分為：

1 插入類排序

主要就是對於一個已經有序的序列中，插入一個新的記錄。它包括：直接插入排序，折半插入排序和希爾排序

2 交換類排序

這類排序的核心就是每次比較都要“交換”，在每一趟排序都會兩兩發生一系列的“交換”排序，但是每一趟排序都會讓一個記錄排序到它的最終位置上。它包括：起泡排序，快速排序

3 選擇類排序

每一趟排序都從一系列數據中選擇一個最大或最小的記錄，將它放置到第一個或最後一個為位置交換，只有在選擇後才交換，比起交換類排序，減少了交換記錄的時間。屬於它的排序：簡單選擇排序，堆排序

4 歸併類排序

將兩個或兩個以上的有序序列合併成一個新的序列

5 基數排序

主要基於多個關鍵字排序的。

下面針對上面所述的算法，講解一些常用的java代碼寫的算法

二 插入類排序之直接插入排序

直接插入排序,一般對於已經有序的隊列排序效果好。

基本思想：每趟將一個待排序的關鍵字按照大小插入到已經排序好的位置上。

算法思路，從後往前先找到要插入的位置，如果小於則就交換，將元素向後移動，將要插入數據插入該位置即可。時間複雜度為O(n2),空間複雜度為O(1)

package sort.algorithm;

public class DirectInsertSort {

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

int temp, j;

for (int i = 1; i data.length; i++) {

temp = data[i];

j = i – 1;

// 每次比較都是對於已經有序的

while (j = 0 data[j] temp) {

data[j + 1] = data[j];

j–;

}

data[j + 1] = temp;

}

// 輸出排序好的數據

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + ” “);

}

}

}

三 插入類排序之折半插入排序(二分法排序)

條件：在一個已經有序的隊列中，插入一個新的元素

折半插入排序記錄的比較次數與初始序列無關

思想：折半插入就是首先將隊列中取最小位置low和最大位置high，然後算出中間位置mid

將中間位置mid與待插入的數據data進行比較，

如果mid大於data，則就表示插入的數據在mid的左邊，high=mid-1;

如果mid小於data，則就表示插入的數據在mid的右邊,low=mid+1

最後整體進行右移操作。

時間複雜度O(n2),空間複雜度O(1)

package sort.algorithm;

//折半插入排序

public class HalfInsertSort {

public static void main(String[] args) {

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20 };

// 存放臨時要插入的元素數據

int temp;

int low, mid, high;

for (int i = 1; i data.length; i++) {

temp = data[i];

// 在待插入排序的序號之前進行折半插入

low = 0;

high = i – 1;

while (low = high) {

mid = (low + high) / 2;

if (temp data[mid])

high = mid – 1;

else

// low=high的時候也就是找到了要插入的位置，

// 此時進入循環中，將low加1，則就是要插入的位置了

low = mid + 1;

}

// 找到了要插入的位置，從該位置一直到插入數據的位置之間數據向後移動

for (int j = i; j = low + 1; j–)

data[j] = data[j – 1];

// low已經代表了要插入的位置了

data[low] = temp;

}

for (int k = 0; k data.length; k++) {

System.out.print(data[k] + ” “);

}

}

}

四 插入類排序之希爾排序

希爾排序，也叫縮小增量排序，目的就是儘可能的減少交換次數，每一個組內最後都是有序的。

將待續按照某一種規則分為幾個子序列，不斷縮小規則，最後用一個直接插入排序合成

空間複雜度為O(1)，時間複雜度為O(nlog2n)

算法先將要排序的一組數按某個增量d（n/2,n為要排序數的個數）分成若干組，每組中記錄的下標相差d.對每組中全部元素進行直接插入排序，然後再用一個較小的增量（d/2）對它進行分組，在每組中再進行直接插入排序。當增量減到1時，進行直接插入排序後，排序完成。

package sort.algorithm;

public class ShellSort {

public static void main(String[] args) {

int a[] = { 1, 54, 6, 3, 78, 34, 12, 45, 56, 100 };

double d1 = a.length;

int temp = 0;

while (true)

{

//利用這個在將組內倍數減小

//這裡依次為5,3,2,1

d1 = Math.ceil(d1 / 2);

//d為增量每個分組之間索引的增量

int d = (int) d1;

//每個分組內部排序

for (int x = 0; x d; x++)

{

//組內利用直接插入排序

for (int i = x + d; i a.length; i += d) {

int j = i – d;

temp = a[i];

for (; j = 0 temp a[j]; j -= d) {

a[j + d] = a[j];

}

a[j + d] = temp;

}

}

if (d == 1)

break;

}

for (int i = 0; i a.length; i++)

System.out.print(a[i]+” “);

}

}

五 交換類排序之冒泡排序

交換類排序核心就是每次比較都要進行交換

冒泡排序：是一種交換排序

每一趟比較相鄰的元素，較若大小不同則就會發生交換，每一趟排序都能將一個元素放到它最終的位置！每一趟就進行比較。

時間複雜度O(n2)，空間複雜度O(1)

package sort.algorithm;

//冒泡排序：是一種交換排序

public class BubbleSort {

// 按照遞增順序排序

public static void main(String[] args) {

// TODO Auto-generated method stub

int data[] = { 2, 6, 10, 3, 9, 80, 1, 16, 27, 20, 13, 100, 37, 16 };

int temp = 0;

// 排序的比較趟數,每一趟都會將剩餘最大數放在最後面

for (int i = 0; i data.length – 1; i++) {

// 每一趟從開始進行比較，將該元素與其餘的元素進行比較

for (int j = 0; j data.length – 1; j++) {

if (data[j] data[j + 1]) {

temp = data[j];

data[j] = data[j + 1];

data[j + 1] = temp;

}

}

}

for (int i = 0; i data.length; i++)

System.out.print(data[i] + ” “);

}

}

JAVA中有哪幾種常用的排序方法

1、冒泡排序

冒泡排序是一個比較簡單的排序方法。在待排序的數列基本有序的情況下排序速度較快。若要排序的數有n個，則需要n-1輪排序，第j輪排序中，從第一個數開始，相鄰兩數比較，若不符合所要求的順序，則交換兩者的位置；直到第n+1-j個數為止，第一個數與第二個數比較，第二個數與第三個數比較，……，第n-j個與第n+1-j個比較，共比較n-1次。此時第n+1-j個位置上的數已經按要求排好，所以不參加以後的比較和交換操作。例如：第一輪排序：第一個數與第二個數進行比較，若不符合要求的順序，則交換兩者的位置，否則繼續進行二個數與第三個數比較……。直到完成第n-1個數與第n個數的比較。此時第n個位置上的數已經按要求排好，它不參與以後的比較和交換操作；第二輪排序：第一個數與第二個數進行比較，……直到完成第n-2個數與第n-1個數的比較；……第n-1輪排序：第一個數與第二個數進行比較，若符合所要求的順序，則結束冒泡法排序；若不符合要求的順序，則交換兩者的位置，然後結束冒泡法排序。

共n-1輪排序處理，第j輪進行n-j次比較和至多n-j次交換。

從以上排序過程可以看出，較大的數像氣泡一樣向上冒，而較小的數往下沉，故稱冒泡法。

2、選擇排序

選擇法的原理是先將第一個數與後面的每一個數依次比較,不斷將將小的賦給第一個數,從而找出最小的,然後第二個數與後面的每一個數依次比較,從而找出第二小的,然後第三個數與後面的

3、插入排序

插入排序的原理是對數組中的第i個元素，認為它前面的i-1個已經排序好，然後將它插入到前面的i-1個元素中。插入排序對少量元素的排序較為有效.

4、快速排序

快速排序是對冒泡排序的一種改進。它的基本思想是：通過一次排序將要排序的數據分割成獨立的兩部分，其中一部分的所有數據都比另外一部分的所有數據都要小，然後再按次方法對這兩部分數據分別進行快速排序，整個排序過程可以遞歸進行，以此大道整個數據變成有序序列。

JAVA中有哪幾種常用的排序方法？每個排序方法的實現思路是如何的？每個方法的思想是什麼？？

一、冒泡排序

已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先比較 a[1]與a[2]的值，若a[1]大於a[2]則交換兩者的值，否則不變。再比較a[2]與a[3]的值，若a[2]大於a[3]則交換兩者的值，否則不變。再比較a[3]與a[4]，以此類推，最後比較a[n-1]與a[n]的值。這樣處理一輪後，a[n]的值一定是這組數據中最大的。再對 a[1]~a[n-1]以相同方法處理一輪，則a[n-1]的值一定是a[1]~a[n-1]中最大的。再對a[1]~a[n-2]以相同方法處理一輪，以此類推。共處理n-1輪後a[1]、a[2]、……a[n]就以升序排列了。

優點：穩定；

缺點：慢，每次只能移動相鄰兩個數據。

二、選擇排序

冒泡排序的改進版。

每一趟從待排序的數據元素中選出最小（或最大）的一個元素，順序放在已排好序的數列的最後，直到全部待排序的數據元素排完。

選擇排序是不穩定的排序方法。

n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果：

①初始狀態：無序區為R[1..n]，有序區為空。

②第1趟排序

在無序區R[1..n]中選出關鍵字最小的記錄R[k]，將它與無序區的第1個記錄R[1]交換，使R[1..1]和R[2..n]分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

……

③第i趟排序

第i趟排序開始時，當前有序區和無序區分別為R[1..i-1]和R(1≤i≤n- 1)。該趟排序從當前無序區中選出關鍵字最小的記錄 R[k]，將它與無序區的第1個記錄R交換，使R[1..i]和R分別變為記錄個數增加1個的新有序區和記錄個數減少1個的新無序區。

這樣，n個記錄的文件的直接選擇排序可經過n-1趟直接選擇排序得到有序結果。

優點：移動數據的次數已知（n-1次）；

缺點：比較次數多。

三、插入排序

已知一組升序排列數據a[1]、a[2]、……a[n]，一組無序數據b[1]、 b[2]、……b[m]，需將二者合併成一個升序數列。首先比較b[1]與a[1]的值，若b[1]大於a[1]，則跳過，比較b[1]與a[2]的值，若b[1]仍然大於a[2]，則繼續跳過，直到b[1]小於a數組中某一數據a[x]，則將a[x]~a[n]分別向後移動一位，將b[1]插入到原來 a[x]的位置這就完成了b[1]的插入。b[2]~b[m]用相同方法插入。（若無數組a，可將b[1]當作n=1的數組a）

優點：穩定，快；

缺點：比較次數不一定，比較次數越少，插入點後的數據移動越多，特別是當數據總量龐大的時候，但用鏈表可以解決這個問題。

三、縮小增量排序

由希爾在1959年提出，又稱希爾排序(shell排序)。

已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。發現當n不大時，插入排序的效果很好。首先取一增量d(dn)，將a[1]、a[1+d]、a[1+2d]……列為第一組，a[2]、a[2+d]、 a[2+2d]……列為第二組……，a[d]、a[2d]、a[3d]……列為最後一組以次類推，在各組內用插入排序，然後取d’d，重複上述操作，直到d=1。

優點：快，數據移動少；

缺點：不穩定，d的取值是多少，應取多少個不同的值，都無法確切知道，只能憑經驗來取。

四、快速排序

快速排序是目前已知的最快的排序方法。

已知一組無序數據a[1]、a[2]、……a[n]，需將其按升序排列。首先任取數據 a[x]作為基準。比較a[x]與其它數據並排序，使a[x]排在數據的第k位，並且使a[1]~a[k-1]中的每一個數據a[x]，a[k+1]~a[n]中的每一個數據a[x]，然後採用分治的策略分別對a[1]~a[k-1]和a[k+1]~a[n] 兩組數據進行快速排序。

優點：極快，數據移動少；

缺點：不穩定。

五、箱排序

已知一組無序正整數數據a[1]、a[2]、……a[n]，需將其按升序排列。首先定義一個數組x[m],且m=a[1]、a[2]、……a[n]，接着循環n次，每次x[a]++.

優點：快，效率達到O(1)

缺點：數據範圍必須為正整數並且比較小

六、歸併排序

歸併排序是多次將兩個或兩個以上的有序表合併成一個新的有序表。最簡單的歸併是直接將兩個有序的子表合併成一個有序的表。

歸併排序是穩定的排序.即相等的元素的順序不會改變.如輸入記錄 1(1) 3(2) 2(3) 2(4) 5(5) (括號中是記錄的關鍵字)時輸出的 1(1) 2(3) 2(4) 3(2) 5(5) 中的2 和 2 是按輸入的順序.這對要排序數據包含多個信息而要按其中的某一個信息排序,要求其它信息盡量按輸入的順序排列時很重要.這也是它比快速排序優勢的地方.

Java數組排序 幾種排序方法詳細一點

JAVA中在運用數組進行排序功能時，一般有四種方法：快速排序法、冒泡法、選擇排序法、插入排序法。

快速排序法主要是運用了Arrays中的一個方法Arrays.sort（）實現。

冒泡法是運用遍曆數組進行比較，通過不斷的比較將最小值或者最大值一個一個的遍歷出來。

選擇排序法是將數組的第一個數據作為最大或者最小的值，然後通過比較循環，輸出有序的數組。

插入排序是選擇一個數組中的數據，通過不斷的插入比較最後進行排序。下面我就將他們的實現方法一一詳解供大家參考。

1利用Arrays帶有的排序方法快速排序

public class Test2{   

        public static void main(String[] args){   

                int[] a={5,4,2,4,9,1};   

                Arrays.sort(a);  //進行排序   

                for(int i: a){   

                        System.out.print(i);   

               }  

        }  

}

2冒泡排序算法

public static int[] bubbleSort(int[] args){//冒泡排序算法   

        for(int i=0;iargs.length-1;i++){   

               for(int j=i+1;jargs.length;j++){   

                   if (args[i]args[j]){   

                       int temp=args[i];   

                       args[i]=args[j];   

                       args[j]=temp;   

                       }   

            }  

       }  

       return args;  

}

3選擇排序算法

public static int[] selectSort(int[] args){//選擇排序算法   

         for (int i=0;iargs.length-1 ;i++ ){   

                int min=i;   

                for (int j=i+1;jargs.length ;j++ ){   

                      if (args[min]args[j]){   

                           min=j;   

                           }   

                  }   

                      if (min!=i){  

                      int temp=args[i];  

                      args[i]=args[min];  

                      args[min]=temp;          

                  }  

            }  

             return args;  

    }

4插入排序算法

public static int[] insertSort(int[] args){//插入排序算法   

                 for(int i=1;iargs.length;i++){   

                         for(int j=i;j0;j–){   

                                 if (args[j]args[j-1]){   

                                         int temp=args[j-1];  

                                         args[j-1]=args[j];  

                                        args[j]=temp;          

                                }else break;   

                        }  

                 }  

                 return args;  

         }

Java排序一共有幾種？

日常操作中，常見的排序方法有：冒泡排序、快速排序、選擇排序、插入排序、希爾排序，甚至還有基數排序、雞尾酒排序、桶排序、鴿巢排序、歸併排序等。

各類排序方法代碼如圖：