Question

我已经完成了它，但是最后一个Array，Sorted C方法输出了这个：

SORTED C METHOD: 179, 181, 238, 190, 105, 144, 26, 63, 90, 14, SORTED C METHOD: 190, 238, 181, 179, 105, 144, 26, 63, 90, 14, SORTED C METHOD: 238, 190, 181, 179, 105, 144, 26, 63, 90, 14,

为什么在Sorted A Method和Sorted B Method只输出一次出现时重复这么多次？以下是代码：

主类：

import java.util.ArrayList;
import java.util.Random;

public class main {
    public static void main(String[] args) {
        ThreeSorts.SortA(randArray(0));
        System.out.println("\n");
        ThreeSorts.SortB(randArray(0));
        System.out.println("\n");
        ThreeSorts.SortC(randArray(0));
        System.out.println("\n");
    }
    public static ArrayList<Integer> randArray(int n) {
        ArrayList<Integer> a = new ArrayList<Integer>(n);
        Random rand = new Random();
        rand.setSeed(System.currentTimeMillis());

        int[] x = new int[10];
        for (int i = 0; i < x.length; i++) {
            Integer r = Math.abs(rand.nextInt() % 256);
            a.add(r);
        }
        showArray(a);
        return a;
    }

    public static void showArray(ArrayList<Integer> a) {
        int n = a.size();
        System.out.println("RANDOM NUMBERS GENERATED 0 TO 255:");
        for (int i = 0; i < n; i++) {
            int r = a.get(i);
            System.out.print("|" + r + "| ");
        }
        System.out.println("\n");
    }

    public static void showA(ArrayList<Integer> array) {
        int n = array.size();
        System.out.print("SORTED A METHOD: ");
        for (int i = 0; i < n; i++) {
            int r = array.get(i);
            System.out.print(r + ", ");
        }
    }

    public static void showB(ArrayList<Integer> array) {
        int n = array.size();
        System.out.print("SORTED B METHOD: ");
        for (int i = 0; i < n; i++) {
            int r = array.get(i);
            System.out.print(r + ", ");
        }
    }

    public static void showC(ArrayList<Integer> array) {
        int n = array.size();

        System.out.print("SORTED C METHOD: ");
        for (int i = 0; i < n; i++) {
            int r = array.get(i);
            System.out.print(r + ", ");
        }
    }
}

排序数组：

import java.util.*;

pubic class ThreeSorts {
    private static ArrayList<Integer> CopyArray(ArrayList<Integer> a) {
        ArrayList<Integer> resa = new ArrayList<Integer>(a.size());
        for (int i = 0; i < a.size(); ++i) {
            resa.add(a.get(i));
        }
        return (resa);
    }

    public static ArrayList<Integer> SortA(ArrayList<Integer> a) {
        ArrayList<Integer> array = CopyArray(a);
        int n = a.size(), i;
        boolean noswaps = false;

        while (noswaps == false) {
            noswaps = true;
            for (i = 0; i < n - 1; ++i) {
                if (array.get(i) < array.get(i + 1)) {
                    Integer temp = array.get(i);
                    array.set(i, array.get(i + 1));
                    array.set(i + 1, temp);
                    noswaps = false;
                }
            }
        }
        main.showA(array);
        return (array);

    }

    public static ArrayList<Integer> SortB(ArrayList<Integer> a) {
        ArrayList<Integer> array = CopyArray(a);
        Integer[] zero = new Integer[a.size()];
        Integer[] one = new Integer[a.size()];
        int i, b;
        Integer x, p;
        // Change from 8 to 32 for whole integers - will run 4 times slower
        for (b = 0; b < 8; ++b) {
            int zc = 0;
            int oc = 0;
            for (i = 0; i < array.size(); ++i) {
                x = array.get(i);
                p = 1 << b;
                if ((x & p) == 0) {
                    zero[zc++] = array.get(i);
                } else {
                    one[oc++] = array.get(i);
                }
            }
            for (i = 0; i < oc; ++i)
                array.set(i, one[i]);
            for (i = 0; i < zc; ++i)
                array.set(i + oc, zero[i]);
        }
        main.showB(array);
        return (array);
    }

    public static ArrayList<Integer> SortC(ArrayList<Integer> a) {
        ArrayList<Integer> array = CopyArray(a);
        SortC(array, 0, array.size() - 1);
        return (array);
    }

    public static void SortC(ArrayList<Integer> array, int first, int last) {
        if (first < last) {
            int pivot = PivotList(array, first, last);
            SortC(array, first, pivot - 1);
            SortC(array, pivot + 1, last);
        }

    }

    private static void Swap(ArrayList<Integer> array, int a, int b) {
        Integer temp = array.get(a);
        array.set(a, array.get(b));
        array.set(b, temp);
    }

    private static int PivotList(ArrayList<Integer> array, int first, int last) {
        Integer PivotValue = array.get(first);
        int PivotPoint = first;
        for (int index = first + 1; index <= last; ++index) {
            if (array.get(index) > PivotValue) {
                PivotPoint = PivotPoint + 1;
                Swap(array, PivotPoint, index);
            }
        }
        main.showC(array);
        Swap(array, first, PivotPoint);
        return (PivotPoint);
    }
}

P.S。我正在使用Eclipse Java

Answer 1

你的showC方法调用是个问题。试试这个：

    public static void SortC(ArrayList<Integer> array, int first, int last) {
    if (first < last) {
        int pivot = PivotList(array, first, last);
        SortC(array, first, pivot - 1);
        SortC(array, pivot + 1, last);
    }
    main.showC(array)//this method has to be called only when your array has been sorted
    }

您的代码存在的问题是，每次找到新的支点时，您都在打印数组。希望这有助于...快乐编码

Answer 2

关于你的public static void SortC(ArrayList<Integer> array,int first,int last) 方法。由于Recursion，它会被多次调用。

但是，如果您希望以错误的方式将权利输出，那么下面的代码行将对您有所帮助。内部class ThreeSorts定义了一个变量，例如

public static boolean isPrinted;

并按照下面的说明更新您的PivotList（）方法，或者只是复制它可以使用的任何粘贴。

private static int PivotList(ArrayList<Integer> array, int first, int last) {
        Integer PivotValue = array.get(first);
        int PivotPoint = first;
        for (int index = first + 1; index <= last; ++index) {
            if (array.get(index) > PivotValue) {
                PivotPoint = PivotPoint + 1;
                Swap(array, PivotPoint, index);
            }
        }
        if (!isPrinted) {
            Main.showC(array);
            isPrinted = true;
        }
        //Main.showC(array);
        Swap(array, first, PivotPoint);
        return (PivotPoint);
    }

Answer 3

可能是因为SortC被调用了3次吗？

public static void SortC(ArrayList<Integer> array,int first,int last){
    if (first < last) {
        int pivot = PivotList(array,first,last);
        SortC(array,first,pivot-1);
        SortC(array,pivot+1,last);
     } 
}

SortC()来电PivotList()
PivotList()来电showC()
showC()打印到SystemOut

我会更新您的主SortC方法来执行打印，而不是递归方法：

public static ArrayList<Integer> SortC(ArrayList<Integer> a) {
    ArrayList<Integer> array = CopyArray(a);
    SortC(array, 0, array.size() - 1);
    main.showC(array) // print only when finished sorting!
    return (array);
}

Answer 4

正如我所说，束11给出了正确答案，确实是因为你在你的算法中使用ShowC多次调用它。

但这只是症状而不是潜在的问题。这里的问题是你在算法函数（SortedArray类）和实用函数（主类）之间创建了不必要的耦合。

换句话说，您的SortedArrays类不应该依赖于任何东西的主类，因此SortedArrays类中的任何内容都不应该在main中调用任何东西。

如果通过调用main函数中的show函数对代码进行非常简单的调整，并在SortedArrays类中删除它们中的任何一个，那么代码将只显示一次。

像这样：

public static void main(String[] args) {
        showA(ThreeSorts.SortA(randArray(0)));
        System.out.println("\n");
        showB(ThreeSorts.SortB(randArray(0)));
        System.out.println("\n");
        showC(ThreeSorts.SortC(randArray(0)));
        System.out.println("\n");
    }

然后从其他类中删除任何main.showXXX。这假设每个sort函数都返回数组。

这样每个班级都有一个目的，让一切都更容易理解。混合目的（排序和显示）在同一个函数（或面向对象的同一个类）中经常会产生副作用。

最后我没有尝试查看算法是否正确，我只是专注于你的代码结构。有可能还有其他错误，那么，这是一个我不能为你完成所有工作的作业:-)那说你似乎做得很好，所以我不太担心。

为什么我的输出重复了？

4 个答案: