Question

分数类：

public class Fraction 
{
    private int numerator;
    private int denominator;

    public Fraction()
    {
        numerator = 0;
        denominator = 1;
    }

    public Fraction(int numerator)
    {
        this.numerator = numerator;
        denominator = 1;
    }

    public Fraction(int numerator, int denominator)
    {   
        this.numerator = numerator;
        this.denominator = denominator;
    }

    public String toString()
    {
        if(numerator == 0)
        {
            String str = "0";
            return str;
        }
        else if((numerator % denominator) == 0)
        {
            int num = (numerator / denominator);
            String str = "" + num;
            return str;
        }
        else if(numerator > denominator)
        {
            int whole = 0;
            int remainder = numerator;

            while(remainder > denominator)
            {
                remainder -= denominator;
                whole++;
            }

            String str = whole + " " + asFraction(remainder,denominator);
            return str;
        }
        else
        {
            String str = asFraction(numerator,denominator);
            return str;
        }
    }

    public static long GCM(long a, long b) {
        return b == 0 ? a : GCM(b, a % b);
    }

    public static String asFraction(long a, long b) {
        long GCM = GCM(a, b);
        return (a / GCM) + "/" + (b / GCM);
    }

    public int getNumerator() 
    {
        return numerator;
    }

    public void setNumerator(int numerator) 
    {
        this.numerator = numerator;
    }

    public int getDenominator() 
    {
        return denominator;
    }

    public void setDenominator(int denominator) 
    {
        this.denominator = denominator;
    }
}

QuickSort课程：

public class FractionalQuickSort 
{

    private Fraction array[];
    private int length;

    public void sort(Fraction[] inputArr) 
    {   
        if (inputArr == null || inputArr.length == 0) 
        {
            return;
        }
        this.array = inputArr;
        length = inputArr.length;
        fractionalQuickSort(0, length - 1);
    }

    private void fractionalQuickSort(int lowerIndex, int higherIndex) 
    {

        int i = lowerIndex;
        int j = higherIndex;

        Fraction pivot = array[lowerIndex+(higherIndex-lowerIndex)/2];

        while (i <= j) 
        {
            while (compareFractions(array[i], pivot) == false) 
            {
                i++;
            }
            while (compareFractions(pivot, array[j]) == false) 
            {
                j--;
            }
            if (i <= j) 
            {
                exchangeNumbers(i, j);

                i++;
                j--;
            }
        }

        if (lowerIndex < j)
        {
            fractionalQuickSort(lowerIndex, j);
        }
        if (i < higherIndex)
        {
            fractionalQuickSort(i, higherIndex);
        }
    }

    private boolean compareFractions(Fraction a, Fraction b)
    {
        int valueOne = ( a.getNumerator() * b.getDenominator() );
        int valueTwo = ( a.getDenominator() * b.getNumerator() );

        if (valueOne > valueTwo)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

    private void exchangeNumbers(int i, int j) 
    {
        Fraction temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

主：

public class FractionalQuickSortDriver
{
    public static void main(String[]args)
    {

        FractionalQuickSort sorter = new FractionalQuickSort();

        Fraction f1 = new Fraction(0,3);
        Fraction f2 = new Fraction(10,2);
        Fraction f3 = new Fraction(3,4);
        Fraction f4 = new Fraction(12,20);
        Fraction f5 = new Fraction(22,5);
        Fraction f6 = new Fraction(1,6);
        Fraction f7 = new Fraction(3,8);
        Fraction f8 = new Fraction(2,6);

        Fraction[] input = {f1, f2, f3, f4, f5, f6, f7, f8};
        sorter.sort(input);
        for(Fraction i:input)
        {
            System.out.print(i);
            System.out.print(" ");
        }
    }
}

上面是一个快速排序我发现我正在尝试使用我编写的Fraction类来实现。快速排序本身在使用整数时工作正常，我已经用随机输入测试了几次，它显然是由比我聪明的人写的。我正在尝试修改它以使用分数，但在fractionlQuickSort尝试调用自身时遇到堆栈溢出错误。

我输入了一些简单的printline语句来尝试和调试它，并且从我有限的理解（仍在学习）中，索引似乎存在问题。在声明了pivot之后我放置了一个printline语句，并且每一次（直到抛出错误），pivot都会出现相同的值，即1/3。排序算法也重复相同的比较，这告诉我它没有索引到任何地方就陷入循环，或者它正在调用自己不正确。我相信我的compareFractions方法是正确的而不是问题，因为每次比较后的印刷线都证实它正确地完成它们（即0小于1/3，1/6小于1/3，等等）。我现在有点不知所措，因为在尝试并且未能解决我认为过去几个小时的问题之后可能出现的问题。我非常感谢有些人比我更聪明地看着我的代码，并朝着正确的方向推动我。

编辑：不确定为什么会这样，但在发布此问题几分钟后，我对compareFractions方法进行了以下更改，作为最后的努力......

    if (valueOne > valueTwo)
    {
        return true;
    }
    else if (valueOne < valueTwo)
    {
        return false;
    }
    else if (valueOne == valueTwo)
    {
        return true;
    } 
    else
    {
        return false;
    }

...程序现在工作正常，作为额外的奖励，数组实际上按顺序排序。如果我说我知道为什么修复它，我会撒谎，所以我仍然会感谢有人解释我的代码发生了什么。

修改QuickSort以使用Fraction类，遇到StackOverFlow错误

0 个答案: