Question

请不要让这篇文章的长度吓到你！好的，这是我目前正在进行的提示：

＆＃34;编写一个名为BucketSort的类，其中包含一个名为sort的方法：

a）根据值的“ones”（最右边）数字，将一维数组的每个值放入bucket数组的一行。例如，97放置在行7中，3放置在行3中，100放置在行0中。该过程称为分发通道。

b）逐行循环遍历bucket数组，并将值复制回原始数组。此过程称为收集过程。一维数组中前面值的新顺序是100,3和97.

c）对每个后续数字位置（数十，数百，数千等）重复此过程。在第二个（十位数）传递中，100位于第0行，3位于第0行（因为3没有在聚集传递之后，一维数组中的值的顺序是100,3和97.在第三（数百位）传递中，100被放置在第1行中，数十个数字）和97被放置在第9行中。 3位于第0行，97位于第0行（3之后）在最后一次聚集传递之后，原始数组按排序顺序排列。被分类。

这种排序技术提供了比冒泡排序更好的性能，但需要更多的内存 - 冒泡排序只需要一个额外的数据元素空间。此比较是空间/时间权衡的一个示例：存储桶排序使用的内存多于冒泡排序，但性能更好。此版本的存储桶排序需要在每次传递时将所有数据复制回原始数组。另一种可能性是创建第二个二维桶阵列并在两个桶阵列之间重复交换数据。桶的二维数组是整数数组＆＃34;

长度的10倍

我知道有点满口。下面是我的代码到目前为止，但我无法弄清楚为什么它不会按照正确的顺序打印，我认为现在是新鲜眼睛的时间。感谢任何想法，谢谢！

import java.util.Arrays;

public class BucketSort_main {

public static void main(String[] args) 
{  
    int[] numbers = new int [5]; 
    int[] tnumbers = new int [500]; 
    int [][] bucket = new int [10][numbers.length]; 
    int [] a = new int [10]; 
    int count = 0;
    int divisor = 1; 
    int cnt = 1; 
    boolean moreDigits = true; 




    for (int s = 0; s < 10; s++)
        {
            a[s] = 0; 
        }

    for (int b = 0; b < numbers.length; b++) 
    { 
        numbers [b] = (int)(Math.random()*2000); 
        tnumbers [b] = numbers [b]; 
    } 

    int[] tmpSort = new int[10]; 


    while (moreDigits)         
    { 
          moreDigits = false; 
          for (int i = 0; i < tmpSort.length; i++) 
          { 
              tmpSort[i]= -1;  // hint hint 
          } 
          for (int i = 0; i < numbers.length; i++) 
          { 
            int tmp = tnumbers[i] / divisor; 

            if (tmp/10 != 0)
                {
                    moreDigits = true; 
                }

            int digit = tmp % 10; 

            tmpSort[digit] = tnumbers[i];  // hint hint 

            System.out.println("Number["+i+"], Digit "+cnt+" is "+digit + ". Full number = " + tnumbers[i]); 

            bucket [digit][a[digit]] = tnumbers[i]; 

            System.out.println ("Digit " + digit + " going to slot " + a[digit] + ". " + bucket[digit][a[digit]]); 
            System.out.println (" "); 

            a[digit]++; 

        }     
        cnt++; 
        divisor *= 10; 

        for (int x = 0; x < 10; x++) 
        { 
            a [x] = 0; 
            for (int y = 0; y < numbers.length; y++) 
            { 
                if (bucket[x][y] != 0) 
                { 
                    tnumbers [y] = 0; 
                    tnumbers [y] = bucket[x][y]; 
                    bucket[x][y] = 0; 
                }                     
            }  
        }  
     }     

            for (int o = 0; o < numbers.length; o++) 
            { 
                System.out.println (tnumbers[o]); 
            }

        } 
 }

Answer 1

问题在于：

for (int x = 0; x < 10; x++) 
        { 
            a [x] = 0; 
            for (int y = 0; y < numbers.length; y++) 
            { 
                if (bucket[x][y] != 0) 
                { 
                    tnumbers [y] = 0; 
                    tnumbers [y] = bucket[x][y]; 
                    bucket[x][y] = 0; 
                }                     
            }  
        }

您使用相同的y从存储区中获取值并将值分配给tnumbers。因此，当您第二次在y，tnumbers[0]等处重新开始tnumbers[1]循环时...

修复此问题，您的代码运行正常。

2D桶排序问题

1 个答案: