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

排序的方法有：插入排序（直接插入排序、希爾排序），交換排序（冒泡排序、快速排序），選擇排序（直接選擇排序、堆排序），歸并排序，分配排序（箱排序、基數排序）

網站建設哪家好，找創新互聯！專注于網頁設計、網站建設、微信開發、微信平臺小程序開發、集團企業網站建設等服務項目。為回饋新老客戶創新互聯還提供了瑞金免費建站歡迎大家使用！

快速排序的偽代碼。

/

/使用快速排序方法對a[

:n-

1

]排序

從a[

:n-

1

]中選擇一個元素作為m

i

d

d

l

e，該元素為支點

把余下的元素分割為兩段left

和r

i

g

h

t，使得l

e

f

t中的元素都小于等于支點，而right

中的元素都大于等于支點

遞歸地使用快速排序方法對left

進行排序

遞歸地使用快速排序方法對right

進行排序

所得結果為l

e

f

t

+

m

i

d

d

l

e

+

r

i

g

h

t

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

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

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

選擇排序代碼如下：

public void Select_sort(int[] arr) {

int temp,index;

for( int i=0;i10;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 n1

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

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

copy 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

p span="" do="" j

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

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

else copy 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;i10;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];

}

}

}

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

想問您一些排序算法的偽代碼，謝啦

冒泡排序：網頁鏈接

所謂排序，就是使一串記錄，按照其中的某個或某些關鍵字的大小，遞增或遞減的排列起來的操作。排序算法，就是如何使得記錄按照要求排列的方法。排序算法在很多領域得到相當地重視，尤其是在大量數據的處理方面。一個優秀的算法可以節省大量的資源。在各個領域中考慮到數據的各種限制和規范，要得到一個符合實際的優秀算法，得經過大量的推理和分析。

C++自帶的algorithm庫函數中提供了排序算法。

穩定的

冒泡排序（bubble sort） — O(n^2）

雞尾酒排序(Cocktail sort，雙向的冒泡排序) — O(n^2）

插入排序（insertion sort）— O(n^2)

桶排序（bucket sort）— O(n); 需要 O(k) 額外空間

計數排序(counting sort) — O(n+k); 需要 O(n+k) 額外空間

合并排序（merge sort）— O(nlog?n); 需要 O(n) 額外空間

原地合并排序— O(n^2)

二叉排序樹排序 （Binary tree sort） — O(nlog?n)期望時間； O(n^2)最壞時間； 需要 O(n) 額外空間

鴿巢排序(Pigeonhole sort) — O(n+k); 需要 O(k) 額外空間

基數排序（radix sort）— O(n·k); 需要 O(n) 額外空間

Gnome 排序— O(n^2)

圖書館排序— O(nlog?n) with high probability，需要 （1+ε)n額外空間

不穩定的

選擇排序（selection sort）— O(n^2)

希爾排序（shell sort）— O(nlog?n) 如果使用最佳的現在版本

組合排序— O(nlog?n)

堆排序（heapsort）— O(nlog?n)

平滑排序— O(nlog?n)

快速排序（quicksort）— O(nlog?n) 期望時間，O(n^2) 最壞情況； 對于大的、亂數列表一般相信是最快的已知排序

Introsort— O(nlog?n)

耐心排序— O(nlog?n+?k) 最壞情況時間，需要 額外的 O(n+?k) 空間，也需要找到最長的遞增子串行（longest increasing subsequence）

不實用的

Bogo排序— O(n×?n!) 期望時間，無窮的最壞情況。

Stupid sort— O(n^3); 遞歸版本需要 O(n^2) 額外存儲器

珠排序（Bead sort） — O(n) or O（√n)，但需要特別的硬件

Pancake sorting— O(n)，但需要特別的硬件

stooge sort——O（n^2.7）很漂亮但是很耗時

排序都有哪幾種方法？請列舉.用java實現一個插入排序

快速排序的偽代碼。

/

/使用快速排序方法對a[

:n-

1

]排序

把余下的元素分割為兩段left

和r

i

g

h

t，使得l

e

f

t中的元素都小于等于支點，而right

中的元素都大于等于支點

插入、合并、快速、計數、基數、桶排序（偽代碼）

從數組第二個元素開始循環，比較其之前的元素有無比它大的，若有則往后移，最后將這個值放到正確位置

時間復雜度O（n^2）

合并排序：

合并操作：

時間復雜度O（nlgn）

采用分治策略

排序一個數組A的全部元素，初始調用為QUICKSORT（A，1，A.length）

x為主元，并圍繞x來分割A為兩個數組

函數中，p為比x小的子數組的初始索引，i為比x小的子數組的最后索引，j為遍歷除了x的數組元素的主索引

示例：

發生在分割中心選擇了最大或最小的元素

此時為O（n^2）

分割中心每次都選到中值元素

此時為O(nlgn)

時間復雜度和最好情況相同

n為A中元素數目，k為A中 種類 數目

3-4行：將索引為A[j]的C數組元素+1，表示此索引表示的值在A數組中出現的次數

5-6行：將C[i]表示成小于等于i的元素的個數

9-11行：j從n開始直到1，將A[j]值賦給索引為A[j]出現次數的B數組中，然后相應出現次數減1

將A數組中出現的元素的次數記錄在C數組中，

C數組中元素為 小于等于此索引 的A中元素出現的次數

最后將其表現為B數組，就排好序了

時間復雜度為O（n+k）

小范圍整數排序O（n）

排序結果具有穩定性：對于相同值的元素，在原來數組中的先后順序排序后得以保留

按照數字的基底一位位地排序

基底：如十進制數基底為10，二進制數為2

基底表示如下：

基數排序從低位開始進行穩定的增序排序，一直到最大位為止

將A數組的元素插入到B中

對B中每一個鏈進行插入排序（總之排序就對了）

平均情況下，時間復雜度為O（n）

因為數據是均勻、獨立地分布在[0，1）之間，所以一般不會出現很多數落在同一個桶的情況。

網站欄目：java插入排序偽代碼 寫出選擇排序的偽代碼
網站鏈接：http://vcdvsql.cn/article18/hiodgp.html

成都網站建設公司_創新互聯，為您提供軟件開發、微信小程序、外貿建站、靜態網站、網站收錄、小程序開發

廣告

聲明：本網站發布的內容（圖片、視頻和文字）以用戶投稿、用戶轉載內容為主，如果涉及侵權請盡快告知，我們將會在第一時間刪除。文章觀點不代表本網站立場，如需處理請聯系客服。電話：028-86922220；郵箱：631063699@qq.com。內容未經允許不得轉載，或轉載時需注明來源： 創新互聯