排序演算法總結java

㈠ java 排序演算法（選擇、冒泡）等等

//選擇排序
publicstaticvoidselectionSort(int[] elements){
for(inti = 0; i < elements.length-1; ++i){
intk = i;
for(intj = i; j < elements.length; ++j){
if(elements[k] > elements[j]){
k = j;
}
}
if(k != i){//交換元素
inttemp = elements[i];
elements[i] = elements[k];
elements[k] = temp;
}
} }

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

樓上說的沒錯，你得自己去學會解決問題。好好加油吧...

㈡ java排序演算法有多少種

演算法和語言無關吧，語言只是把具體的演算法實現出來而已。據我了解的排序演算法11-13種。排序演算法嘛 主要就是個思想而已。不同的演算法時間復雜度不一樣，空間復雜度也不一樣，當然執行的效率也不一樣。當然採用哪種演算法還取決於你要實現什麼樣的功能。就好比說：要同時盡快的找出最大最小，或者盡快的找出最值的位置等等。冒泡排序（bubble sort） — O(n2)
雞尾酒排序 (Cocktail sort, 雙向的冒泡排序) — O(n2)
插入排序 （insertion sort）— O(n2)
桶排序 （bucket sort）— O(n); 需要 O(k) 額外 記憶體
計數排序 (counting sort) — O(n+k); 需要 O(n+k) 額外 記憶體
歸並排序 （merge sort）— O(n log n); 需要 O(n) 額外記憶體
原地歸並排序 — O(n2)
二叉樹排序 （Binary tree sort） — O(n log n); 需要 O(n) 額外記憶體
鴿巢排序 (Pigeonhole sort) — O(n+k); 需要 O(k) 額外記憶體
基數排序 （radix sort）— O(n·k); 需要 O(n) 額外記憶體
Gnome sort — O(n2)
Library sort — O(n log n) with high probability, 需要 (1+ε)n 額外記憶體不穩定
選擇排序 （selection sort）— O(n2)
希爾排序 （shell sort）— O(n log n) 如果使用最佳的現在版本
Comb sort — O(n log n)
堆排序 （heapsort）— O(n log n)
Smoothsort — O(n log n)
快速排序 （quicksort）— O(n log n) 期望時間, O(n2) 最壞情況; 對於大的、亂數串列一般相信是最快的已知排序
等。

㈢ 常見的排序演算法—選擇，冒泡，插入，快速，歸並

太久沒看代碼了，最近打算復習一下java，又突然想到了排序演算法，就把幾種常見的排序演算法用java敲了一遍，這里統一將無序的序列從小到大排列。

選擇排序是一種簡單直觀的排序演算法。它的工作原理是：第一次從待排序的數據元素中選出最小的一個元素，存放在序列的起始位置，然後再從剩餘的未排序元素中尋找到最小元素，繼續放在下一個位置，直到待排序元素個數為0。

選擇排序代碼如下：

public void Select_sort(int[] arr) {

int temp,index;

for( int i=0;i<10;i++) {

index = i;

for(int j = i + 1 ; j < 10 ; j++) {

if(arr[j] < arr[index])

index = j;

}

/*

temp = arr[i];

arr[i] = arr[index];

arr[index] = temp;

*/

swap(arr,i,index);

}

System.out.print("經過選擇排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

冒泡排序是一種比較基礎的排序演算法，其思想是相鄰的元素兩兩比較，較大的元素放後面，較小的元素放前面，這樣一次循環下來，最大元素就會歸位，若數組中元素個數為n，則經過（n-1）次後，所有元素就依次從小到大排好序了。整個過程如同氣泡冒起，因此被稱作冒泡排序。

選擇排序代碼如下：

public void Bubble_sort(int[] arr) {

int temp;

for(int i = 0 ; i < 9 ; i++) {

for(int j = 0 ; j < 10 - i - 1 ;j++) {

if(arr[j] > arr[j+1]) {

/*

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

*/

swap(arr,j,j+1);

}

}

}

System.out.print("經過冒泡排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

插入排序也是一種常見的排序演算法，插入排序的思想是：創建一個與待排序數組等大的數組，每次取出一個待排序數組中的元素，然後將其插入到新數組中合適的位置，使新數組中的元素保持從小到大的順序。

插入排序代碼如下：

public void Insert_sort(int[] arr) {

int length = arr.length;

int[] arr_sort = new int[length];

int count = 0;

for(int i = 0;i < length; i++) {

if(count == 0) {

arr_sort[0] = arr[0];

}else if(arr[i] >= arr_sort[count - 1]) {

arr_sort[count] = arr[i];

}else if(arr[i] < arr_sort[0]) {

insert(arr,arr_sort,arr[i],0,count);

}else {

for(int j = 0;j < count - 1; j++) {

if(arr[i] >= arr_sort[j] && arr[i] < arr_sort[j+1]) {

insert(arr,arr_sort,arr[i],j+1,count);

break;

}

}

}

count++;

}

System.out.print("經過插入排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr_sort[i] +" ");

System.out.println("");

}

public void insert(int[] arr,int[] arr_sort,int value,int index,int count) {

for(int i = count; i > index; i--)

arr_sort[i] = arr_sort[i-1];

arr_sort[index] = value;

}

快速排序的效率比冒泡排序演算法有大幅提升。因為使用冒泡排序時，一次外循環只能歸位一個值，有n個元素最多就要執行（n-1）次外循環。而使用快速排序時，一次可以將所有元素按大小分成兩堆，也就是平均情況下需要logn輪就可以完成排序。

快速排序的思想是：每趟排序時選出一個基準值（這里以首元素為基準值），然後將所有元素與該基準值比較，並按大小分成左右兩堆，然後遞歸執行該過程，直到所有元素都完成排序。

public void Quick_sort(int[] arr, int left, int right) {

if(left >= right)

return ;

int temp,t;

int j = right;

int i = left;

temp = arr[left];

while(i < j) {

while(arr[j] >= temp && i < j)

j--;

while(arr[i] <= temp && i < j)

i++;

if(i < j) {

t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

}

arr[left] = arr[i];

arr[i] = temp;

Quick_sort(arr,left, i - 1);

Quick_sort(arr, i + 1, right);

}

歸並排序是建立在歸並操作上的一種有效的排序演算法，歸並排序對序列的元素進行逐層折半分組，然後從最小分組開始比較排序，每兩個小分組合並成一個大的分組，逐層進行，最終所有的元素都是有序的。

public void Mergesort(int[] arr,int left,int right) {

if(right - left > 0) {

int[] arr_1 = new int[(right - left)/2 + 1];

int[] arr_2 = new int[(right - left + 1)/2];

int j = 0;

int k = 0;

for(int i = left;i <= right;i++) {

if(i <= (right + left)/2) {

arr_1[j++] = arr[i];

}else {

arr_2[k++] = arr[i];

}

}

Mergesort(arr_1,0,(right - left)/2);

Mergesort(arr_2,0,(right - left - 1)/2);

Merge(arr_1,arr_2,arr);

}

}

public void Merge(int[] arr_1,int[] arr_2,int[] arr) {

int i = 0;

int j = 0;

int k = 0;

int L1 = arr_1.length;

int L2 = arr_2.length;

while(i < L1 && j < L2) {

if(arr_1[i] <= arr_2[j]) {

arr[k] = arr_1[i];

i++;

}else {

arr[k] = arr_2[j];

j++;

}

k++;

}

if(i == L1) {

for(int t = j;j < L2;j++)

arr[k++] = arr_2[j];

}else {

for(int t = i;i < L1;i++)

arr[k++] = arr_1[i];

}

}

歸並排序這里我使用了left，right等變數，使其可以通用，並沒有直接用數字表示那麼明確，所以給出相關偽代碼，便於理解。

Mergesort(arr[0...n-1])

//輸入：一個可排序數組arr[0...n-1]

//輸出：非降序排列的數組arr[0...n-1]

if n>1

arr[0...n/2-1] to arr_1[0...(n+1)/2-1]//確保arr_1中元素個數>=arr_2中元素個數

//對於總個數為奇數時，arr_1比arr_2中元素多一個；對於總個數為偶數時，沒有影響

arr[n/2...n-1] to arr_2[0...n/2-1]

Mergesort(arr_1[0...(n+1)/2-1])

Mergesort(arr_2[0...n/2-1])

Merge(arr_1,arr_2,arr)

Merge(arr_1[0...p-1],arr_2[0...q-1],arr[0...p+q-1])

//輸入：兩個有序數組arr_1[0...p-1]和arr_2[0...q-1]

//輸出：將arr_1與arr_2兩數組合並到arr

int i<-0;j<-0;k<-0

while i

if arr_1[i] <= arr_2[j]

arr[k] <- arr_1[i]

i<-i+1

else arr[k] <- arr_2[j];j<-j+1

k<-k+1

if i=p

arr_2[j...q-1] to arr[k...p+q-1]

else arr_1[i...p-1] to arr[k...p+q-1]

package test_1;

import java.util.Scanner;

public class Test01 {

public static void main(String[] args) {

Scanner sc = new Scanner(System.in);

int[] arr_1 = new int[10];

for(int i = 0 ; i < 10 ; i++)

arr_1[i] = sc.nextInt();

Sort demo_1 = new Sort();

//1~5一次只能運行一個，若多個同時運行，則只有第一個有效，後面幾個是無效排序。因為第一個運行的已經將帶排序數組排好序。

demo_1.Select_sort(arr_1);//-----------------------1

//demo_1.Bubble_sort(arr_1);//---------------------2

/* //---------------------3

demo_1.Quick_sort(arr_1, 0 , arr_1.length - 1);

System.out.print("經過快速排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr_1[i] +" ");

System.out.println("");

*/

//demo_1.Insert_sort(arr_1);//--------------------4

/* //--------------------5

demo_1.Mergesort(arr_1,0,arr_1.length - 1);

System.out.print("經過歸並排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr_1[i] +" ");

System.out.println("");

*/

}

}

class Sort {

public void swap(int arr[],int a, int b) {

int t;

t = arr[a];

arr[a] = arr[b];

arr[b] = t;

}

public void Select_sort(int[] arr) {

int temp,index;

for( int i=0;i<10;i++) {

index = i;

for(int j = i + 1 ; j < 10 ; j++) {

if(arr[j] < arr[index])

index = j;

}

/*

temp = arr[i];

arr[i] = arr[index];

arr[index] = temp;

*/

swap(arr,i,index);

}

System.out.print("經過選擇排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

public void Bubble_sort(int[] arr) {

int temp;

for(int i = 0 ; i < 9 ; i++) {

for(int j = 0 ; j < 10 - i - 1 ;j++) {

if(arr[j] > arr[j+1]) {

/*

temp = arr[j];

arr[j] = arr[j+1];

arr[j+1] = temp;

*/

swap(arr,j,j+1);

}

}

}

System.out.print("經過冒泡排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr[i] +" ");

System.out.println("");

}

public void Quick_sort(int[] arr, int left, int right) {

if(left >= right)

return ;

int temp,t;

int j = right;

int i = left;

temp = arr[left];

while(i < j) {

while(arr[j] >= temp && i < j)

j--;

while(arr[i] <= temp && i < j)

i++;

if(i < j) {

t = arr[i];

arr[i] = arr[j];

arr[j] = t;

}

}

arr[left] = arr[i];

arr[i] = temp;

Quick_sort(arr,left, i - 1);

Quick_sort(arr, i + 1, right);

}

public void Insert_sort(int[] arr) {

int length = arr.length;

int[] arr_sort = new int[length];

int count = 0;

for(int i = 0;i < length; i++) {

if(count == 0) {

arr_sort[0] = arr[0];

}else if(arr[i] >= arr_sort[count - 1]) {

arr_sort[count] = arr[i];

}else if(arr[i] < arr_sort[0]) {

insert(arr,arr_sort,arr[i],0,count);

}else {

for(int j = 0;j < count - 1; j++) {

if(arr[i] >= arr_sort[j] && arr[i] < arr_sort[j+1]) {

insert(arr,arr_sort,arr[i],j+1,count);

break;

}

}

}

count++;

}

System.out.print("經過插入排序後：");

for(int i = 0 ; i < 10 ; i++)

System.out.print( arr_sort[i] +" ");

System.out.println("");

}

public void insert(int[] arr,int[] arr_sort,int value,int index,int count) {

for(int i = count; i > index; i--)

arr_sort[i] = arr_sort[i-1];

arr_sort[index] = value;

}

public void Mergesort(int[] arr,int left,int right) {

if(right - left > 0) {

int[] arr_1 = new int[(right - left)/2 + 1];

int[] arr_2 = new int[(right - left + 1)/2];

int j = 0;

int k = 0;

for(int i = left;i <= right;i++) {

if(i <= (right + left)/2) {

arr_1[j++] = arr[i];

}else {

arr_2[k++] = arr[i];

}

}

Mergesort(arr_1,0,(right - left)/2);

Mergesort(arr_2,0,(right - left - 1)/2);

Merge(arr_1,arr_2,arr);

}

}

public void Merge(int[] arr_1,int[] arr_2,int[] arr) {

int i = 0;

int j = 0;

int k = 0;

int L1 = arr_1.length;

int L2 = arr_2.length;

while(i < L1 && j < L2) {

if(arr_1[i] <= arr_2[j]) {

arr[k] = arr_1[i];

i++;

}else {

arr[k] = arr_2[j];

j++;

}

k++;

}

if(i == L1) {

for(int t = j;j < L2;j++)

arr[k++] = arr_2[j];

}else {

for(int t = i;i < L1;i++)

arr[k++] = arr_1[i];

}

}

}

若有錯誤，麻煩指正，不勝感激。

㈣ java中冒泡排序演算法的詳細解答以及程序

實例說明

用冒泡排序方法對數組進行排序。

實例解析

交換排序的基本思想是兩兩比較待排序記錄的關鍵字，發現兩個記錄的次序相反時即進行交換，直到沒有反序的記錄為止。

應用交換排序基本思想的主要排序方法有冒泡排序和快速排序。

冒泡排序

將被排序的記錄數組 R[1..n] 垂直排列，每個記錄 R[i] 看做是重量為 R[i].key 的氣泡。根據輕氣泡不能在重氣泡之下的原則，從下往上掃描數組 R 。凡掃描到違反本原則的輕氣泡，就使其向上「漂浮」。如此反復進行，直到最後任何兩個氣泡都是輕者在上，重者在下為止。

(1) 初始， R[1..n] 為無序區。

(2) 第一趟掃描，從無序區底部向上依次比較相鄰的兩個氣泡的重量，若發現輕者在下、重者在上，則交換二者的位置。即依次比較 (R[n],R[n-1]) 、 (R[n-1],R[n-2]) 、 … 、 (R[2],R[1]); 對於每對氣泡 (R[j+1],R[j]), 若 R[j+1].key<R[j].key, 則交換 R[j+1] 和 R[j] 的內容。

第一趟掃描完畢時，「最輕」的氣泡就飄浮到該區間的頂部，即關鍵字最小的記錄被放在最高位置 R[1] 上。

(3) 第二趟掃描，掃描 R[2..n]。掃描完畢時，「次輕」的氣泡飄浮到 R[2] 的位置上 …… 最後，經過 n-1 趟掃描可得到有序區 R[1..n]。

注意：第 i 趟掃描時， R[1..i-1] 和 R[i..n] 分別為當前的有序區和無序區。掃描仍是從無序區底部向上直至該區頂部。掃描完畢時，該區中最輕氣泡漂浮到頂部位置 R[i] 上，結果是 R[1..i] 變為新的有序區。

冒泡排序演算法

因為每一趟排序都使有序區增加了一個氣泡，在經過 n-1 趟排序之後，有序區中就有 n-1 個氣泡，而無序區中氣泡的重量總是大於等於有序區中氣泡的重量，所以整個冒泡排序過程至多需要進行 n-1 趟排序。

若在某一趟排序中未發現氣泡位置的交換，則說明待排序的無序區中所有氣泡均滿足輕者在上，重者在下的原則，因此，冒泡排序過程可在此趟排序後終止。為此，在下面給出的演算法中，引入一個布爾量 exchange, 在每趟排序開始前，先將其置為 FALSE 。若排序過程中發生了交換，則將其置為 TRUE 。各趟排序結束時檢查 exchange, 若未曾發生過交換則終止演算法，不再進行下趟排序。

具體演算法如下：

void BubbleSort(SeqList R){
//R(1..n) 是待排序的文件，採用自下向上掃描，對 R 做冒泡排序
int i,j;
Boolean exchange; // 交換標志
for(i=1;i<n;i++){ // 最多做 n-1 趟排序
exchange=FALSE; // 本趟排序開始前，交換標志應為假
for(j=n-1;j>=i;j--) // 對當前無序區 R[i..n] 自下向上掃描
if(R[j+1].key<R[j].key){ // 交換記錄
R[0]=R[j+1]; //R[0] 不是哨兵，僅做暫存單元
R[j+1]=R[j];
R[j]=R[0];
exchange=TRUE; // 發生了交換，故將交換標志置為真
}
if(!exchange) // 本趟排序未發生交換，提前終止演算法
return;
} //endfor( 外循環 )
}//BubbleSort

publicclassBubbleSort{

publicstaticvoidmain(String[]args){
//TODOAuto-generatedmethodstub
List<Integer>lstInteger=newArrayList<Integer>();
lstInteger.add(1);
lstInteger.add(1);
lstInteger.add(3);
lstInteger.add(2);
lstInteger.add(1);
for(inti=0;i<lstInteger.size();i++){
System.out.println(lstInteger.get(i));
}
System.out.println("排序之後-----------------");
lstInteger=sortList(lstInteger);
for(inti=0;i<lstInteger.size();i++){
System.out.println(lstInteger.get(i));
}

}

publicstaticList<Integer>sortList(List<Integer>lstInteger){
inti,j,m;
booleanblChange;
intn=lstInteger.size();

for(i=0;i<n;i++){
blChange=false;
for(j=n-1;j>i;j--){
if(lstInteger.get(j)<lstInteger.get(j-1)){
m=lstInteger.get(j-1);
lstInteger.set(j-1,lstInteger.get(j));
lstInteger.set(j,m);
blChange=true;
}
}
if(!blChange){
returnlstInteger;
}
}
returnlstInteger;
}
}
歸納注釋

演算法的最好時間復雜度:若文件的初始狀態是正序的,一趟掃描即可完成排序。所需的關鍵字比較次數C和記錄移動次數M均達到最小值，即C(min)=n-1,M(min)=0。冒泡排序最好的時間復雜度為O(n)。

演算法的最壞時間復雜度:若初始文件是反序的，需要進行n-1趟排序。每趟排序要進行n-1次關鍵字的比較(1<=i<=n-1),且每次比較都必須移動記錄3次。在這種情況下，比較和移動次數均達到最大值，即C(max)=n(n-1)/2=O(n^2)，M(max)=3n(n-1)/2=O(n^2)。冒泡排序的最壞時間復雜度為O(n^2)。

演算法的平均時間復雜度為O(n^2)。雖然冒泡排序不一定要進行n-1趟，但由於它的記錄移動次數較多，故平均時間性能比直接插入排序要差得多。

演算法穩定性：冒泡排序是就地排序，且它是穩定的。

演算法改進：上述的冒泡排序還可做如下的改進，①記住最後一次交換發生位置lastExchange的冒泡排序(該位置之前的相鄰記錄均已有序)。下一趟排序開始時，R[1..lastExchange-1]是有序區，R[lastExchange..n]是無序區。這樣，一趟排序可能使當前有序區擴充多個記錄，從而減少排序的趟數。②改變掃描方向的冒泡排序。冒泡排序具有不對稱性。能一趟掃描完成排序的情況，只有最輕的氣泡位於R[n]的位置，其餘的氣泡均已排好序，那麼也只需一趟掃描就可以完成排序。如對初始關鍵字序列12、18、42、44、45、67、94、10就僅需一趟掃描。需要n-1趟掃描完成排序情況，當只有最重的氣泡位於R[1]的位置，其餘的氣泡均已排好序時，則仍需做n-1趟掃描才能完成排序。比如對初始關鍵字序列：94、10、12、18、42、44、45、67就需7趟掃描。造成不對稱性的原因是每趟掃描僅能使最重氣泡「下沉」一個位置，因此使位於頂端的最重氣泡下沉到底部時，需做n-1趟掃描。在排序過程中交替改變掃描方向，可改進不對稱性

㈤ JAVA 冒泡排序法的詳細解釋是什麼

冒泡排序的英文Bubble Sort，是一種最基礎的交換排序。

大家一定都喝過汽水，汽水中常常有許多小小的氣泡，嘩啦嘩啦飄到上面來。這是因為組成小氣泡的二氧化碳比水要輕，所以小氣泡可以一點一點向上浮動。而我們的冒泡排序之所以叫做冒泡排序，正是因為這種排序演算法的每一個元素都可以像小氣泡一樣，根據自身大小，一點一點向著數組的一側移動。

冒泡排序演算法的原理如下：

• 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。

• 對每一對相鄰元素做同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。

• 針對所有的元素重復以上的步驟，除了最後一個。

• 持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。

具體如何來移動呢？讓我們來看一個栗子：



希望對您有所幫助！~

㈥ JAVA選擇排序演算法方法

下面是我自己定的一個int數組排序的工具，希望對你有幫助。

package net.ftng.util.Order;

public class IntArrayOrder {

/**
* @param args
*/
public static void main(String[] args) {
int[] a = { 12, 6, 14, 7, 18, 9 };

System.out.print("noOrderByAnything====>:");
for (int t : a) {
System.out.print(t + " ");
}

System.out.println();

System.out.print("orderByAscend====>:");
int[] temp = lightOrderByAscend(a);
for (int t : temp) {
System.out.print(t + " ");
}

System.out.println();

System.out.print("orderByDescend====>:");
temp = lightOrderByDescend(a);
for (int t : temp) {
System.out.print(t + " ");
}

}

static public int[] lightOrderByAscend(int[] args) {
try {
int temp;
int[] tempargs = args.clone();
int argsLength = tempargs.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (tempargs[i] < tempargs[j]) {
temp = tempargs[i];
tempargs[i] = tempargs[j];
tempargs[j] = temp;
}
}
}
return tempargs;

} catch (Exception e) {
return null;
}

}

static public int[] deepOrderByAscend(int[] args) {
try {
int temp;
int argsLength = args.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (args[i] < args[j]) {
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
}
return args;

} catch (Exception e) {
return null;
}

}

static public int[] lightOrderByDescend(int[] args) {
try {
int temp;
int[] tempargs = args.clone();
int argsLength = tempargs.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (tempargs[i] > tempargs[j]) {
temp = tempargs[i];
tempargs[i] = tempargs[j];
tempargs[j] = temp;
}
}
}
return tempargs;

} catch (Exception e) {
return null;
}

}

static public int[] deepOrderByDescend(int[] args) {
try {
int temp;
int argsLength = args.length;

for (int i = 0; i < argsLength; i++) {
for (int j = i + 1; j < argsLength; j++) {
if (args[i] > args[j]) {
temp = args[i];
args[i] = args[j];
args[j] = temp;
}
}
}
return args;

} catch (Exception e) {
return null;
}

}
}

㈦ java實現幾種常見排序演算法

下面給你介紹四種常用排序演算法：

1、冒泡排序

特點：效率低，實現簡單

思想（從小到大排）：每一趟將待排序序列中最大元素移到最後，剩下的為新的待排序序列，重復上述步驟直到排完所有元素。這只是冒泡排序的一種，當然也可以從後往前排。

㈧ Java的排序演算法有哪些

排序： 插入，冒泡，選擇，Shell,快速排序

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

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

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

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

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

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

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

publicclassTest2{
publicstaticvoidmain(String[]args){
int[]a={5,4,2,4,9,1};
Arrays.sort(a);//進行排序
for(inti:a){
System.out.print(i);
}
}
}

<2>冒泡排序演算法

publicstaticint[]bubbleSort(int[]args){//冒泡排序演算法
for(inti=0;i<args.length-1;i++){
for(intj=i+1;j<args.length;j++){
if(args[i]>args[j]){
inttemp=args[i];
args[i]=args[j];
args[j]=temp;
}
}
}
returnargs;
}

<3>選擇排序演算法

publicstaticint[]selectSort(int[]args){//選擇排序演算法
for(inti=0;i<args.length-1;i++){
intmin=i;
for(intj=i+1;j<args.length;j++){
if(args[min]>args[j]){
min=j;
}
}
if(min!=i){
inttemp=args[i];
args[i]=args[min];
args[min]=temp;
}
}
returnargs;
}

<4>插入排序演算法

publicstaticint[]insertSort(int[]args){//插入排序演算法
for(inti=1;i<args.length;i++){
for(intj=i;j>0;j--){
if(args[j]<args[j-1]){
inttemp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}elsebreak;
}
}
returnargs;
}

㈩ Java的幾種常見排序

快速排序法、冒泡法、選擇排序法、插入排序法
1.快速排序：

import java.util.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;i<args.length-1;i++){
for(int j=i+1;j<args.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;i<args.length-1 ;i++ ){
int min=i;
for (int j=i+1;j<args.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;i<args.length;i++){
for(int j=i;j>0;j--){
if (args[j]<args[j-1]){
int temp=args[j-1];
args[j-1]=args[j];
args[j]=temp;
}else break;
}
}
return args;
}