for(int i = 0; i < array.length ; i++){
int x = 0;
for (int j = i +1; j < array.length - i - 1; j++){
      if (array[j] >array[j + 1]){
         if(array[x] < array[j]){
             x = j;
         }
      }
}
if(array[x] > array[array.length - i -1]){
  int temp = array[x];
  array [array.length - i -1] = array[x];
array[x] = temp;
}
}

自己写的不知道对不对

表示看不懂 下边那个循环是什么意义...

q123123 发表于 2016-7-26 22:31
表示看不懂 下边那个循环是什么意义...

内循环记录角标 外循环将记录的角标的数（当前最大的数）与最后的一个数换位置

[mw_shl_code=java,true]import java.util.ArrayList;
import java.util.List;
import java.util.Random;
//随机产生20个1-100的整数,写入数组,排序
public class Demo {
        public static void main(String[] args) {
                List<Integer> list1 = new ArrayList<Integer>();
                Random r = new Random();
                for(int i=0;i<20;i++){
                        list1.add(r.nextInt(100));
                }
                System.out.println("初始顺序是:");
                System.out.println(list1);
                int min = list1.get(0);
                for(int i=0;i<list1.size();i++){
                        for(int j=i+1;j<list1.size();j++){
                                if(list1.get(j)<list1.get(i)){
                                        min = list1.get(i);
                                        list1.set(i,list1.get(j));
                                        list1.set(j, min);
                                }
                        }
                }
                System.out.println("冒泡法排序后从小到大是:");
                System.out.println(list1);
        }
}[/mw_shl_code]这是我下午写的

M_J 发表于 2016-7-26 23:58
[mw_shl_code=java,true]import java.util.ArrayList;
import java.util.List;
import java.util.Random;

你的是在内循环中换位置（会换很多次）
在堆内存中这样做很消耗资源
如果是在外循环 最多l只需换ist.size()-1次
大大提高了运行效率 当然这是在处理大数组 集合数据是才能体现出来

集合里面的-i-1？这样写不会出错吗

fzc123 发表于 2016-7-27 00:10
集合里面的-i-1？这样写不会出错吗

会出错 没仔细看 主要讨论的是思想{:2_31:}

冒牌儿排序?

haochengjian 发表于 2016-7-27 22:06
冒牌儿排序?

冒泡的优化

最后的if 语句里 的好像有问题，你应该是要把2个数互换吧？
是不是该这么写呢
int temp = array[x];
array[x] =  array [array.length - i -1] ;
array [array.length - i -1] = temp;

让发个广告多个

一个月前随手写的，拿去吧~~~
/*
        冒泡排序:
                                        1.从第一个开始遍历
                                        2.比较第一个值和第二个值的大小
                                        3.大:将第一个值和第二个值交换
                                           小:不变
                                        4.从第二个开始遍历
*/
class BuddleTest {
        public static void main(String[] args) {
                //定义数组
                int[] a = {18,12,3,54,5,46,7,28,9};
                //遍历
                for(int x = 0;x < a.length-1;x++) {
                        for(int y = 0;y < a.length-1-x;y++) {
                        if(a[y]>a[y+1]) {
                                int temp;
                                temp = a[y];
                                a[y] = a[y+1];
                                a[y+1] =temp;
                                }
                        }
                }

                for(int y = 0;y < a.length;y++) {
                        System.out.print(a[y]+" ");
                }
        }
}

好牛逼的赶脚，你懂的

冒泡排序应该都这个道理了吧[mw_shl_code=java,true]public static void bubblesort(int[] arr) {
                for(int j = 0; j < arr.length - 1; j++){
                        for(int i = 0;i < arr.length - 1 - j; i++) {
                                if(arr > arr[i + 1]) {
                                        swap(arr, i, i + 1);
                                }
                        }
                }
                print(arr);
}[/mw_shl_code]

主要应该就是这部分了吧

表示不懂

我说的是效率优化  冒泡的优化！！！！
将换位置操作移到外循环中