我需要一些帮助来改进我的代码。我试图使用Radixsort按递增顺序对10个数字（例如）的数组进行排序。
当我使用大小为10的数组运行程序时，将10个随机的int数字放入
70
309
450
279
799
192
586
609
54
657
我明白了：
450
309
192
279
54
192
586
657
54
609
不要在代码中看到我的错误。
class IntQueue
{
static class Hlekkur
{
int tala;
Hlekkur naest;
}
Hlekkur fyrsti;
Hlekkur sidasti;
int n;
public IntQueue()
{
fyrsti = sidasti = null;
}
// First number in queue.
public int first()
{
return fyrsti.tala;
}
public int get()
{
int res = fyrsti.tala;
n--;
if( fyrsti == sidasti )
fyrsti = sidasti = null;
else
fyrsti = fyrsti.naest;
return res;
}
public void put( int i )
{
Hlekkur nyr = new Hlekkur();
n++;
nyr.tala = i;
if( sidasti==null )
f yrsti = sidasti = nyr;
else
{
sidasti.naest = nyr;
sidasti = nyr;
}
}
public int count()
{
return n;
}
public static void radixSort(int [] q, int n, int d){
IntQueue [] queue = new IntQueue[n];
for (int k = 0; k < n; k++){
queue[k] = new IntQueue();
}
for (int i = d-1; i >=0; i--){
for (int j = 0; j < n; j++){
while(queue[j].count() != 0)
{
queue[j].get();
}
}
for (int index = 0; index < n; index++){
// trying to look at one of three digit to sort after.
int v=1;
int digit = (q[index]/v)%10;
v*=10;
queue[digit].put(q[index]);
}
for (int p = 0; p < n; p++){
while(queue[p].count() != 0) {
q[p] = (queue[p].get());
}
}
}
}
}
我也在想我可以把这个函数作为一个队列 参数和返回时队列的顺序递增？如果是这样的话？
请帮忙。对不起，如果我的英语不好，那就不好了。
如果您需要更多详细信息，请告知。
import java.util.Random;
public class RadTest extends IntQueue {
public static void main(String[] args)
{
int [] q = new int[10];
Random r = new Random();
int t = 0;
int size = 10;
while(t != size)
{
q[t] = (r.nextInt(1000));
t++;
}
for(int i = 0; i!= size; i++)
{
System.out.println(q[i]);
}
System.out.println("Radad: \n");
radixSort(q,size,3);
for(int i = 0; i!= size; i++)
{
System.out.println(q[i]);
}
}
}
希望这就是你所说的......
感谢您的回答，我会调查一下。不寻找有人为我解决问题。寻求帮助和想法我如何解决它。
在我的任务中说：
为使用队列排序的整数实现基数排序函数。 该函数应该将一个队列作为 参数和返回时队列应该以升序包含相同的值 order您可以假设值介于0和999之间。
我可以在队列中放置100个int数字并使用radixsort函数对其进行排序，还是需要将数字放入数组中然后使用radixsort函数中的数组使用队列？
我理解它就像我需要在Int队列中放入数字并将该队列放入函数中但是没有用。
但是，谢谢你的答案会看着他们，并尝试解决我的问题。但如果您认为可以提供帮助，请发表评论。
答案 0 :(得分：1)
这适用于我尝试过的测试用例。它没有完整记录，但我认为没关系。我会留给你阅读它，将它与你现在正在做的事情进行比较，并找出为什么你的哲学与我的不同。还有其他一些标记，我以“懒惰”的方式对它们进行了标记，你应该以更好的方式做到这一点。
import java.util.*;
class Radix {
static int[] radixSort(int[] arr) {
// Bucket is only used in this method, so I declare it here
// I'm not 100% sure I recommend doing this in production code
// but it turns out, it's perfectly legal to do!
class Bucket {
private List<Integer> list = new LinkedList<Integer>();
int[] sorted;
public void add(int i) { list.add(i); sorted = null;}
public int[] getSortedArray() {
if(sorted == null) {
sorted = new int[list.size()];
int i = 0;
for(Integer val : list) {
sorted[i++] = val.intValue(); // probably could autobox, oh well
}
Arrays.sort(sorted); // use whatever method you want to sort here...
// Arrays.sort probably isn't allowed
}
return sorted;
}
}
int maxLen = 0;
for(int i : arr) {
if(i < 0) throw new IllegalArgumentException("I don't deal with negative numbers");
int len = numKeys(i);
if(len > maxLen) maxLen = len;
}
Bucket[] buckets = new Bucket[maxLen];
for(int i = 0; i < buckets.length; i++) buckets[i] = new Bucket();
for(int i : arr) buckets[numKeys(i)-1].add(i);
int[] result = new int[arr.length];
int[] posarr = new int[buckets.length]; // all int to 0
for(int i = 0; i < result.length; i++) {
// get the 'best' element, which will be the most appropriate from
// the set of earliest unused elements from each bucket
int best = -1;
int bestpos = -1;
for(int p = 0; p < posarr.length; p++) {
if(posarr[p] == buckets[p].getSortedArray().length) continue;
int oldbest = best;
best = bestOf(best, buckets[p].getSortedArray()[posarr[p]]);
if(best != oldbest) {
bestpos = p;
}
}
posarr[bestpos]++;
result[i] = best;
}
return result;
}
static int bestOf(int a, int b) {
if(a == -1) return b;
// you'll have to write this yourself :)
String as = a+"";
String bs = b+"";
if(as.compareTo(bs) < 0) return a;
return b;
}
static int numKeys(int i) {
if(i < 0) throw new IllegalArgumentException("I don't deal with negative numbers");
if(i == 0) return 1;
//return (i+"").length(); // lame method :}
int len = 0;
while(i > 0) {
len++;
i /= 10;
}
return len;
}
public static void main(String[] args) {
int[] test = {1, 6, 31, 65, 143, 316, 93, 736};
int[] res = radixSort(test);
for(int i : res) System.out.println(i);
}
}
答案 1 :(得分：0)
有一件事看起来很奇怪：
for (int p = 0; p < n; p++){
while(queue[p].count() != 0) {
q[p] = (queue[p].get());
}
}
p应该是q中的索引，范围从0到n-1，还是队列中的0到9？它不太可能同时......
另：
for (int index = 0; index < n; index++){
// trying to look at one of three digit to sort after.
int v=1;
int digit = (q[index]/v)%10;
v*=10;
queue[digit].put(q[index]);
}
为什么你将v乘以10，只是在下一次迭代中用v = 1覆盖它？您是否知道v将永远是一个，因此您将在每次迭代中查看相同的数字？
答案 2 :(得分：0)
嗯，我认为没有几乎没有发布解决方案就能提供帮助（只是给出提示更令人筋疲力尽，我有点累，对不起），所以我只是做一个不错的小模糊测试，这样你就可以测试了你的解决方案听上去怎么样？ ： - ）
如果你正在实施一些算法，那么提出一个好的模糊测试者总是一个好主意。虽然没有100％的确定性，如果它与你的实现运行机会是它会工作（基数排序没有任何奇怪的边缘情况，我知道这只发生极少）
private static void fuzztest() throws Exception{
Random rnd = new Random();
int testcnt = 0;
final int NR_TESTS = 10000;
// Maximum size of array.
final int MAX_DATA_LENGTH = 1000;
// Maximum value allowed for each integer.
final int MAX_SIZE = Integer.MAX_VALUE;
while(testcnt < NR_TESTS){
int len = rnd.nextInt(MAX_DATA_LENGTH) + 1;
Integer[] array = new Integer[len];
Integer[] radix = new Integer[len];
for(int i = 0; i < len; i++){
array[i] = rnd.nextInt(MAX_SIZE);
radix[i] = new Integer(array[i]);
}
Arrays.sort(array);
sort(radix); // use your own sort function here.
for(int i = 0; i < len; i++){
if(array[i].compareTo(radix[i]) != 0){
throw new Exception("Not sorted!");
}
}
System.out.println(testcnt);
testcnt++;
}