冒泡法排序问题

Question

import java.util.Arrays;
public class testone { /**
 * @param args
 */
public static void main(String[] args) {
int [] a={1,5,63,646,46,413,1};
Arrays.sort(a);
  System.out.println("升序排序:");
    for(int i=0;i<a.length;i++){
      for(int j=0;j<a.length-1-i;j++){
       if(a[j]>a[j+1]){
        int temp=a[j];        
        a[j]=a[j+1];
        a[j+1]=temp;
        }      
       
      }
      
    }   
  
  
for(int i=1;i<a.length;i++){
  System.out.println(a[i]);

}
}}碰到数组中有相同数字是排序出现了问题

Answer 1

Arrays.sort(a);
这个方法是JDK自带的方法，已经帮你实现排序了。。
如果是练习排序算法，建议将其注释掉。

Answer 2

感觉你对冒泡的思想还是没掌握，把你的代码改了下： int[] a = { 1, 5, 63, 646, 46, 413, 1 };
//Arrays.sort(a);
System.out.println("升序排序:");
for (int i = 0; i < a.length; i++) {
for (int j = i; j < a.length; j++) {
if (a[j] < a[i]) {
int temp = a[j];
a[j] = a[i];
a[i] = temp;
}
}
}

Answer 3

我提供一种写法给你吧int[] a = {2,5,3,7,9,5,1,6,6};
System.out.println("升序排序");
for (int i=0; i<a.length-1; i++)
    for (int j=0; j<a.length-1-i; j++)
    {
        if (a[j]>a[j+1])
        {
              int temp = a[j];
              a[j] = a[j+1];
              a[j+1] = temp;
         }
     }

Answer 4

亲爱的楼主看好！！！
 /*第一种。冒泡排序法*/
for(int i=0;i<a.length-1;i++){
     for(int j=i+1;j<a.length-1-i;j++){
     if(a[j]>a[j+1]){
          //看这里，j和j+1对比才是冒泡排序，也就是说两个相邻的数作比较。i就是做多次循环！！！！。
如果，你从小到大，就把最大的排到了最后面，i循环多少次，就把多少个大的排在了后面，既然把最大的选择出来了，说以，后面的就不用再比较了，说以要j<a.length-1-i
          }
     }
}
/*第二种。选择排序*/
for(int i=0;i<a.length-1;i++){
     for(int j=i+1;j<a.length;j++){
     if(a[i]>a[j]){
       //看这里，i和j做对比就是选择排序，就是第一个分别和2,3,4,5。作比较，然后就是第二和3,4,5,6比较
      }
   }
}
//一定要区分他们的用法，很多人把他们都给搞乱了。
看一下，，，

Answer 5

import java.util.Arrays;public class BubbleSortDemo {
public static void main(String[] args) {
int[] arr = new int[]{1,2,5,8,0,4,22,7,75};
arr = bubbleSort(arr);
System.out.println(Arrays.toString(arr));
}
public static int[] bubbleSort(int[] a) {
for(int i=0; i<a.length-1; i++) {
for(int j=0; j<a.length-i-1; j++) {
if(a[j]>a[j+1]){
int temp = a[j];
a[j] = a[j+1];
a[j+1] = temp;
}
}
}
return a;
}}

Answer 6

package 包;public class java2 {
public static void main(String[] args) {
int a[]={23,56,8,45,9,14,6,79}; for(int i=0;i<a.length-1;i++){
     for(int j=0;j<a.length-1-i;j++){
     if(a[j]<a[j+1]){
     int bj=a[j];
     a[j]=a[j+1];
     a[j+1]=bj;
     }      }
}
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]+" ");
}

}
}

Answer 7

package 包;
//选择排序实例：
public class java2 {
public static void main(String[] args) {
int a[]={23,56,8,45,9,14,6,79}; for(int i=0;i< a.length-1;i++){
     for(int j=i+1;j<a.length;j++){
     if(a[i]>a[j]){
     int bj=a[i];
     a[i]=a[j];
     a[j]=bj;
     }      }
}
for (int i = 0; i < a.length; i++) {
System.out.println(a[i]+" ");
}

}
}

Answer 8

楼主纠结的是 int [] a={1,5,63,646,46,413,1};  前后两个 1 为啥排完了 少了个一

Answer 9

因为楼主从int = 1;开始遍历输出哪门子的习惯
for(int i=1;i<a.length;i++){
  System.out.println(a[i]);}

Answer 10

for(int i=1;i<a.length;i++){
  System.out.println(a[i]);
}
i应该从0开始取值,因为数组下标就是从0开始的!其他地方没问题,思路很正确!

Answer 11

你这只能算半个 选择排序吧，和冒泡泡不沾边吧，而且第一个for循环i<a.length-1就好了，第二个for循环j=i+1就好了

Answer 12

for (int i = 0; i < number.length; i++) {
for (int j = 0; j < i; j++) {
if (number[i] < number[j]) {
temp = number[i];
number[i] = number[j];
number[j] = temp;
}
}
}

Answer 13

冒泡排序里的j应该从0开始吧，而不是从i+1开始吧没有~~~~看书。。如果是他这样写，就要从0开始，给你看两个版本
版本1:for(int i=0;i<data.length;i++){
          for(int j=data.length-1;j>i;j--){
}
}
版本2：for(int i=0;i<data.length;i++){
      for(int j=0;j<data.length-1-i;j++)
}
如果不信你可以自己测试一下，版本2,j从i+1开始是不行的

Answer 14

冒泡排序里的j应该从0开始吧，而不是从i+1开始吧没有~~~~看书。。如果是他这样写，就要从0开始，给你看两个版本
版本1:for(int i=0;i<data.length;i++){
          for(int j=data.length-1;j>i;j--){
}
}
版本2：for(int i=0;i<data.length;i++){
      for(int j=0;j<data.length-1-i;j++)
}
如果不信你可以自己测试一下，版本2,j从i+1开始是不行的你没看懂他的意思吧，他说的第二种是选择排序~~~不过他的选择排序好像是有点问题  你看我的blog第一个关于选择排序，冒泡排序没有写~~~~http://blog.csdn.net/jackwang_378/article/details/8823318

Answer 15

你这只能算半个 选择排序吧，和冒泡泡不沾边吧，而且第一个for循环i<a.length-1就好了，第二个for循环j=i+1就好了
嗯，直接在LZ基础上改的，那个i+1确实错了。
那个，请你写个典型沾边的冒泡给大家看看吧？

Answer 16

冒泡排序的主要思想就是，相邻的两两比较，轻的（小的数）上浮，当然有可能遇到正序或反序的情况，为了避免这种情况可以使用交替改变扫描方向，写了一个简单的单向扫描的
class bubbleSort{
public static  void main(String [] args) {
int [] arrs={12,334,23,42134,12,354,342,234,53,342};
int i,j,temp;
for(i=0;i<arrs.length-1;i++) {
for(j=arrs.length-1;j>i;j--) {
if(arrs[j]<arrs[j-1])  {
temp=arrs[j];
arrs[j]=arrs[j-1];;
arrs[j-1]=temp;
}
}
} for(int key:arrs) {
System.out.print(key+"->");
}

}
}
要注意不要漏掉，和数组越界的问题

Answer 17

你这只能算半个 选择排序吧，和冒泡泡不沾边吧，而且第一个for循环i<a.length-1就好了，第二个for循环j=i+1就好了
嗯，直接在LZ基础上改的，那个i+1确实错了。
那个，请你写个典型沾边的冒泡给大家看看吧？package com.sisj.Test;public class BubbleSort {
public static void main(String[] args) {
int[] testArray = {1,3,5,7,9,1,3,555,666,1000,4,0,-10 };
sort(testArray);
for (int arr : testArray) {
System.out.print(arr + " ");
}
} public static void sort(int[] a) {
int temp = 0;
for (int i = a.length - 1; i > 0; --i) {
for (int j = 0; j < i; ++j) {
if (a[j + 1] < a[j]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
}

Answer 18

冒泡排序里的j应该从0开始吧，而不是从i+1开始吧没有~~~~看书。。如果是他这样写，就要从0开始，给你看两个版本
版本1:for(int i=0;i<data.length;i++){
          for(int j=data.length-1;j>i;j--){
}
}
版本2：for(int i=0;i<data.length;i++){
      for(int j=0;j<data.length-1-i;j++)
}
如果不信你可以自己测试一下，版本2,j从i+1开始是不行的你没看懂他的意思吧，他说的第二种是选择排序~~~不过他的选择排序好像是有点问题  你看我的blog第一个关于选择排序，冒泡排序没有写~~~~http://blog.csdn.net/jackwang_378/article/details/8823318他的冒泡排序的i从1开始了 

Answer 19

冒泡排序里的j应该从0开始吧，而不是从i+1开始吧没有~~~~看书。。如果是他这样写，就要从0开始，给你看两个版本
版本1:for(int i=0;i<data.length;i++){
          for(int j=data.length-1;j>i;j--){
}
}
版本2：for(int i=0;i<data.length;i++){
      for(int j=0;j<data.length-1-i;j++)
}
如果不信你可以自己测试一下，版本2,j从i+1开始是不行的你没看懂他的意思吧，他说的第二种是选择排序~~~不过他的选择排序好像是有点问题  你看我的blog第一个关于选择排序，冒泡排序没有写~~~~http://blog.csdn.net/jackwang_378/article/details/8823318他的冒泡排序的i从1开始了 额，没注意看下边，确实～修改一下就行了～

Answer 20

import java.util.Arrays;import java.util.Arrays;
public class testone {/**
 * @param args
 */
public static void main(String[] args) {
int [] a={1,5,63,646,46,413,1}; 
Arrays.sort(a);
  System.out.println("升序排序:");
    for(int i=0;i<a.length;i++){
      for(int j=0;j<a.length-1-i;j++){
       if(a[j]>a[j+1]){
        int temp=a[j];        
        a[j]=a[j+1];
        a[j+1]=temp;
        }      
       
      } 
      
    }   
  
  
for(int i=1;i<a.length;i++){
  System.out.println(a[i]);}
}}
======================================
你的外层循环多了一次，外层循环应该是：
for(int i=0;i<a.length-1;i++){

Answer 21

你这只能算半个 选择排序吧，和冒泡泡不沾边吧，而且第一个for循环i<a.length-1就好了，第二个for循环j=i+1就好了
嗯，直接在LZ基础上改的，那个i+1确实错了。
那个，请你写个典型沾边的冒泡给大家看看吧？package com.sisj.Test;public class BubbleSort {
public static void main(String[] args) {
int[] testArray = {1,3,5,7,9,1,3,555,666,1000,4,0,-10 };
sort(testArray);
for (int arr : testArray) {
System.out.print(arr + " ");
}
} public static void sort(int[] a) {
int temp = 0;
for (int i = a.length - 1; i > 0; --i) {
for (int j = 0; j < i; ++j) {
if (a[j + 1] < a[j]) {
temp = a[j];
a[j] = a[j + 1];
a[j + 1] = temp;
}
}
}
}
}你是对的，一直理解错了，多谢指教~