java冒泡
『壹』 java冒泡
冒泡就是兩兩交換。。
每循環一次就排好一個數。
10 8 18 7 4
冒泡排序就是內循環
首先用10跟8去比較，10大於8，就進行交換
8 10 18 7 4
然後用10跟18比，不用交換
再用18跟7比，交換，最後跟4比，交換。
第一次外循環結束。
8 10 7 4 18
然後再用8去跟後面的比。。
而18已經排好了，所以就不需要再比較了。。
『貳』 java冒泡排序
首先Public class MpZy是唯一主類。
『叄』 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;
// }
// }
// }
// }
}
『肆』 JAVA 冒泡排序
public static void main(String[] args) {
int[] arr = {5,1,3,7,9,4,2,8,6,0};
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;
}
}
}
for(int i = 0;i<arr.length;i++){
System.out.println(arr[i]);
}
}
『伍』 java中的冒泡排序法
內層循環一次得到這個數組中最大的數並把它放在數組最後一個，同時把內層需要再循環的數組長度減1，即去掉數組中最後一個數（也就是最大的一個）。
外層循環控制內層循環執行幾次。
『陸』 java中的冒泡排序
for(int j=0;i<monkeys.length-1-i;j++)
{
if(monkeys[j].height>monkeys[j+1].height) //該行會報數組越界錯誤
第一行。。for(int j=0;i<monkeys.length-1-i;j++)中的i<monkeys.length-1-i明顯邏輯不對。。該是j<monkeys.length-1-i吧
『柒』 關於JAVA冒泡排序
判斷每一個元素和後一個位置的元素大小，如果大於後面的元素，那麼交換他們的位置。
而交換數組兩個元素的時候，要藉助變數。因為一旦把其中一個的值覆蓋掉的話，就沒法獲取他的值了。。所以藉助temp先把一個值存起來，再覆蓋那個位置，再把存起來的值賦給另一個。。
『捌』 java冒泡排序代碼
冒泡排序（Bubble Sort）是一種簡單的排序演算法。它重復地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重復地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢「浮」到數列的頂端。
冒泡排序演算法的運作如下:
比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。在這一點，最後的元素應該會是最大的數。
針對所有的元素重復以上的步驟，除了最後一個。
持續每次對越來越少的元素重復上面的步驟，直到沒有任何一對數字需要比較。
publicclassBubbleSort{
publicstaticvoidmain(String[]args){
intscore[]={67,69,75,87,89,90,99,100};
for(inti=0;i<score.length-1;i++){//最多做n-1趟排序
for(intj=0;j<score.length-i-1;j++){//對當前無序區間score[0......length-i-1]進行排序(j的范圍很關鍵，這個范圍是在逐步縮小的)
if(score[j]<score[j+1]){//把小的值交換到後面
inttemp=score[j];
score[j]=score[j+1];
score[j+1]=temp;
}
}
System.out.print("第"+(i+1)+"次排序結果：");
for(inta=0;a<score.length;a++){
System.out.print(score[a]+" ");
}
System.out.println("");
}
System.out.print("最終排序結果：");
for(inta=0;a<score.length;a++){
System.out.print(score[a]+" ");
}
}
}
『玖』 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++){
//交換位置
}