java冒泡排序法代碼

冒泡排序是比較經典的排序算法。代碼如下：

公司主營業務：成都網站設計、網站制作、移動網站開發等業務。幫助企業客戶真正實現互聯網宣傳，提高企業的競爭能力。創新互聯公司是一支青春激揚、勤奮敬業、活力青春激揚、勤奮敬業、活力澎湃、和諧高效的團隊。公司秉承以“開放、自由、嚴謹、自律”為核心的企業文化，感謝他們對我們的高要求，感謝他們從不同領域給我們帶來的挑戰，讓我們激情的團隊有機會用頭腦與智慧不斷的給客戶帶來驚喜。創新互聯公司推出唐山免費做網站回饋大家。

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

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

//交換位置

} ? ?

拓展資料：

原理：比較兩個相鄰的元素，將值大的元素交換至右端。

思路：依次比較相鄰的兩個數，將小數放在前面，大數放在后面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放后。然后比較第2個數和第3個數，將小數放前，大數放后，如此繼續，直至比較最后兩個數，將小數放前，大數放后。重復第一趟步驟，直至全部排序完成。

第一趟比較完成后，最后一個數一定是數組中最大的一個數，所以第二趟比較的時候最后一個數不參與比較；

第二趟比較完成后，倒數第二個數也一定是數組中第二大的數，所以第三趟比較的時候最后兩個數不參與比較；

依次類推，每一趟比較次數-1；

……

舉例說明：要排序數組：int[]?arr={6,3,8,2,9,1};?

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

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

//交換位置

} ? ?

參考資料：冒泡排序原理

請問一下java快速排序源代碼

快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**

* @author treeroot

* @since 2006-2-2

* @version 1.0

*/

public class QuickSort implements SortUtil.Sort{

/* (non-Javadoc)

* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

public void sort(int[] data) {

quickSort(data,0,data.length-1);

}

private void quickSort(int[] data,int i,int j){

int pivotIndex=(i+j)/2;

//swap

SortUtil.swap(data,pivotIndex,j);

int k=partition(data,i-1,j,data[j]);

SortUtil.swap(data,k,j);

if((k-i)1) quickSort(data,i,k-1);

if((j-k)1) quickSort(data,k+1,j);

}

/**

* @param data

* @param i

* @param j

* @return

*/

private int partition(int[] data, int l, int r,int pivot) {

do{

while(data[++l]pivot);

while((r!=0)data[--r]pivot);

SortUtil.swap(data,l,r);

}

while(lr);

SortUtil.swap(data,l,r);

return l;

}

}

改進后的快速排序：

package org.rut.util.algorithm.support;

import org.rut.util.algorithm.SortUtil;

/**

* @author treeroot

* @since 2006-2-2

* @version 1.0

*/

public class ImprovedQuickSort implements SortUtil.Sort {

private static int MAX_STACK_SIZE=4096;

private static int THRESHOLD=10;

/* (non-Javadoc)

* @see org.rut.util.algorithm.SortUtil.Sort#sort(int[])

*/

public void sort(int[] data) {

int[] stack=new int[MAX_STACK_SIZE];

int top=-1;

int pivot;

int pivotIndex,l,r;

stack[++top]=0;

stack[++top]=data.length-1;

while(top0){

int j=stack[top--];

int i=stack[top--];

pivotIndex=(i+j)/2;

pivot=data[pivotIndex];

SortUtil.swap(data,pivotIndex,j);

//partition

l=i-1;

r=j;

do{

while(data[++l]pivot);

while((r!=0)(data[--r]pivot));

SortUtil.swap(data,l,r);

}

while(lr);

SortUtil.swap(data,l,r);

SortUtil.swap(data,l,j);

if((l-i)THRESHOLD){

stack[++top]=i;

stack[++top]=l-1;

}

if((j-l)THRESHOLD){

stack[++top]=l+1;

stack[++top]=j;

}

}

//new InsertSort().sort(data);

insertSort(data);

}

/**

* @param data

*/

private void insertSort(int[] data) {

int temp;

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

for(int j=i;(j0)(data[j]data[j-1]);j--){

SortUtil.swap(data,j,j-1);

}

}

}

}

java排序代碼

整數轉成字符串后排序。import java.util.Arrays;import java.util.Collections;import java.util.List;public class Test { public static void main(String[] args) { List list = Arrays.asList("1", "10", "12", "3", "2", "4", "5"); Collections.sort(list); System.out.println(Arrays.toString(list.toArray())); }}

求java快速排序的正確代碼

一趟快速怕序的具體做法是：附設兩個指針low和high,他們的初值分別為low和high,設樞軸記錄的關鍵字為privotkey,則首先從high所指位置向前搜索找到第一個關鍵字小于pivotkey的記錄和樞軸記錄互相交換,然后從low所指向的位置起向后搜索,找到第一個關鍵字大于privotkey的記錄和樞軸記錄互相交換，重復這兩步直至low==high位置.

import java.util.concurrent.Executor;

import java.util.concurrent.ExecutorService;

import java.util.concurrent.Executors;

public class 快速排序_1 {

public static void main(String[] args) throws InterruptedException {

int test[] = {15,23,56,7,13,52,20,7};

new 快速排序_1().qSort(test, 0, test.length-1);

for(int k:test) System.out.println(k);

}

public void qSort(int []array,int low,int high){

if(low

int privot=partition(array,low,high);

qSort(array,low,privot-1);

qSort(array,privot+1,high);

}

}

public int partition(int [] array,int low,int high){

/**

* 選擇 low位置 作為曲軸(支點)

*/

int pivot=array[low];

int temp=0;

/**

* 如果 low

*/

while(low

/**

* 先從 high端 開始判斷

*/

while(low=pivot) high--;

/**

* 進行 置換操作

*/

if(low

array[low]=array[high];

low++;

}

/**

* 從 low 端判斷

*/

while(low

/**

* 進行 置換操作

*/

if(low

array[high]=array[low];

high--;

}

}

array[low]=pivot;

return low;

}

}

java中排序算法代碼

package temp;

import sun.misc.Sort;

/**

* @author zengjl

* @version 1.0

* @since 2007-08-22

* @Des java幾種基本排序方法

*/

/**

* SortUtil:排序方法

* 關于對排序方法的選擇：這告訴我們，什么時候用什么排序最好。當人們渴望先知道排在前面的是誰時，

* 我們用選擇排序；當我們不斷拿到新的數并想保持已有的數始終有序時，我們用插入排序；當給出的數

* 列已經比較有序，只需要小幅度的調整一下時，我們用冒泡排序。

*/

public class SortUtil extends Sort {

/**

* 插入排序法

* @param data

* @Des 插入排序(Insertion Sort)是，每次從數列中取一個還沒有取出過的數，并按照大小關系插入到已經取出的數中使得已經取出的數仍然有序。

*/

public int[] insertSort(int[] data) {

1/11頁

int temp;

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

for (int j = i; (j 0) (data[j] data[j - 1]); j--) {

swap(data, j, j - 1);

}

}

return data;

}

/**

* 冒泡排序法

* @param data

* @return

* @Des 冒泡排序(Bubble Sort)分為若干趟進行，每一趟排序從前往后比較每兩個相鄰的元素的大小（因此一趟排序要比較n-1對位置相鄰的數）并在

* 每次發現前面的那個數比緊接它后的數大時交換位置；進行足夠多趟直到某一趟跑完后發現這一趟沒有進行任何交換操作（最壞情況下要跑n-1趟，

* 這種情況在最小的數位于給定數列的最后面時發生）。事實上，在第一趟冒泡結束后，最后面那個數肯定是最大的了，于是第二次只需要對前面n-1

* 個數排序，這又將把這n-1個數中最小的數放到整個數列的倒數第二個位置。這樣下去，冒泡排序第i趟結束后后面i個數都已經到位了，第i+1趟實

* 際上只考慮前n-i個數（需要的比較次數比前面所說的n-1要小）。這相當于用數學歸納法證明了冒泡排序的正確性

名稱欄目：用于排序的java代碼 用于排序的java代碼
本文來源：http://vcdvsql.cn/article40/hiooho.html

成都網站建設公司_創新互聯，為您提供面包屑導航、網站內鏈、網站制作、外貿網站建設、ChatGPT、云服務器

廣告

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