Java 检查多个向量是否为回文？

我创建了一个程序，从文件中读取

字符串

，并检查它是否是回文。现在我需要修改它来检查向量是否是回文。我必须创建几个向量并检查它们是否是回文。假设我有以下向量

(1,2,3), (1,1,1), (2,2,2), (2,2,2), (1,1,1), (1,2,3)

程序将使用两个迭代器，并检查第一个迭代器是否等于最后一个，第二个迭代器是否等于第二个迭代器，依此类推。这是我的

字符串

输入程序：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import java.util.Vector;

public class Project4
{
    public static void main(String[] args) throws IOException
    {
        Vector v1 = new Vector(3);
        Vector v2 = new Vector(3);
        Vector v3 = new Vector(3);
        Vector v4 = new Vector(3);
        ArrayList vectors = new ArrayList();
        v1.add(1);
        v1.add(2);
        v1.add(3);
        v2.add(1);
        v2.add(1);
        v2.add(1);
        v3.add(1);
        v3.add(1);
        v3.add(1);
        v4.add(1);
        v4.add(2);
        v4.add(3);
        vectors.add(v1);
        vectors.add(v2);
        vectors.add(v3);
        vectors.add(v4);
        if (isPalindrome(vectors))// If true, it's a palindrome
            System.out.println("That is a palindrome.");
        else // otherwise, it's not
            System.out.println("That is not a palindrome.");

    }
    public static boolean isPalindrome(ArrayList vectors)
    {
        // Make a new queue, stack, and character object
        Queue<Vector> q = new LinkedList<>();
        Stack<Vector> s = new Stack<>();
        for(int i = 0; i < vectors.size(); i++){
            q.add((Vector) vectors.get(i));
            s.add((Vector) vectors.get(i));
        }
        Vector temp = new Vector();
        int mismatches = 0;
        for (int i = 0; i < vectors.size(); i++)
        {
            temp = (Vector) vectors.get(i);
            if (vectors.get(i).equals(vectors.get(i)))
            {
                q.add(temp);
                s.push(temp);
            }
        }

        while (!q.isEmpty())
        {
            if (q.remove() != s.pop())
                mismatches++; // Increment "mismatches" if q != s
        }

        return (mismatches == 0); // will return true if the method did not change the variable "mismatches"
    }
}

导入java.io.BufferedReader；
导入java.io.FileReader；
导入java.io.IOException；
导入java.util.ArrayList；
导入java.util.LinkedList；
导入java.util.Queue；
导入java.util.Stack；
导入java.util.Vector；
公共类项目4
{
公共静态void main（字符串[]args）引发IOException
{
向量v1=新向量（3）；
矢量v2=新矢量（3）；
向量v3=新向量（3）；
向量v4=新向量（3）；
ArrayList向量=新的ArrayList（）；
v1.加入（1）；
v1.加入（2）；
v1.加入（3）；
v2.增加（1）；
v2.增加（1）；
v2.增加（1）；
v3.增加（1）；
v3.增加（1）；
v3.增加（1）；
v4.添加（1）；
v4.添加（2）；
v4.添加（3）；
向量。添加（v1）；
向量。添加（v2）；
矢量。添加（v3）；
矢量。添加（v4）；
if（isAlindrome（vectors））//如果为真，则为回文
System.out.println（“这是一个回文”）；
否则，就不是了
System.out.println（“这不是回文”）；
}
公共静态布尔值isAlindrome（ArrayList向量）
{
//创建新队列、堆栈和角色对象
队列q=新的LinkedList（）；
堆栈s=新堆栈（）；
对于（int i=0；i

尝试以下方法（非常简单）。阅读代码中的注释以了解其工作原理

代码：

public static void main(String[] args)
{
    int[] a = { 1, 2, 3 };
    int[] b = { 1, 2, 1 };
    int[] c = { 1, 2, 2, 1 };
    int[] d = { 1, 2, 3, 1 };
    int[] e = { 1 };
    System.out.println(is_palindrome(a));
    System.out.println(is_palindrome(b));
    System.out.println(is_palindrome(c));
    System.out.println(is_palindrome(d));
    System.out.println(is_palindrome(e));

}

public static boolean is_palindrome(int[] arr)
{
    for (int i = 0; i < arr.length / 2; i++) { // Check just half times the size of 'arr'
        // System.out.println(arr[i] + " - " + arr[arr.length - i - 1]); // Debug
        if (arr[i] != arr[arr.length - i - 1]) // Check 'first' with 'last', 'second' with 'last - 1' ...
            return false;
    }
    return true;
}

false
true
true
false
true

---

我想你要确定的是整型列表是否是回文。通过展平，我的意思是如果你展平

[（3,2,1），（1,2,1），（1,2,3）]

，它将变成

[3,2,1,1,1,2,3]

（你可以看到这是一个回文）

您的代码有一些问题。举个例子，为什么还要检查vectors.get（i）.equals（vectors.get（i））？这将永远是正确的

这个问题有家庭作业的味道，所以我不打算给你们一个实现，但我会概述一个

在

isAlindrome（数组列表向量）

中：

将

向量的前半部分推到堆栈上

将

向量的后半部分反向排列在队列中

比较

x=q.remove（）

和

y=s.pop（）

，直到没有更多元素为止。仔细想想，平铺列表成为回文的唯一方法是，如果

x

和

y

，它们只是整数列表，彼此相反

---

你可以从那里得到它。我可以想出几种方法来实现这一点，特别是第3步。

。这是测试某个东西是否是回文的“标准”方法。清晰，评论良好。这适用于你制作的数组中的数字，但我必须检查一组向量是否是回文的。所以，一个数组需要填充向量，每个向量可能包含3个独立的数字，然后它必须检查第一个和最后一个向量是否相同，第二个和第二个向量是否相同，等等。所以（1,2,3）和（1,2,3）应该相等，如果数组中只有这两个向量，我需要检查回文，那么它将是回文的。最重要的是，我必须在is_回文方法中使用队列和堆栈。可能包含3个，或者肯定包含3个？有区别。此外，如果你必须使用堆栈和队列，这听起来像是家庭作业或其他什么。如果我告诉你，如果我试图编写这个没有队列的程序，世界会崩溃，你会相信吗无需堆栈和队列即可轻松完成。如果这是你的家庭作业，你应该表现出更多的努力，你只是用

String

发布了你的代码，但你没有表现出试图用你提到的向量来完成它。