Rust 如何将向量与向量本身的反向版本进行比较？

为什么这个不能编译

fn isPalindrome<T>(v: Vec<T>) -> bool {
  return v.reverse() == v;
}

fn isPalindrome（v:Vec）->bool{
返回v.reverse（）==v；
}

我明白了

错误[E0308]：类型不匹配
-->src/main.rs:2:25
|
2 |返回v.reverse（）==v；
|^应为（），找到结构“std:：vec:：vec”`
|
=注意：应为类型“”（）`
找到类型“std:：vec:：vec”`

请仔细阅读您正在使用的功能：

在适当的位置反转切片中元素的顺序

或检查函数签名：

fn reverse(&mut self)

方法的返回值是单位类型，一个空元组

（）

。你无法将其与向量进行比较

---

风格上，Rust使用4个空格缩进，

snake\u case

函数和变量标识符，并且在块的末尾有一个隐式返回。你应该用一种新的语言来适应这些习惯

此外，如果未将项添加到向量，则应该

为了解决您的问题，我们将使用迭代器来比较切片。您可以获得一个切片的正向和反向迭代器，与反转整个数组相比，这需要非常小的空间。允许您简洁地进行比较

您还需要声明

T

与自身具有可比性，这需要or

fn是回文（v:&[T]）->bool
哪里
T:Eq，
{
v、 iter（）.eq（v.iter（）.rev（））
}
fn main（）{
println！（“{}”，是_回文（&[1,2,3]）；
println！（“{}”，是_回文（&[1,2,1]）；
}

如果你想做空间效率较低的版本，你必须自己分配一个新的向量：

fn is_palindrome<T>(v: &[T]) -> bool
where
    T: Eq + Clone,
{
    let mut reverse = v.to_vec();
    reverse.reverse();
    reverse == v
}

fn main() {
    println!("{}", is_palindrome(&[1, 2, 3]));
    println!("{}", is_palindrome(&[1, 2, 1]));
}

fn是回文（v:&[T]）->bool
哪里
T:Eq+Clone，
{
让mut reverse=v.to_vec（）；
反向，反向（）；
反向==v
}
fn main（）{
println！（“{}”，是_回文（&[1,2,3]）；
println！（“{}”，是_回文（&[1,2,1]）；
}

---

请注意，我们现在还需要添加向量中的项，因此我们将该特征绑定到该方法。

由于您只需要查看前半部分和后半部分，因此可以使用

双端数据生成器

特征（方法

.next（）

和

.next\u back（）

）以这种方式查看前半部分和后半部分对元素：

/// Determine if an iterable equals itself reversed
fn is_palindrome<I>(iterable: I) -> bool
where
    I: IntoIterator,
    I::Item: PartialEq,
    I::IntoIter: DoubleEndedIterator,
{
    let mut iter = iterable.into_iter();
    while let (Some(front), Some(back)) = (iter.next(), iter.next_back()) {
        if front != back {
            return false;
        }
    }

    true
}

///确定一个iterable是否等于它本身
fn是回文的（iterable:I）->bool
哪里
I:迭代器，
I：：项目：PartialEq，
I：：输入者：双输入者，
{
设mut iter=iterable.into_iter（）；
而let（Some（front），Some（back））=（iter.next（），iter.next_back（））{
如果前面！=后面{
返回false；
}
}
真的
}

这个版本更一般，因为它支持任何双端的iterable，例如slice和chars迭代器

---

它只检查每个元素一次，如果迭代器的长度为奇数，它会自动跳过剩余的中间元素。

通过两次查看每个元素，您正在做双重工作。我已经发布了另一个答案。：）@这是真的，但在精神上更接近于原始问题中的代码。

/// Determine if an iterable equals itself reversed
fn is_palindrome<I>(iterable: I) -> bool
where
    I: IntoIterator,
    I::Item: PartialEq,
    I::IntoIter: DoubleEndedIterator,
{
    let mut iter = iterable.into_iter();
    while let (Some(front), Some(back)) = (iter.next(), iter.next_back()) {
        if front != back {
            return false;
        }
    }

    true
}