How to implement a remove function in a linked list in safe rust? (cannot assign to *node because is borrowed)

huangapple
go评论118阅读模式
英文:

How to implement a remove function in a linked list in safe rust? (cannot assign to *node because is borrowed)

问题

  1. 结构体 Node<T> {
  2.   内容: T,
  3.   下一个: Option<Box<Node<T>>>
  4. }
  6. 结构体 LinkedList<T> {
  7.   第一个: Option<Box<Node<T>>>,
  8.   大小: i64
  9. }
  11. 实现<T: std::default::Default + std::cmp::PartialEq> LinkedList<T> {
  12.   函数 新建() -> Self {
  13.     LinkedList { 第一个: None, 大小: 0 }
  14.   }
  16.   函数 压栈(&mut self, 值: T) {
  17.     let mut 临时节点 = Box::new(Node { 内容: 值, 下一个: None });
  18.     let 旧第一个节点 = std::mem::replace(&mut self.第一个, None);
  19.     临时节点.下一个 = 旧第一个节点;
  20.     self.第一个 = Some(临时节点);
  22.     self.大小 += 1;
  23.   }
  25.   函数 弹栈(&mut self) -> Option<T> {
  26.     let mut 旧第一个 = std::mem::replace(&mut self.第一个, None);
  27.     match &mut 旧第一个 {
  28.       None => {
  29.         return None;
  30.       },
  31.       Some(ptr) => {
  32.         self.第一个 = std::mem::take(&mut ptr.下一个);
  33.         let 返回值 = std::mem::take(&mut ptr.内容);
  34.         return Some(返回值);
  35.       }
  36.     }
  37.   }
  39.   函数 删除(&mut self, 值: T) {
  40.     let mut 当前节点 = &mut self.第一个;
  42.     while let Some(节点) = 当前节点 {
  43.       if 节点.内容 == 值 {
  44.         *当前节点 = 节点.下一个.take();
  45.         break;
  46.       }
  47.       当前节点 = &mut 节点.下一个;
  48.     }
  49.   }
  50. }
  52. 函数 主函数() {
  53.   
  54. }
英文: 
  1. struct Node<T> {
  2.   content: T,
  3.   next: Option<Box<Node<T>>>
  4. }
  6. struct LinkedList<T> {
  7.   first: Option<Box<Node<T>>>,
  8.   size: i64
  9. }
  11. impl<T: std::default::Default + std::cmp::PartialEq> LinkedList<T> {
  12.   fn new() -> Self {
  13.     LinkedList { first: None, size: 0 }
  14.   }
  16.   fn push(&mut self, value: T) {
  17.     let mut tmp_node = Box::new(Node { content: value, next: None });
  18.     let old_first_node = std::mem::replace(&mut self.first, None);
  19.     tmp_node.next = old_first_node;
  20.     self.first = Some(tmp_node);
  22.     self.size += 1;
  23.   }
  25.   fn pop(&mut self) -> Option<T> {
  26.     let mut old_first = std::mem::replace(&mut self.first, None);
  27.     match &mut old_first {
  28.       None => {
  29.         return None;
  30.       },
  31.       Some(ptr) => {
  32.         self.first = std::mem::take(&mut ptr.next);
  33.         let val_to_return = std::mem::take(&mut ptr.content);
  34.         return Some(val_to_return);
  35.       }
  36.     }
  37.   }
  39.   fn remove(&mut self, value: T) {
  40.     let mut current_node = &mut self.first;
  42.     while let Some(node) = current_node {
  43.       if node.content == value {
  44.         *current_node = node.next.take();
  45.         break;
  46.       }
  47.       current_node = &mut node.next;
  48.     }
  49.   }
  50. }
  52. fn main() {
  53.   
  54. }

I tried to implement this function a lot but every solution I thought of, the compiler complains about some "borrow" error, in this case, the error is "cannot assign to *current_node because is borrowed". How can i avoid this error and make the current node be the next node of the linked list?

答案1

得分: 2

Actually, your code is correct, it's a limitation of the compiler that it doesn't accept it. It is accepted with the nightly Polonius borrow checker.

The simplest solution is to replace while let with is_some() and unwrap()s:

  1. fn remove(&mut self, value: T) {
  2.     let mut current_node = &mut self.first;
  4.     while current_node.is_some() {
  5.         if current_node.as_mut().unwrap().content == value {
  6.             *current_node = current_node.as_mut().unwrap().next.take();
  7.             break;
  8.         }
  9.         current_node = &mut current_node.as_mut().unwrap().next;
  10.     }
  11. }
英文:

Actually, your code is correct, it's a limitation of the compiler that it doesn't accept it. It is accepted with the nightly Polonius borrow checker.

The simplest solution is to replace while let with is_some() and unwrap()s:

  1. fn remove(&mut self, value: T) {
  2.     let mut current_node = &mut self.first;
  4.     while current_node.is_some() {
  5.         if current_node.as_mut().unwrap().content == value {
  6.             *current_node = current_node.as_mut().unwrap().next.take();
  7.             break;
  8.         }
  9.         current_node = &mut current_node.as_mut().unwrap().next;
  10.     }
  11. }

huangapple
  • 本文由 发表于 2023年5月21日 01:46:27
  • 转载请务必保留本文链接：https://go.coder-hub.com/76296596.html
  • linked-list
  • rust
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定