Question

我想使用Java中的堆栈实现检查字符串是否回文。我已经尝试了很多方法，但是并没有得到正确的答案。有人可以帮我吗？

我在我的课程中实现了一个Stack，其变量名称为“ stackArray”。

回文法：

Stack s1 = new Stack(5);

for (int i = 0; i < 5; i++) {
    s1.push(stackArray[i]);
}

String [] reverser = new String[5];

while (!s1.isEmpty()) {
    int count = 0;
    reverser[count] = s1.pop();
    count++;
}

if (s1.equals(reverser)){
    System.out.println("The input String is a palindrome.");
}
else
    System.out.println("The input String is not a palindrome.");

驱动程序代码：

public static void main(String[] args) throws Exception { 

        Stack st = new Stack(5);

        st.push("l");
        st.push("e");
        st.push("v");
        st.push("e");
        st.push("l");
        System.out.println("");
        System.out.println("When Palindromic is starting; ");
        System.out.println("");
        st.palindromic();
}

“ level”一词很明显是回文，但总是说“输入的字符串不是回文”。

Answer 1

解决方案至少存在两个基本问题：

您正在弹出s1，直到它为空，然后进行回文检查
s1和反向器的数据类型不同

1）暂时忽略项目符号2，当您使用s1确定输入是否为回文时，它似乎为空。您需要确保进行等效检查时，两个变量都指向其中包含数据的结构！

2）s1是一个堆栈，反向器是一个String []。堆栈中“等于”的默认实现是检查参数是否为堆栈的实例。由于永远不会这样，因此您将始终看到“输入的字符串不是回文”。

要修复2），您需要使两个对象具有相同的数据类型（Stack或String []）。如果选择后一个String []，则需要验证每个索引i的字符串在s1和reverser中是否相等。

希望这会有所帮助！

Answer 2

在您的堆栈类中检查equals方法的实现，因为未发布实现很难发现问题。但是，相反，如果您不需要这样做，则可以使用相同的方法进行比较。记住要使用相同的数据类型。例如，将数组和堆栈强制转换为字符串。然后使用字符串类的equals方法。

String original = "level"; //The contents of you stack dumped into a String
String[] reversedArr = {"l", "e", "v", "e", "l"}; //And your array reverser

String reversed = "";

for (String letter : reversedArr)
    reversed = reversed.concat(letter);

System.out.println(original.equals(reversed));

Answer 3

二十年不使用Java后，我正在重新学习它。这是我对您的主要帖子的先前评论的实现。我的堆栈基于OOP，而不是使用内部数组：

public class Palindrome {

    public static void main(String[] args)
    {
        java.util.Scanner keyboard = new java.util.Scanner(System.in);
        System.out.print("Enter the word to check: ");
        String input = keyboard.nextLine();
        Palindrome p = new Palindrome(input);
        System.out.println("Input: " + p.getInput());
        System.out.println("Reversed: " + p.getInputReversed());
        System.out.println("Palindromic: " + p.isPalindromic());
    }

    private String _input;

    public Palindrome(String input)
    {
        _input = input.toLowerCase();
    }

    public String getInput()
    {
        return _input;
    }

    public String getInputReversed()
    {
        CharStack chars = new CharStack(getInput());    
        String reversed = "";
        while(!chars.empty())
        {
            try {
                reversed = reversed + chars.pop();
            } catch (Exception e) {
                System.out.println("Exception: " + e.getMessage());
            }
        }
        return reversed;
    }

    public boolean isPalindromic()
    {
        return getInput().equals(getInputReversed());
    }

    private class CharStack
    {

        private CharStackNode top = null;

        private class CharStackNode
        {
            public char c;
            public CharStackNode next = null;

            public CharStackNode(char inC, CharStackNode top)
            {
                c = inC;
                next = top;
            }
        }

        public CharStack(String input)
        {
            for(char c: input.toCharArray())
            {
                push(c);
            }
        }

        public void push(char c)
        {
            top = new CharStackNode(c, top);;
        }

        public char pop() throws Exception
        {
            if (!empty())
            {
                char c = top.c;
                top = top.next;
                return c;
            }
            else
            {
                throw new Exception("Cannot pop() an empty stack!");
            }
        }

        public boolean empty()
        {
            return top == null;
        }

    }

}

Answer 4

public static void main(String[] args) { 

    String str ="word";
    if(str.equals(reverse(str))) {
          System.out.println("Word is Palindromic ");
    }else {
          System.out.println("Word is Not Palindromic ");
    }
}


public static String reverse(String str) {
    char[] charArr = str.toCharArray();
    int size = charArr.length;
    Stack stack = new Stack(size);

    int i;
    for(i = 0; i < size; ++i) {
        stack.push(charArr[i]);
    }

    for(i = 0; i < size; ++i) {
        charArr[i] = stack.pop();
    }

    return String.valueOf(charArr);
}

使用堆栈检查字符串是否回文

4 个答案: