冒泡法好像很出名，但是我们的教程上没有，求大神能写个大概格式

学习了。

楼下大神好温馨的回答,攒

就是把数组从前一次往后排序,最值的往后排,就像水里冒的气泡一样

        public static void bubbleSort(int[] arr)
        {
                for (int x=0;x<arr.length-1 ;x++ )
                        for (int y=0;y<arr.length-x-1 ;y++ )//-x；让每一次比较的元素减少，-1；避免角标越界。
                        {
                                if (arr[y]<arr[y+1])
                                {
                                        int temp =arr[y];
                                        arr[y]=arr[y+1];
                                        arr[y+1]=temp;
                                }
                        }
                }
        }

        public static void printArray(int[] arr)
        {
                for (int x=0;x<arr.length ; x++)
                {
                        if(x!=arr.length-1)
                                System.out.print(arr[x]+",");
                        else
                                System.out.println(arr[x]+",");
                }
       
        }
        public static void main(String[] args)
        {
                int[] arr ={5,1,6,4,8,9};
                //排序前；
                printArray(arr);
                //排序
                /lectSort(arr);
                /bbleSort(arr);
                //Arrays.sort(arr);//这是java种已经定义好的一种排序方式，开发中，对数组排序，要使用该句代码。
                //排序后；
                printArray(arr);

       
        }

String类那里会学到的。。。

放养的饼干 发表于 2016-1-16 17:28
最大。。。。。。。。。。。。。。。。。。。

正序…。。。。。。

放养的饼干 发表于 2016-1-16 17:28
最大。。。。。。。。。。。。。。。。。。。

可以选择最大下沉，效果一样，但不形象

擎天柱 发表于 2016-1-16 14:36
基本思想：每一趟选择一个最小元素上浮。

最大。。。。。。。。。。。。。。。。。。。

拿数组中第一个元素与第二个比较，大的放后面，小的放前面，
然后拿第二个元素与第三个比较，大的放后面，小的放前面
依次类推，
最后是拿倒数第二个于倒数第一个比较，大的放后面，小的放前面，
一轮下来最大的一个数就被放在了最后位置，
下一轮比较就忽略到最后位置
以此类推
大的数就像一只气泡一样慢慢浮上来，循环一次就确定一个

基本思想：每一趟选择一个最小元素上浮。

宋达思 发表于 2016-1-16 11:41
public static void bubbleSort(int[] arr)
        {
//x为1轮中每2个相邻元素比较的次数，最后只剩下1个 ...

好全面。。。。。

public static void bubbleSort(int[] arr)
        {
//x为1轮中每2个相邻元素比较的次数，最后只剩下1个元素时就不用比了，所以-1
                for (int x=0;x<arr.length-1 ;x++ )
                {
//-1：防止角标越界； -x：y的角标随x的比较次数而变化，减少每1轮比较元素的个数
                        for (int y=0;y<arr.length-1-x ;y++ )
                        {
                                if(arr[y]>arr[y+1])
                                        swap(arr,y,y+1);
                        }
                }
        }
        public static void bubbleSort2(int[] arr)//只是bubbleSort的反向比较，其它一样
        {
                for (int x=arr.length-1;x>0 ;x-- )
                {
                        for (int y=0;y<x ;y++ )
                        {
                                if(arr[y]>arr[y+1])
                                        swap(arr,y,y+1);
                        }
                }
        }
        public static void swap(int[] arr,int a ,int b)
        {
                int temp=arr[a];
                arr[a]=arr;
                arr=temp;
        }
以下为冒泡原理图：