Question

在这里，我试图通过使用堆栈和队列来确定单词或短语是否是回文，具体取决于我写的短语。

它所做的是它说所有东西都是回文并且写着＆＃34; Palindrome＆＃34;它有多少个字母。

我猜我需要在最后一个for循环和while循环之间添加一些东西，但我不确定是什么。

public class CheckPalindrome {

public static void main(String[] args) throws IOException {
    BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

    while (true) {

        String line = reader.readLine();


        if (line.toLowerCase().equals("quit")) {
            break;
        }

        Stack<Character> stack = new Stack<Character>();

        Queue<Character> queue = new LinkedList<Character>();

         for (int i = 0; i < line.length(); i++) {
                stack.push(line.charAt(i));
            }

         for (int i = line.length() - 1; i >= 0; i--) {
             queue.add(line.charAt(i));
         }

          while (!queue.isEmpty()) {
             if (queue.remove().equals(stack.pop())) {
                 System.out.println("Palindrome");
             } else {
                 System.out.println("Not a Palindrome");
             }
         }

      }     
   }
}

Answer 1

您需要以相同的顺序将字符放入堆栈和队列中的每一个。使用两者的关键是一个反转顺序而另一个不反转。正如你现在所做的那样，在他们中的一个上扭转秩序，否定了这一点。

Answer 2

我做了一些非常小的修改（首先修复你的一个for循环，第二个是防止你的＆＃34; Palindrome / Not a Palindrome＆＃34;消息从输入中的每个字符打印一次）到你的代码让它工作：

import java.util.Stack;
import java.util.LinkedList;
import java.util.Queue;
import java.io.*;
class Palindrome {
    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));

        while (true) {

            String line = reader.readLine();


            if (line.toLowerCase().equals("quit")) {
                break;
            }

            Stack<Character> stack = new Stack<Character>();

            Queue<Character> queue = new LinkedList<Character>();

            for (int i = 0; i < line.length(); i++) {
                stack.push(line.charAt(i));
            }

            for (int i = 0; i < line.length(); i++) {
                queue.add(line.charAt(i));
            }

            boolean isPalindrome=true;
            while (!queue.isEmpty()) {
                if (queue.remove().equals(stack.pop())) {
                    continue;
                } else {
                    isPalindrome=false;
                    break;
                }
            }
            if (!isPalindrome) {
                System.out.println("Not a Palindrome");
            } else {
                System.out.println("Palindrome");
            }

        }     
    }
}

Answer 3

如果感兴趣，可以使用Deque<E>而不是堆叠和队列分别对您的方法进行修改。 Deque只是一个双端队列（即作为两个队列运行）。

public static boolean isPalindrome(String word) {
    boolean isPalindrome = word.length() == 1;
    if (!isPalindrome) {
        Deque<Character> wordDeque = new LinkedList<>();
        for (Character c : word.toCharArray()) {
            wordDeque.add(Character.toLowerCase(c));
        }
        isPalindrome = true;
        while (isPalindrome && wordDeque.size() > 1) {
            isPalindrome = wordDeque.pollFirst().compareTo(wordDeque.pollLast()) == 0;
        }
    }
    return isPalindrome;
}

Answer 4

这是新的解决方案。试试这个。如果有任何修改，请告诉我。程序包堆栈；

public class pallindrome {

Stack<Integer> stack = new Stack<Integer>();
Queue<Integer> queue = new LinkedList<Integer>();

void pushh(int new_Data) {
    stack.push(new_Data);
}

void enquee(int new_Data) {

    queue.add(new_Data);
}

int popStack(){
    return stack.pop();
}

int dequeueQueue() {
    return queue.remove();
}   
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        String input = scan.nextLine();
        scan.close();

        // Convert input String to an array of characters:
        char[] s = input.toCharArray();

        // Create a Solution object:
        pallindrome p = new pallindrome();

        // Enqueue/Push all Integer to their respective data structures:
        for(int i=0;i<input.length();i++)
        {
            p.pushh(i);
            p.enquee(i);
        }
        // Pop/Dequeue the chars at the head of both data structures and compare them:
        boolean isPalindrome = true;
        for ( i = 0; i < s.length/2; i++) {
            if (p.popStack() != p.dequeueQueue()) {
                isPalindrome = false;                
                break;
            }
        }

        //Finally, print whether string s is palindrome or not.
        System.out.println( "The Integer, " + input + ", is " 
                           + ( (!isPalindrome) ? "not a palindrome." : "a palindrome." ) );
    }
}

Answer 5

同时使用堆栈和队列来检查JAVA中的回文

    public class Palindrome {


    public static void main(String[] args) {

        Scanner input = new Scanner(System.in);

        System.out.println("Enter the String:: ");
        String real = input.nextLine();

        Queue q = new LinkedList();
        Stack st = new Stack();


        for(int i=0; i<=real.length()-1; i++) {
            q.add(real.charAt(i));
        }

        for(int i=0; i<real.length(); i++) {
            st.push(real.charAt(i));
        }

        if(q.remove().equals(st.pop())) {
            System.out.println("Palindrom");
        }else {
            System.out.println("Not Palindrom");
        }

    }

}

在java中使用Stack和Queue确定回文结构

5 个答案: