[Rust语言]实现链表

链表是一个结点指向下一个结点的存储结构，每一个结点有两个元素，一个是存放数据本身，另一个数据指向下一个结点，由这些结点组成一个链表

思路：

• 需要先定义一个结点类包含两个元素，一个数据，一个指向下一结点
• 定义一个链表，包含一个头结点的元素
• 根据链表中头结点中包含下一个结点循环找到最后的结点，在最后增加新的结点

代码实现

//链表node节点结构体
#[derive(Clone,PartialEq)]
struct Node{
    
    
    node:i32,
    next:Option<Box<Node>>
}
impl Node{
    
    
    fn new(data:i32)->Node{
    
    
        Node{
    
    
            node:data,
            next:None,
        }
    }
}
//链表结构体
#[derive(Clone)]
struct NodeList{
    
    
    headNode:Option<Box<Node>>,
}
impl NodeList{
    
    
    fn new()->NodeList{
    
    
        NodeList{
    
    
            headNode:None
        }
    }
	//加入链表方法
    fn add(&mut self,data:i32){
    
    
        let dataNode=Node::new(data);
        if self.headNode.is_none(){
    
    
            self.headNode=Some(Box::new(dataNode));
        }else{
    
    
            let headNodeMid=self.headNode.as_mut().expect("wrong");
            //let mut tmpNode=(*tmpNodeMid).clone();
            let mut headNodeRes=&mut (*headNodeMid);
            //let mut headNodeTmp=headNodeRes;
            while headNodeRes.next.is_some(){
    
    
                let  headNodeTmp =headNodeRes.next.as_mut().expect("wrong");
                let  headNodeTmp1=&mut (*headNodeTmp);
                headNodeRes=headNodeTmp1;
            }
            (*headNodeRes).next=Some(Box::new(dataNode));
        }
    }
	//打印链表上的节点
    fn showAll(&mut self){
    
    
        if self.headNode.is_none(){
    
    
            print!("no data")
        }else{
    
    
        let tmpNodeMid=self.headNode.as_mut().expect("wrong");
        let mut headNodeRes=&mut (*tmpNodeMid);
        while headNodeRes.next.is_some(){
    
    
            println!("datanode is {}",headNodeRes.node);
            let mut headNode1 =headNodeRes.next.as_mut().expect("wrong");
            let mut headNodeTmp1=&mut (*headNode1);
            headNodeRes=headNodeTmp1;
            
            }
            println!("datanode is {}",headNodeRes.node);
        }
    }

}
//主函数
fn main() {
    
    
    let mut list=NodeList::new();
    list.add(1);
    list.add(2);
    list.add(3);
    list.add(4);
    list.add(5);
    list.add(6);
    list.showAll();
}

这段代码没有用递归的方式实现，因为对match的理解不够，也没有用match表达式。