Question

我试图在leetcode上每天做一个编程问题来改进我的编程，并且在下面的问题中添加到LinkedList时遇到问题。我想知道是否有人能给我一些指示。我知道我的回答并不是最有效的，我只是想从某个地方开始并努力工作。方法中的所有内容都是我到目前为止所做的。我真的很感激任何帮助。

///

您将获得两个非空链表，表示两个非负整数。数字以相反的顺序存储，每个节点包含一个数字。添加两个数字并将其作为链接列表返回。

这是一张带有可能输出示例的图片： https://imgur.com/a/g9rlb

您可以假设这两个数字不包含任何前导零，除了数字0本身。

/**
* Definition for singly-linked list.
* public class ListNode {
*     int val;
*     ListNode next;
*     ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {

    ListNode l3 = new ListNode(-1);
    ListNode curr = new ListNode(-1);
    ListNode newNode = new ListNode(-1);

 // Take numbers from linkedList and store in strings
    String s1 = "";
    String s2 = "";
// String values after being reveresed in the right direction.
    String sR1 = "";
    String sR2 = "";

    while(l1 != null) {

        s1 += l1.val;
        l1 = l1.next;
    }
    while(l2 != null) {

        s2 += l2.val;
        l2 = l2.next;
    }

    //check
    System.out.println(s1);
    System.out.println(s2);

    //reverse the string;

    for(int i = s1.length()-1; i >= 0; i--) {

        sR1 += s1.charAt(i);
    }
      for(int j = s2.length()-1; j >= 0; j--) {

        sR2 += s2.charAt(j);
    }

//Adding the numbers together to get the final value.
    int n3 = Integer.parseInt(sR1) + Integer.parseInt(sR2);
//Converting ints to string so i can parse them into characters that will eventually be parsed into an int to return back to the LinkedList
    String fin = Integer.toString(n3);
    System.out.println(fin);


//adding the values to my final linked list that i'd be returning here.       This is the part that isn't working.
    for(int i = 0; i < fin.length()-1; i++){

    String s = String.valueOf(fin.charAt(i)); 

       int num = Integer.parseInt(s);

        newNode = new ListNode(num);

        if(l3.val == -1) {

            l3 = newNode;
        }
        else {
            curr = l3;

            while(curr.next != null){
                curr = curr.next;
            }
            curr.val = num;
        }

    }
    return l3;
}

Answer 1

也许是这样的？这里的概念是直截了当的。要求是反转节点并添加它们。这意味着您只需要选择正确的数据结构来满足此要求，这为您提供了最后一次出局？堆。现在您已经拥有堆栈中的数据，只需从堆栈中弹出项目并将其添加并获得预期结果。有许多方法可以解决这个问题，使用ArrayList，使用LinkedList或普通的旧数组，但尝试将问题与已知的数据结构相关联，并以这种方式解决它将为您提供一致的有意义的输出。我本可以向您指出这个概念，但是使用此代码可以帮助您思考如何根据用户需求解决特定问题。干杯，希望它有所帮助。

import java.util.Scanner;
import java.util.Stack;

public class AddTuple {
    public static void main(String[] args) {
        Stack<Integer> leftTuple = new Stack<Integer>();
        Stack<Integer> rightTuple = new Stack<Integer>();

        populateTuple(leftTuple, rightTuple, 3);
        Stack<Integer> result = addTuples(leftTuple, rightTuple);
        System.out.print("Output: {");
        int i = 0;
        while (!result.isEmpty()) {
            if (i != 0) {
                System.out.print(", ");
            }
            System.out.print(result.pop());
            i++;
        }
        System.out.println("}");
    }

    private static void populateTuple(Stack<Integer> leftTuple, Stack<Integer> rightTuple, int count) {
        Scanner scanner = new Scanner(System.in);
        try {
            System.out.print("Input: ");
            String input = scanner.nextLine();
            if (input == null || !input.contains("+") || !input.contains("{")) {
                throw new RuntimeException("Usage: {x,y,z} + {a,b,c}");
            }
            String[] operandSplit = input.split("\\+");
            String left = operandSplit[0].trim();
            String right = operandSplit[1].trim();
            left = left.replaceAll("\\{", "");
            left = left.replaceAll("\\}", "");
            right = right.replaceAll("\\{", "");
            right = right.replaceAll("\\}", "");

            String[] leftSplit = left.split(",");
            String[] rightSplit = right.split(",");

            for (int i = 0; i < leftSplit.length; i++) {
                leftTuple.push(Integer.parseInt(leftSplit[i].trim()));
            }

            for (int i = 0; i < rightSplit.length; i++) {
                rightTuple.push(Integer.parseInt(rightSplit[i].trim()));
            }
        } finally {
            scanner.close();
        }
    }

    private static Stack<Integer> addTuples(Stack<Integer> leftTuple, Stack<Integer> rightTuple) {
        Stack<Integer> result = new Stack<Integer>();
        int carryForward = 0;
        while (!leftTuple.isEmpty()) {
            int addition = leftTuple.pop() + rightTuple.pop() + carryForward;
            if (addition > 9) {
                carryForward = 1;
                addition = 10 - addition;
            }
            result.push(addition);
        }
        return result;
    }
}

将值添加到LinkedList不起作用

1 个答案: