public class Test_Ordination
{
　　public static void main(String args[])
        {
　　                int[] s = {23,5,12,59,78,21,100,79,66};
　　                for(int j=1;j<=s.length;j++)
　　                {
　                　        for(int i=0;i<s.length-1;i++)
　                        {
　　                                if(s>s[i+1])
　　                                {
　　                                        int temp;
　                                        temp = s;
　　                                        s = s[i+1];
　　                                        s[i+1] = temp;
　　                                }
　　                        }
　　                }
　　for(int i1=0;i1<s.length;i1++)
        {
　　                System.out.println(s[i1]);
　　        }
        }
}


这个是我百度的冒泡排序
int[] s = {23,5,12,59,78,21,100,79,66};
for(int j=1;j<=s.length;j++)
这句效果是不是给他排序了已经   length是数组的长度还是数的大小

是数组的长度 那句话没给排序的 ，      int temp;
　                                        temp = s;
　　                                        s = s[i+1];
　　                                        s[i+1] = temp;  
这句话才是

冒泡排序就是一个一个气泡向上 起泡越来越大。就是一个一个比较然后得出一个最大的放在前面，然后在开始拿第2个开始向后比较

最小的放在前面  原理我懂  就是细节  我卡在细节上了  让我记结构能记住  就是想分析一下

关于冒泡问题 我下面写了一篇三种排序方法的思想 和算法 你可以参考一下

    插入法排序：插入法排序的中心思想是将待排序的记录(元素)逐个进行处理，即将待排序的一个新记录与前面已经排好序的进行比较，然后插入到适当的位置中。核心特点：被插入的序列已经排好序这样一旦找到第一不满足条件的记录就不用继续往下遍历了。

      冒泡排序：冒泡排序的思想是不断比较相邻的两个记录的值，如果不满足要求则交换相邻的记录，直到所有记录排好序。

     直接选择排序：逐个找到第n小的记录，并将这个记录放入到数组的第n个位置中，与冒泡排序不相同的是选择排序不需要不断交换记录，只是将第n个记录与满足条件的某个记录如第n+m记录交换。

   关于他们的描述先就这么写吧 一下是各个排序算法的代码，大家如果有更好的见解欢迎指导交流。

// 插入法排序

public void insert(int a[]){
  int temp=0;
  for(int i=1;i<a.length;i++){
   for (int j = i; j > 0; j--) {
    if(a[j]<a[j-1]){
     temp=a[j];
     a[j]=a[j-1];
     a[j-1]=temp;
    }else break;
   }
  }
}
//优化的插入法排序
public void insert2(int a[]){
  for (int i = 1; i < a.length; i++) {
   int temp=a;
   int j=i-1;
   while(j>=0&&temp<a[j]){
    a[j+1]=a[j];
    j--;
   }
   if(j<i-1){a[j+1]=temp;}
  }
}

//冒泡排序

public void bubble(int a[]){
  for (int i = 1; i < a.length; i++) {
   for (int j = a.length-1; j >=i; j--) {
    if(a[j]<a[j-1]){
     int temp=a[j];
     a[j]=a[j-1];
     a[j-1]=temp;
    }
   }
  }
}

//直接选择排序

public void select(int []a){
  int index=0;
  int temp=a[0];
  for (int i = 0; i < a.length-1; i++) {
   temp=a;
   index=i;
   for (int j = i+1; j < a.length; j++) {
    if(a[j]<a[index]){index=j;}
   }
   a=a[index];
   a[index]=temp;
  }
}

以上就是三种简单排序的代码 ，第一次写博客也不知道如何写好久墨迹到这里吧，希望大家踊跃交流。

如果对方没有要求用哪种种算法的话我建议你用优化了的插入法排序，这样时间代价会缩短一点。

你的冒泡也有一点缺陷

int[] s = {23,5,12,59,78,21,100,79,66};
　　                for(int j=1;j<=s.length;j++)
　　                {
　                　        for(int i=0;i<s.length-1;i++)

有点重复了 因为前面的部分已经排好了就不用再从头开始遍历了，之需要从没有排的部分开始就可以了。

[ 本帖最后由 兰海忠 于 2011-07-26  10:46 编辑 ]

原理：每次将待排序数列中的最大数，放到序列末尾。
排序算法可以有多种写法，您百度的那个算法，不方便理解。看看下面的代码：
范例1：冒泡排序。[code=java]package org.cxy.demo;

import java.util.*;
public class Demo {
        public static void main(String[] args) {
                int[] array = {23,5,12,59,78,21,100,79,66,1};
                int temp ;
                for(int i=array.length-1;i>0;i--){
                        for(int j=0;j<i;j++){
                                if(array[j]>array[j+1]){
                                        temp = array[j];
                                        array[j] = array[j+1];
                                        array[j+1] = temp;
                                }
                        }
                }
                System.out.println(Arrays.toString(array));
        }
}[/code]外层循环i代表，当前待排序数列中最大数，将要存放的位置。
第一次排序的时候，待排序序列中的最大数，应该被放到数组的最后一个位置，即array.length-1的地方，然后依次前移一个位置。
冒泡排序是交换排序的一种，需要相邻的两个元素进行比较。 因此i的取值到1即可。 若是到0，则最后一个元素还要和自己再比较一次，这是没意义的。
内层循环用于完成每轮比较。每次都从待排序序列中第一个元素开始，和他后面的一个元素进行比较，并且总是保证数值大的一方在后面的位置，直到j<i为止。
语句“if(array[j]>array[j+1])”的含义为：若前面的元素比后面的元素大， 则交换他们的位置。

排序算法，主要靠的就是思考，您随便百度一个算法来，就让别人给您讲，这是对自己很不负责任的。

你这个算法有错误  s = s[i+1](s是数组s[i+1]数组的元素不能相等)  这个是改过的
public class Test_Oridination
{
   public static void main(String[] args)
        {
               int[] s = {23,5,12,59,78,21,100,79,66};
                    for(int j=1;j<=s.length;j++)
                     {
                       for(int i=0;i<s.length-1;i++)
                           {
                                if(s[i]>s[i+1])
                                {
                                    int temp;
                                    temp = s[i];
                                    s[i] = s[i+1];
                                   s[i+1] = temp;
                                    }
                                    }
                           }
            for(int i1=0;i1<s.length;i1++)
            {
                  System.out.println(s[i1]);
               }
              }
}

冒泡排序的关键在于
              if(s[i]>s[i+1])
                                {
                                    int temp;
                                    temp = s[i];
                                    s[i] = s[i+1];
                                   s[i+1] = temp;
                                    } 把s[i]和s[i+1]置换位置  然后外面的是一个嵌套的循环只要按照循环一步一步来就可以了

都一样 大的放前，和小的放前，学习一定要灵活，你卡在什么细节上了呢

5楼讲的很详细了。仔细看看。多编写编写，动手写，就会理解很多。

你看看这个冒泡排序:[code]class BubbleOrder
{
  public static void main(String[] args)
  {
    int[] arry={2,4,6,7,9,1};
    bubble(arry);
  }

  public static void bubble(int[] arry)
  {
      int[] ary=arry;
      int l=ary.length;
      for(int i=0;i<l;i++)
        {
            for(int j=i+1;j<l;j++)
              {
                    
                    if(ary[i]>ary[j])
                    
                    {int temp=ary[i];
                     ary[i]=ary[j];
                     ary[j]=temp;}
               }
        }
        
       System.out.println("冒泡排序后为:");
       for(int k=0;k<l;k++)
         {
               System.out.print(" "+ary[k]);
         }
     
   }
}[/code]这个冒泡排序每次都假定数组是按索引有序的，第一层循环保证数组中的每一个元素都排序一次，第二层循环保证数组中的每个元素都与未排序的元素比较一次。这样看来有序元素上移，就像水中的"泡泡"一样上浮。我是这么理解的，互相学习 ！你的那个不能排序吧。