从 java 中的两个链表堆栈中减去数字

Question

最小可重现示例：

    int borrow = 0;
    int valueOne = 2;
    int valueTwo = 5;
    int sub;
    
    if(valueOne > valueTwo) {
        sub = borrow + valueOne - valueTwo;
    } else {
        sub = borrow + valueTwo - valueOne;
    }
    if (sub < 0) {
        borrow = -1;
        sub += 10;
    } else {
        borrow = 0;
    }
    System.out.format("borrow: %d; sub: %d.%n", borrow, sub);

预期输出：

borrow: -1; sub: 7.

观察到的输出：

borrow: 0; sub: 3.

我有两个不使用集合的链表堆栈实现。此方法应该处理任何长度的数字并减去它们。该方法在过程中没有任何借用时有效，但在减法需要借用时无效。当减法需要借用时，我无法理解逻辑！任何帮助

方法在这里

    public static void subtractRoutine(String operndOne, String operndTwo) {
        int sub =0, borrow =0, valueOne, valueTwo;
        pushToLsLeft(padZero(operndOne, operndTwo)[ZERO]);
        pushToLsRight(padZero(operndOne, operndTwo)[ONE]);
//      System.out.println(left);
        left.reverseLinkLsStack();
        right.reverseLinkLsStack();
        while(left.sizeLinkedLs() > ZERO && right.sizeLinkedLs() > ZERO) {
            valueOne = Character.getNumericValue(left.pop());
            valueTwo = Character.getNumericValue(right.pop());
// --------------------------- please, only focus on the logic below. Everything above works fine.
            if(valueOne > valueTwo) {
                sub = borrow + valueOne - valueTwo;
            
                
            } else {
                sub = borrow + valueTwo - valueOne;
//              System.out.println(sub);
            }
            if (sub < 0) {
                borrow = -1;
                sub += 10;
            } else {
                borrow = 0;
            }
//          System.out.println(sub);
            result.push(sub);
        }
    }

如果我输入这个

250 + -150
-250 + 150
120 + -50

输出将是

250
-150
0100

-250
150
-0100

// the problem is here
120
-50
0130

Answer 1

你的问题在这里：

            sub = borrow + valueTwo - valueOne;

在你应该从2中减去5的情况下，这需要我们借用，你正在交换值并从5中减去2。这是错误的，在你的结果中给出了错误的 3，130。也导致我们没有按我们应该的方式借钱。

你根本不需要这个 if-else 语句：

        if(valueOne > valueTwo) {

不管哪个数字大，减法应该是一样的。只有借的部分会根据你一开始是否得到负差而不同

Answer 2

所以基于@Ole V.V。这里的答案是我的问题的有效解决方案。

首先，我有 if 条件，我在其中切换值 1 和 2 的位置。这不是减法的工作原理。我必须将值保持在相同位置。

删除了这个


 if(valueOne > valueTwo) {
                sub = borrow + valueOne - valueTwo;
            
                
            } else {
                sub = borrow + valueTwo - valueOne;

其次，我在开始减法之前反转了堆栈，这导致从左到右开始，但正确的顺序应该是从右到左。

最后，减法顺序不对。我需要先减去数字，然后检查数字是否小于零，这意味着需要借用，然后将借用设置为 -1。完成所有这些后，将堆栈反转为以正确顺序出现的结果。

正确答案

public void subtractRoutine(String operndOne, String operndTwo) {
        int sub =0, borrow =0, valueOne, valueTwo;
        pushToLsLeft(padZero(operndOne, operndTwo)[ZERO]);
        pushToLsRight(padZero(operndOne, operndTwo)[ONE]);
        while(left.sizeLinkedLs() > ZERO && right.sizeLinkedLs() > ZERO) {
            valueOne = Character.getNumericValue(left.pop());
            valueTwo = Character.getNumericValue(right.pop());

            sub = borrow + valueOne - valueTwo;
            if (sub < 0) {
                // when you borrow you need to add 10 
                sub = 10 + valueOne - valueTwo;
                // set borrow to -1 so the number been borrowed from cancelled out
                borrow = -1;
            } else {
                borrow = 0;
            }

            result.push(sub);
        }
        // at the end reverse the numbers in the stack 
        result.reverseLinkLsStack();
    }

从 java 中的两个链表堆栈中减去数字

Subtract numbers from two linked list stack in java

java

linked-list

stack