谁能给我讲讲冒泡排序的原理

Question

谁能给我讲讲冒泡排序的原理

Answer 1

http://baike.baidu.com/view/254413.htm
还不如找本书自己看看呢

Answer 2

“冒泡”這個詞本身就是很形象的。冒泡排序，就是若干個泡泡在一個水缸裡，然後他們相互比較。A：“你有我大個嗎？”
B：“沒有。”
A：“那我得浮在你上面。”
C：“A，瞧你小樣，你還沒我大，在我下面待著吧。”

Answer 3

百度百科 维基百科 都看不懂。。知道大概是两个for循环

Answer 4

int[] array = new int[5] { 1, 4, 2, 5, 3 }; for(int i=1;i< arr.Length;i++)
{
   for(int j=(arr.Length-1);j>=i;j--)
   {
       if(arr[j+1]<arr[j])
       {
          int temp= arr[j];
          arr[j+1]=arr[j];
          arr[j] = temp;
       }
    }
}

Answer 5

/// <summary>
  /// 基本思路：两两比较
  /// 排序，按升序排列
  /// </summary>
  /// <param name="str"></param>
  public static void GetSort(int[] str)
  {
  int temp = 0;
  Console.Write("原数组是:");
  for (int i = 0; i < str.Length; i++)
  {
  Console.Write(str[i]+"\t");
  }
  Console.WriteLine();
  for (int i = 0; i <str.Length; i++)  
  {
  Console.WriteLine("第{0}轮的排序结果是:",i+1);
  for (int j = 0; j < str.Length-1-i; j++) //两两比较 没一轮比较都会依次递减比表的次数
  {
  if (str[j] > str[j + 1])//比较相邻的两个数
  {
  temp = str[j]; //把较大的值放入到临时变量里
  str[j] = str[j + 1]; //因为是升序 数组第一位放较小值
  str[j + 1] = temp; //因为是升序 数组第二位放较大值（即temp）
  }
  //打印每次比较的结果
  for (int k = 0; k < str.Length; k++)
  {
  Console.Write(str[k] + "\t");
  }
  Console.WriteLine();
    
  }  Console.WriteLine();
  }
  }
  /// <summary>
  /// 降序，按降序排列
  /// </summary>
  /// <param name="str"></param>
  public static void GetSort1(int[] str)
  {
  int temp = 0;
  for (int i = 0; i < str.Length; i++) //外循环5次
  {
  for (int j = 0; j < str.Length - 1 - i; j++)
  {
  if (str[j] < str[j + 1]) //如果前一个小于后一个
  {
  temp = str[j]; //第一个值和它的下一个值比较 把小的就放入到临时变量里
  str[j] = str[j + 1]; //把大的这个值放入到它后面
  str[j + 1] = temp; //把小的这个值放入到第一位   
  }
  //打印每次比较的结果
  for (int k = 0; k < str.Length; k++)
  {
  Console.Write(str[k] + "\t");
  }
  Console.WriteLine();  }  Console.WriteLine();  }
  }

Answer 6

http://topic.csdn.net/u/20090113/11/F371C1F2-9330-4B61-B845-00177E6AE953.html
楼主看看这个吧

Answer 7

/// <summary>
  /// 基本思路：两两比较
  /// 排序，按升序排列
  /// </summary>
  /// <param name="str"></param>
  public static void GetSort(int[] str)
  {
  int temp = 0;
  Console.Write("原数组是:");
  for (int i = 0; i < str.Length; i++)
  {
  Console.Write(str[i]+"\t");
  }
  Console.WriteLine();
  for (int i = 0; i <str.Length; i++)  
  {
  Console.WriteLine("第{0}轮的排序结果是:",i+1);
  for (int j = 0; j < str.Length-1-i; j++) //两两比较 没一轮比较都会依次递减比表的次数
  {
  if (str[j] > str[j + 1])//比较相邻的两个数
  {
  temp = str[j]; //把较大的值放入到临时变量里
  str[j] = str[j + 1]; //因为是升序 数组第一位放较小值
  str[j + 1] = temp; //因为是升序 数组第二位放较大值（即temp）
  }
  //打印每次比较的结果
  for (int k = 0; k < str.Length; k++)
  {
  Console.Write(str[k] + "\t");
  }
  Console.WriteLine();
    
  }  Console.WriteLine();
  }
  }
  /// <summary>
  /// 降序，按降序排列
  /// </summary>
  /// <param name="str"></param>
  public static void GetSort1(int[] str)
  {
  int temp = 0;
  for (int i = 0; i < str.Length; i++) //外循环5次
  {
  for (int j = 0; j < str.Length - 1 - i; j++)
  {
  if (str[j] < str[j + 1]) //如果前一个小于后一个
  {
  temp = str[j]; //第一个值和它的下一个值比较 把小的就放入到临时变量里
  str[j] = str[j + 1]; //把大的这个值放入到它后面
  str[j + 1] = temp; //把小的这个值放入到第一位   
  }
  //打印每次比较的结果
  for (int k = 0; k < str.Length; k++)
  {
  Console.Write(str[k] + "\t");
  }
  Console.WriteLine();  }  Console.WriteLine();  }
  }

Answer 8

比如，要从小到大排列
原理就是  外层循环    先找出n个数中最小的，放在最左面 。
然后在剩下的n-1数中，再找出最小的，放在左面第2个。
然后在剩下的n-2数中，再找出最小的，放在左面第3个。

直到最后还剩1个数，他就是最大的，在最右面。完毕

Answer 9

故明思意,就是像冒泡一样有 n 个数字就要进行 n-1 的查找,如下:第1  次: 把最大(最小)的数字放在第1位!
第2  次: 把最大(最小)的数字放在第1位!(除前第1位)
第3  次: 把最大(最小)的数字放在第1位!(除前第2位)
...
第n-1次: 把最大(最小)的数字放在第1位!(除前第n-2位)以下! 谢谢

Answer 10

内循环为什么是
j < str.Length - 1 - i;啊

Answer 11

str.Length - 1 - i; 意思就是 比如 101，9，5，8，4；这组数101要换到4的那个位置就要挪动5-1=4步101这个数字已经确定是最大的了 所以待排序的数字由5个变为5-1=4个 对不对啊交换需要4-1=3所以下次循环就是5-1-1=3？

Answer 12

起泡排序的基本思路是：设待排序记录序列中的记录个数为 n。最多作 n-1 趟起泡，i = 1, 2, , n-1。在第 i 趟中从后向前，j = n-1, n-2, ,  i，顺次两两比较V[j-1]和V[j]。如果发生逆序，即V[j-1]＞V[j]，则交换V[j-1]和V[j]。

Answer 13

原理是临近的数字两两进行比较,按照从小到大或者从大到小的顺序进行交换,
这样一趟过去后,最大或最小的数字被交换到了最后一位,
然后再从头开始进行两两比较交换,直到倒数第二位时结束,其余类似看例子
例子为从小到大排序,
原始待排序数组| 6 | 2 | 4 | 1 | 5 | 9 |第一趟排序(外循环)
第一次两两比较6 > 2交换(内循环)
交换前状态| 6 | 2 | 4 | 1 | 5 | 9 |
交换后状态| 2 | 6 | 4 | 1 | 5 | 9 |
 
第二次两两比较,6 > 4交换
交换前状态| 2 | 6 | 4 | 1 | 5 | 9 |
交换后状态| 2 | 4 | 6 | 1 | 5 | 9 |第三次两两比较,6 > 1交换
交换前状态| 2 | 4 | 6 | 1 | 5 | 9 |
交换后状态| 2 | 4 | 1 | 6 | 5 | 9 |第四次两两比较,6 > 5交换
交换前状态| 2 | 4 | 1 | 6 | 5 | 9 |
交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |第五次两两比较,6 < 9不交换
交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |
 
第二趟排序(外循环)
第一次两两比较2 < 4不交换
交换前状态| 2 | 4 | 1 | 5 | 6 | 9 |
交换后状态| 2 | 4 | 1 | 5 | 6 | 9 |
 
第二次两两比较,4 > 1交换
交换前状态| 2 | 4 | 1 | 5 | 6 | 9 | 
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
 
第三次两两比较,4 < 5不交换
交换前状态| 2 | 1 | 4 | 5 | 6 | 9 | 
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
 
第四次两两比较,5 < 6不交换
交换前状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |第三趟排序(外循环)
第一次两两比较2 > 1交换
交换后状态| 2 | 1 | 4 | 5 | 6 | 9 |
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
 
第二次两两比较,2 < 4不交换
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |
 
第三次两两比较,4 < 5不交换
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 | 
交换后状态| 1 | 2 | 4 | 5 | 6 | 9 |第四趟排序(外循环)无交换
第五趟排序(外循环)无交换排序完毕,输出最终结果1 2 4 5 6 9动态演示

Answer 14

冒泡排序（BubbleSort）的基本概念是：依次比较相邻的两个数，将小数放在前面，大数放在后面。即在第一趟：首先比较第1个和第2个数，将小数放前，大数放后。然后比较第2个数和第3个数，将小数放前，大数放后，如此继续，直至比较最后两个数，将小数放前，大数放后。至此第一趟结束，将最大的数放到了最后。在第二趟：仍从第一对数开始比较（因为可能由于第2个数和第3个数的交换，使得第1个数不再小于第2个数），将小数放前，大数放后，一直比较到倒数第二个数（倒数第一的位置上已经是最大的），第二趟结束，在倒数第二的位置上得到一个新的最大数（其实在整个数列中是第二大的数）。如此下去，重复以上过程，直至最终完成排序。
　　由于在排序过程中总是小数往前放，大数往后放，相当于气泡往上升，所以称作冒泡排序。
　　用二重循环实现，外循环变量设为i，内循环变量设为j。外循环重复9次，内循环依次重复9，8，...，1次。每次进行比较的两个元素都是与内循环j有关的，它们可以分别用a[j]和a[j+1]标识，i的值依次为1,2,...,9，对于每一个i,j的值依次为1,2,...10-i。

Answer 15

package xin;
// bubbleSort.java
// demonstrates bubble sort
// to run this program: C>java BubbleSortApp
////////////////////////////////////////////////////////////////
class ArrayBub
   {
   private long[] a;                 // ref to array a
   private int nElems;               // number of data items
//--------------------------------------------------------------
   public ArrayBub(int max)          // constructor
      {
      a = new long[max];                 // create the array
      nElems = 0;                        // no items yet
      }
//--------------------------------------------------------------
   public void insert(long value)    // put element into array
      {
      a[nElems] = value;             // insert it
      nElems++;                      // increment size
      }
//--------------------------------------------------------------
   public void display()             // displays array contents
      {
      for(int j=0; j<nElems; j++)       // for each element,
         System.out.print(a[j] + " ");  // display it
      System.out.println("");
      }
//--------------------------------------------------------------
   public void bubbleSort()
      {
      int out, in;      for(out=nElems-1; out>1; out--)   // outer loop (backward)
         for(in=0; in<out; in++)        // inner loop (forward)
            if( a[in] > a[in+1] )       // out of order?
               swap(in, in+1);          // swap them
      }  // end bubbleSort()
//--------------------------------------------------------------
   private void swap(int one, int two)
      {
      long temp = a[one];
      a[one] = a[two];
      a[two] = temp;
      }
//--------------------------------------------------------------
   }  // end class ArrayBub
////////////////////////////////////////////////////////////////
public class BubbleSortApp
   {
   public static void main(String[] args)
      {
      int maxSize = 100;            // array size
      ArrayBub arr;                 // reference to array
      arr = new ArrayBub(maxSize);  // create the array      arr.insert(77);               // insert 10 items
      arr.insert(99);
      arr.insert(44);
      arr.insert(55);
      arr.insert(22);
      arr.insert(88);
      arr.insert(11);
      arr.insert(00);
      arr.insert(66);
      arr.insert(33);      arr.display();                // display items      arr.bubbleSort();             // bubble sort them      arr.display();                // display them again
      }  // end main()
   }  // end class BubbleSortApp
////////////////////////////////////////////////////////////////

Answer 16

7楼写的数组越界啦!
int[] arr = { 1, 4, 2, 5, 3,6,89,77 };  for(int i=1;i< arr.length;i++)
{
   for(int j=arr.length-1-i;j>=0;j--)
   {
       if(arr[j+1]<arr[j])
       {
          int temp= arr[j+1];
          arr[j+1]=arr[j];
          arr[j] = temp;
       }
    }
}
for (int k = 0; k < arr.length; k++) {
System.out.println("排序后的结果--------->"+arr[k]);
}