Rust集合--VecDeque

VecDeque

https://doc.rust-lang.org/std/collections/struct.VecDeque.html
使用可增长的环形缓冲区实现的双端队列

在以下情况下使用VecDeque：

• 您需要一个支持在序列两端高效插入的 Vec。
• 您需要一个队列。

• 您需要一个双端队列 （deque）。

  实现

  new() -> VecDeque

  Creates an empty deque.

  //创建一个空的队列
  fn test_create_empty_deque() {
    let deque: VecDeque<u32> = VecDeque::new();
  }

  with_capacity(capacity: usize)-> VecDeque

  创建一个至少包含空间的空元素。capacity

  //创建一个至少包含空间的空元素。capacity
  fn test_create_empty_deque_with_capacity() {
    let deque: VecDeque<u32> = VecDeque::with_capacity(10);
  }

  get（&self， index： usize） -> Option[&](https://doc.rust-lang.org/std/primitive.reference.html)T

  提供对给定索引处的元素的引用。索引 0 处的元素是队列的前面。

  //get 提供对给定索引处的元素的引用
  fn test_get() {
    let mut deque: VecDeque<u32> = VecDeque::new();
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.push_back(4);
    assert_eq!(deque.get(0), Some(&4));
  }

  get_mut（&mut self， index： usize） -> Option[&mut](https://doc.rust-lang.org/std/primitive.reference.html)T

  get_mut 提供对给定索引处的元素的可变引用。索引 0 处的元素是队列的前面。

  //get_mut 提供对给定索引处的元素的可变引用
  fn test_get_mut() {
    let mut deque: VecDeque<u32> = VecDeque::new();
    deque.push_back(1);
    deque.push_back(2);
    deque.push_back(3);
    deque.push_back(4);
    if let Some(elem) = deque.get_mut(1) {
        *elem = 7;
    }
    assert_eq!(deque[1], 7);
  }

  swap（&mut self， i： usize， j： usize)

  在指定索引处交换ij元素。i并且可能相等j。
  恐慌
  如果任一索引超出范围，则出现紧急状态。

  //在指定索引处交换ij元素。i并且可能相等j
  fn test_swap() {
    let mut buf = VecDeque::new();
    buf.push_back(3);
    buf.push_back(4);
    buf.push_back(5);
    assert_eq!(buf, [3, 4, 5]);
    buf.swap(0, 2);
    assert_eq!(buf, [5, 4, 3]);
  }

  capacity（&self） -> usize

  返回 deque 在不重新分配的情况下可以容纳的元素数。

  //返回 deque 在不重新分配的情况下可以容纳的元素数。
  fn test_capacity() {
    let buf: VecDeque<i32> = VecDeque::with_capacity(10);
    assert!(buf.capacity() >= 10);
  }

  reserve_exact（&mut self， additional： usize)

  保留最小容量，以便至少将更多元素插入到给定的截面中。如果容量已足够，则不执行任何操作。additional
  请注意，分配器可能为集合提供比它请求更多的空间。因此，不能指望容量精确地最小化。如果将来需要插入，则首选保留。
  恐慌
  如果新容量溢出，则惊慌失措。usize

  //保留最小容量，以便至少将更多元素插入到给定的截面中。
  fn test_reserve_exact() {
    let mut buf: VecDeque<i32> = [1].into();
    buf.reserve_exact(10);
    assert!(buf.capacity() >= 11);
  }

  reserve（&mut self， additional： usize)

  为至少更多元素保留在给定的截面中插入的容量。馆藏可能会保留更多空间，以推测性地避免频繁的重新分配。additional
  恐慌
  如果新容量溢出，则惊慌失措。usize

  //为至少更多元素保留在给定的截面中插入的容量
  fn test_reserve() {
    let mut buf: VecDeque<i32> = [1].into();
    buf.reserve(10);
    assert!(buf.capacity() >= 11);
  }

  try_reserve_exact（&mut self，additional： usize）

  尝试为至少更多元素保留在给定的 deque 中所需的最小容量。调用后，容量将大于或等于返回 时。如果容量已足够，则不执行任何操作。
  请注意，分配器可能为集合提供比它请求更多的空间。因此，不能指望容量精确地最小化。如果将来需要插入，则首选try_reserve。
  错误
  如果容量溢出，或者分配器报告失败，则返回错误。usize

  //尝试为至少更多元素保留在给定的 deque 中所需的最小容量
  fn test_try_reserve_exact(data: &[u32]) -> Result<VecDeque<u32>, TryReserveError> {
    let mut output = VecDeque::new();
    // Pre-reserve the memory, exiting if we can't
    output.try_reserve_exact(data.len())?;
    // Now we know this can't OOM(Out-Of-Memory) in the middle of our complex work
    output.extend(data.iter().map(|&val| {
        val * 2 + 5 // very complicated
    }));
    Ok(output)
  }

  try_reserve（&mut self， additional： usize）

  尝试为至少要在给定的 deque 中插入更多元素保留容量。馆藏可能会保留更多空间，以推测性地避免频繁的重新分配。调用后，容量将大于或等于返回 时。如果容量已足够，则不执行任何操作。

  shrink_to_fit（&mut self）

  尽可能缩小瓶盖的容量。

  shrink_to（&mut self， min_capacity： usize)

  使用下限收缩 deque 的容量。

  truncate（&mut self， len： usize)

  缩短 deque，保留第一个元素并删除其余元素。len
  如果 大于 deque 的当前长度，则此值不起作用。len

  iter（&self）

  iter_mut（&mut self）

  as_slices（&self）

  as_mut_slices（&mut self）

  len（&self）

  is_empty（&self

  range（&self， range： R）

  range_mut（&mut self， range： R）

  drain（&mut self， range： R）

  clear（&mut self）

  contains(&self, x: &T)

  back（&self）

  back_mut（&mut self）

  pop_front（&mut self）

  pop_back（&mut self）

  push_front（&mut self， value： T）

  push_back（&mut self， value： T）

  将元素追加到 deque 的背面。

  swap_remove_front（&mut self， index： usize）

  从 deque 中的任意位置删除元素并返回该元素，并将其替换为第一个元素。
  这不会保留排序，而是 O（1）。
  如果超出范围，则返回。Noneindex
  索引 0 处的元素是队列的前面。

  swap_remove_back（&mut self， index： usize）

  从 deque 中的任意位置删除元素并返回该元素，并将其替换为最后一个元素。
  这不会保留排序，而是 O（1）。
  如果超出范围，则返回。Noneindex
  索引 0 处的元素是队列的前面。

  insert（&mut self， index： usize， value： T）

  在 deque 中插入一个元素，将索引大于或等于 的所有元素向后移动。indexindex
  索引 0 处的元素是队列的前面。
  恐慌
  如果大于 deque 的长度，则惊慌失措index

  remove（&mut self， index： usize）

  从 deque 中删除并返回 at 元素。无论哪一端靠近移除点，都将被移动以腾出空间，并且所有受影响的元素将被移动到新位置。如果超出范围，则返回。indexNoneindex
  索引 0 处的元素是队列的前面。

  split_off（&mut self， at： usize）

  在给定索引处将 deque 拆分为两个。
  返回新分配的 。 包含元素，返回的 deque 包含元素 。VecDequeself[0, at)[at, len)
  请注意，的容量不会改变。self
  索引 0 处的元素是队列的前面。

  append（&mut self， other： &mut VecDeque）

  将 other 的所有元素移入selfother
  恐慌
  如果 self 中的新元素数溢出 .usize

  make_contiguous（&mut self）

  重新排列此截面的内部存储，使其成为一个连续切片，然后将其返回。
  此方法不分配，也不更改插入元素的顺序。当它返回可变切片时，这可用于对 deque 进行排序。
  一旦内部存储是连续的，as_slices和as_mut_slices方法将在单个切片中返回 deque 的全部内容。

  rotate_left（&mut self， mid： usize)

  rotate_right（&mut self， k： usize)