冒泡排序算法问题

itpower

本帖最后由小马初长成于 2014-5-1 15:01 编辑

按冒泡排序的算法输出的结果应该是
[1，2，55，151，2，585，151，5155]
可是这个程序执行后的结果是
排序前[1, 2, 55, 585, 151, 2, 5155, 151]
排序后[1, 5155, 2, 55, 151, 2, 585, 151]
哪里出问题了，还是我理解错了？求解

public class List2{
public static void bubbleSort(int[] arr){//冒泡排序
for(int i=0;i<arr.length-1;i++){
for(int j=0;i<arr.length-1;i++){
if(arr[i]>arr[j+1]){
int temp=arr[i];
arr[i]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
public static void main(String[] args){
int[] arr={1,2,55,585,151,2,5155,151};
System.out.print("排序前");
printArray(arr);
bubbleSort(arr);
System.out.print("排序后");
printArray(arr);
}
public static void printArray(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1)
System.out.print(arr[i]+", ");
else
System.out.println(arr[i]+"]");
}
}
}

复制代码

来男. · 来男.

本帖最后由来男. 于 2014-4-27 17:03 编辑

for(int i=0;x<arr.length-1;i++){
for(int j=0;j<arr.length-1-i;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
要-i：就是减少每次的比较元素的意思。

天山 · 天山

public static void bubble_sort(int[] a) {
for (int i = 0; i < a.length - 1; i++)
for (int j = 0; j < a.length - 1; j++) {
if (a[j] > a[j + 1])
swap(a, j, j + 1);
}

要 j 和 j+1 相比较，

曲佳奇 · 曲佳奇

本帖最后由曲佳奇于 2014-4-27 17:57 编辑

public static void bubbleSort(int[] arr){//冒泡排序
/**************仔细看这里*********/
for(int i=0;i<arr.length-1;i++){
for(int j=0;j<arr.length-i-1;j++){
if(arr[j]>arr[j+1]){
int temp=arr[j];
arr[j]=arr[j+1];
arr[j+1]=temp;
}
}
}
}

复制代码

冒泡排序的主要思想是把相邻的两个元素进行比较楼主记住这点判断语句里面的就不会写错了
至于你的内层循环... 我相信你是不小心...

362688114

循环套循环。
for(int i=0;x<arr.length-1;i++){ //循环的趟数，就是总共循环几趟；
for(int j=0;j<arr.length-1-i;j++){ //每趟循环的次数：次数的规律就是（arr.length-1-i）；
if(arr[j]>arr[j+1]){
   int temp=arr[j];
   arr[j]=arr[j+1];
   arr[j+1]=temp;
}
}

z1342802487 · z1342802487

冒泡排序的过程如下：（从小到大）
比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
public class Test
{
      public static void main(String[] args)
        {
           int[] arr  = {1,2,55,585,151,2,5155,151};
           bubblesort(arr);
           show(arr);
         }
      public static void bubblesort(int[] Arr)
        {
        for(int i = 0;i<Arr.length-1;i++)
        {
        for(int j = 0;j<Arr.length-i-1;j++)//内部循环的下标要比长度小一
        {
        if(Arr[j]>Arr[j+1])
        {
        Arr[j]=Arr[j+1]^Arr[j];//异或，不借助第三方变量，效率提高很多。
        Arr[j+1]=Arr[j+1]^Arr[j];
        Arr[j]=Arr[j+1]^Arr[j];
        }
        }
        }
        }
      public static void show(int[] arr)
        {
        for (int i = 0; i < arr.length; i++)
{
System.out.print(arr[i]+" ");
if ((i+1)%10==0)
{
System.out.print('\n');
}
}
        }
}

evar71 · evar71

本帖最后由 evar71 于 2014-4-27 21:59 编辑

楼主第5行代码：for(int j=0;i<arr.length-1;i++){
请问你的 j 不是恒等于 0 吗亲，你仔细想想哪里错了.
其实你把5.6.7.8.9代码里的 i 都改成j就对了

wyqs92 · wyqs92

public class List2{
public static void bubbleSort(int[] arr){//冒泡排序
for(int i=0;i<arr.length-1;i++){
for(int j=0;i<arr.length-1;i++){//这一行的i应该改为j.然后就是这一行的条件要变成 // arr.length-1-i
if(arr[i]>arr[j+1]){
int temp=arr[i];//i应该是j
arr[i]=arr[j+1];
arr[j+1]=temp;
}
}
}
}
public static void main(String[] args){
int[] arr={1,2,55,585,151,2,5155,151};
System.out.print("排序前");
printArray(arr);
bubbleSort(arr);
System.out.print("排序后");
printArray(arr);
}
public static void printArray(int[] arr){
System.out.print("[");
for(int i=0;i<arr.length;i++){
if(i!=arr.length-1)
System.out.print(arr[i]+", ");
else
System.out.println(arr[i]+"]");
}
}
}

复制代码

蛤蟆太康 · 蛤蟆太康

我分析总结了一下冒泡排序的思想，你参考一下，希望对你有所帮助！
/*冒泡排序
分析：A：外循环控制比较次数，范围是数组元素个数-1次。
   B：内循环范围是arr.length-1-i,因为内循环每比较完一次，会生成一个最大值放在最后面。
（跟冒泡一样，越往后越大）
   C：最大值已经放在了最后面，那么再次内循环遍历的时候只需要遍历前面的元素就可以了，
      所以需要arr.length-1-i。
   D：最后循环内就是元素置换了。
*/
public static void bubbleSort(int[] arr){
for(int i=0;i<arr.length-1;i++){ //外循环
   for(int j=0;j<arr.length-1-i;j++){ //内循环判断条件：j<arr.length-1-i
   if(arr[j]>arr[j+1]){ //判断，大的往后排，置换。
   int temp=arr[j];
               arr[j]=arr[j+1];
               arr[j+1]=temp;
   }
}
}
}

天涯追梦 · 天涯追梦

关于错误，前面几位已经解释很详细了，我就不多说了，下面给你总结下几种常见的简单排序算法吧，希望你能用到
冒泡排序：定义两个for循环，比较相邻元素，前者比后者大就交换相邻元素
*选择排序：定义初始最小项，比较找出最小项，然后进行交换
*插入排序：将一个记录插入到已经排序好的有序表中，从而得到一个新的，记录数增一的有序表。
* 定义两个for循环，以第一个记录为已经排好的有序表，然后逐渐排序后面的记录。

public class Test {
public static void main(String[] args) {
int[] a = { 3, 5, 1, 56, 3, 15, 7, 0, 1 };
System.out.print("原有数组：");
print(a);
xuanZe(a);
System.out.print("选择排序：");
print(a);
maoPao(a);
System.out.print("冒泡排序：");
print(a);
chaRu(a);
System.out.print("插入排序：");
print(a);
}
//插入排序
private static void chaRu(int[] a) {
for (int i = 1; i < a.length; i++) {
for (int j = i; j > 0; j--) {
if (a[j] < a[j - 1]) {
jiaohuan(a, j, j - 1);
}
}
}
}
//打印数组
private static void print(int[] a) {
for (int i : a) {
System.out.print(i + " ");
}
System.out.println();
}
//冒泡排序
private static void maoPao(int[] a) {
for (int i = 0; i < a.length; i++) {
for (int j = i + 1; j < a.length; j++) {
if (a[i] > a[j]) {
jiaohuan(a, i, j);
}
}
}
}
//交换数组元素
private static void jiaohuan(int[] a, int i, int j) {
int temp;
temp = a[i];
a[i] = a[j];
a[j] = temp;
}
//选择排序
private static void xuanZe(int[] a) {
for (int i = 0; i < a.length - 1; i++) {
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[min] > a[j]) {
min = j;
}
}
if (min != i) {
jiaohuan(a, min, i);
}
}
}
}

复制代码

帐号		自动登录	找回密码
密码			加入黑马

冒泡排序算法问题

评分

9 个回复

评分

评分

评分

评分

黑马骑士勋章