數組排序java冒泡排序
1. java冒泡排序
packageTest;
importjava.util.Arrays;
publicclassDemo1{
publicstaticvoidmain(String[]args){
int[]a={2,1,3,9,7,10,8,11,17,6};
//System.out.println(Arrays.toString(a));
sortArr(a,a.length-1,0);
System.out.println(Arrays.toString(a));
sort(a);
System.out.println(Arrays.toString(a));
}
publicstaticvoidsortArr(int[]a,inti,intj){
if(j<i){
sortOne(a,i,j);
}else{
sortOne(a,--i,0);
}
}
publicstaticvoidsortOne(int[]a,inti,intj){
if(i==0)return;
if(a[j+1]<a[j]){
inttemp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
sortArr(a,i,++j);
}
publicstaticvoidsort(int[]a)
{
inttemp=0;
for(inti=a.length-1;i>0;--i)
{
for(intj=0;j<i;++j)
{
if(a[j+1]<a[j])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
}
}
}
上面代碼是從小到大排列
packageTest;
importjava.util.Arrays;
publicclassDemo1{
publicstaticvoidmain(String[]args){
Object[]a={2,1,3,9,7,10,8,11,17,6};
sortArr(a,a.length-1,0);
System.out.println(Arrays.toString(a));
Object[]b={'a','m','s','b','h','e'};
sortArr(b,b.length-1,0);
System.out.println(Arrays.toString(b));
}
publicstaticvoidsortArr(Object[]a,inti,intj){
if(j<i){
sortOne(a,i,j);
}else{
sortOne(a,--i,0);
}
}
publicstaticvoidsortOne(Object[]a,inti,intj){
if(i==0)return;
if(a[j+1]instanceofInteger){
if(Integer.valueOf(""+a[j+1])<Integer.valueOf(""+a[j])){
Objecttemp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}elseif(a[j+1]instanceofCharacter){
if(a[j+1].toString().charAt(0)<a[j].toString().charAt(0)){
Objecttemp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
sortArr(a,i,++j);
}
// publicstaticvoidsort(int[]a)
// {
// inttemp=0;
// for(inti=a.length-1;i>0;--i)
// {
// for(intj=0;j<i;++j)
// {
// if(a[j+1]<a[j])
// {
// temp=a[j];
// a[j]=a[j+1];
// a[j+1]=temp;
// }
// }
// }
// }
}
2. java數組冒泡排序問題
你當前的數組長度為5
冒泡排序的做法是：
1、取下標為0的元素分別去和下標為1、2、3、4的元素進行比較，值最大的元素或者是值最小的元素與下標為0的元素互換位置；
2、取下標為1的元素分別去和下標為0、2、3、4的元素進行比較，值最大的元素或者是值最小的元素與下標為1的元素互換位置；
3、取下標為2的元素分別去和下標為0、1、3、4的元素進行比較，值最大的元素或者是值最小的元素與下標為2的元素互換位置；
以此類推，直到數組的最後一個元素也分別和其他元素進行過比較之後終止循環。
程序中的 temp 是幫助程序將數組中的兩個元素互換位置的。
另：你這段程序可以簡化為
public class Demo2 { public static void main(String[] args) { int arr[]={1,10,3,5,4};
Arrays.sort(arr);
for (int i : arr) {
System.out.println(i);
}
}
樓主可以著重看看Arrays.sort()這個方法，這是java.util包下的排序方法。
3. java數組如何排序
如果是升序可以使用 Arrays.sort（數組名)（注意：要使用這個方法必須導入java.util.Arrays包）或者使用冒泡排序，如果是降序只能自己寫，推薦使用冒泡排序
4. java定義一個整型數組將數組中的元素用冒泡排序法升序排序
請看：
/*
*冒泡排序
*/
publicclassBubbleSort{
publicstaticvoidmain(String[]args){
int[]arr={6,3,8,2,9,1};
System.out.println("排序前數組為：");
for(intnum:arr){
System.out.print(num+"");
}
for(inti=0;i<arr.length-1;i++){//外層循環控制排序趟數
for(intj=0;j<arr.length-1-i;j++){//內層循環控制每一趟排序多少次
if(arr[j]>arr[j+1]){
inttemp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println();
System.out.println("排序後的數組為：");
for(intnum:arr){
System.out.print(num+"");
}
}
}
5. java冒泡排序詳細講解
依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。至此第一趟結束，將最大的數放到了最後。在第二趟：仍從第一對數開始比較（因為可能由於第2個數和第3個數的交換，使得第1個數不再小於第2個數），將小數放前，大數放後，一直比較到倒數第二個數（倒數第一的位置上已經是最大的），第二趟結束，在倒數第二的位置上得到一個新的最大數（其實在整個數列中是第二大的數）。如此下去，重復以上過程，直至最終完成排序。
由於在排序過程中總是小數往前放，大數往後放，相當於氣泡往上升，所以稱作冒泡排序。
for(int
j=0;j<=len-i-1;j++),冒泡排序比較相鄰的值，也就是a[j]和a[j+1]相比較
所以這段代碼從a[0]開始與後面的a[1]比較，如果a[1]小於
a[0]就換。不小於j++，a[1]和[a2]比較，以此類推，直到比到a[len-i-1]時，也就比到了最後一個數組了。上層循環就是控制數組比較的長度。
6. java冒泡排序法代碼
冒泡排序是比較經典的排序演算法。代碼如下：
for(int i=1;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
//交換位置
}
拓展資料：
原理：比較兩個相鄰的元素，將值大的元素交換至右端。
思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重復第一趟步驟，直至全部排序完成。
第一趟比較完成後，最後一個數一定是數組中最大的一個數，所以第二趟比較的時候最後一個數不參與比較；
第二趟比較完成後，倒數第二個數也一定是數組中第二大的數，所以第三趟比較的時候最後兩個數不參與比較；
依次類推，每一趟比較次數-1；
……
舉例說明：要排序數組：int[]arr={6,3,8,2,9,1};
for(int i=1;i<arr.length;i++){
for(int j=1;j<arr.length-i;j++){
//交換位置
}
7. java語言中怎樣用冒泡法對數組元素的排序
public class Practice {
public void sortArry(){
int arr[]={2,1,5,8,21,12};
System.out.println("冒泡排序前的結果是：");
for(int i=0;i<arr.length;i++){
System.out.print(" "+arr[i]);
}
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
System.out.println("冒泡排序後的結果是：");
for(int i=0;i<arr.length;i++){
System.out.print(" "+arr[i]);
}
}
public static void main(String args[]){
Practice p=new Practice();
p.sortArry();
}
}
你看看還有啥問題就問，抱歉趕時間，我沒有加註釋哦，其實我感覺你把冒泡排序的思想理解了就好了，每次從數組中選擇出一個最大的（也可以是最小的），放到最後，每次都找最大的，然後找n-1次，n是數組長度，你看看。
8. 冒泡排序演算法，java
原理：比較兩個相鄰的元素，將值大的元素交換至右端。
思路：依次比較相鄰的兩個數，將小數放在前面，大數放在後面。即在第一趟：首先比較第
1個和第2個數，將小數放前，大數放後。然後比較第2個數和第3個數，將小數放前，大
數放後，如此繼續，直至比較最後兩個數，將小數放前，大數放後。重復第一趟步驟，直至
全部排序完成。
publicclass BubbleSort {
publicstaticvoid main(String[] args) { int[] arr={12,45,23,67,56,34,99,123}; System.out.println("排序前數組為：");
for(int n:arr){
System.out.print(n+"");
}
for(int i=0;i<arr.length-1;i++){//外層循環控制排序趟數
for(int j=0;j<arr.length-1-i;j++){//內層循環控制每一趟排序多少次 if(arr[j]>arr[j+1]){ int temp=arr[j]; arr[j]=arr[j+1]; arr[j+1]=temp;
}
}
9. java 冒泡排序怎麼寫
int[]
num=new
int[]{1，6，5，8，9，4，7};
int
temp
=
0;//用於兩個數進行交換的中間變數
for(int
i=0;i<num.length;i++){
//外層循環開始
控制比較的開始位置
和比較的次數
for(int
j=num.length-1;j>i;j--){
//內層循環開始
對相鄰的兩個數進行比較
若後者比前者大則交換位置
if(num[j]>num[j-1]){
temp=num[j-1];
num[j-1]=num[j];
num[j]=temp;
}
}
}