面试题：Rust泛型约束在复杂数据结构中的应用

Question

假设有一个自定义的链表数据结构`MyList`，它是一个泛型结构，存储的数据类型需要实现`Clone`和`PartialEq` trait。请实现`MyList`结构及其相关方法，包括添加元素、删除元素、查找元素（如果元素存在返回`true`，否则返回`false`）。在实现过程中，展示如何正确运用泛型约束来确保代码的正确性和可扩展性。

Answer 1

use std::clone::Clone;
use std::cmp::PartialEq;

// 定义链表节点
struct Node<T> {
    data: T,
    next: Option<Box<Node<T>>>,
}

// 定义链表结构
pub struct MyList<T> {
    head: Option<Box<Node<T>>>,
}

impl<T: Clone + PartialEq> MyList<T> {
    // 创建新的空链表
    pub fn new() -> Self {
        MyList { head: None }
    }

    // 添加元素到链表尾部
    pub fn add_element(&mut self, data: T) {
        let new_node = Box::new(Node {
            data,
            next: None,
        });
        match self.head.take() {
            None => self.head = Some(new_node),
            Some(mut head) => {
                while let Some(ref mut node) = head.next {
                    head = node.as_mut();
                }
                head.next = Some(new_node);
            }
        }
    }

    // 删除元素
    pub fn remove_element(&mut self, data: &T) {
        self.head = match self.head.take() {
            None => None,
            Some(mut head) => {
                if head.data == *data {
                    head.next.take()
                } else {
                    let mut prev = &mut head;
                    while let Some(ref mut node) = prev.next {
                        if node.data == *data {
                            prev.next = node.next.take();
                            break;
                        }
                        prev = node.as_mut();
                    }
                    Some(head)
                }
            }
        }
    }

    // 查找元素
    pub fn find_element(&self, data: &T) -> bool {
        match &self.head {
            None => false,
            Some(head) => {
                let mut current = head;
                while let Some(node) = current {
                    if node.data == *data {
                        return true;
                    }
                    current = node.next.as_ref().map(|n| n.as_ref());
                }
                false
            }
        }
    }
}