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

Question

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

我在我的类中实现了一个堆栈，其变量名为“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();
}

很明显，“级别”这个词是回文，但它总是说“输入字符串不是回文”。

Answer 1

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

1. 您弹出 s1 直到它为空，然后进行回文检查
2. s1和reverser不是同一个数据类型

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

2) s1 是一个堆栈，反向器是一个字符串[]。 Stack 中 'equals' 的默认实现是检查参数是否是 Stack 的实例。由于永远不会出现这种情况，因此您将始终看到“输入字符串不是回文。”。

要修复 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 之后，我正在重新学习 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);
}