is_empty() -> bool：如果 Vec 为空，则返回 true，否则返回 false。

as_slice(&self) -> &[T]：将 Vec 转换为其元素的切片。

as_mut_slice(&mut self) -> &mut [T]：将 Vec 转换为其元素的可变切片。

last(&self) -> Option<&T>：返回 Vec 的最后一个元素的引用，如果 Vec 为空，则返回 None。

last_mut(&mut self) -> Option<&mut T>：返回 Vec 的最后一个元素的可变引用，如果 Vec 为空，则返回 None。

first(&self) -> Option<&T>：返回 Vec 的第一个元素的引用，如果 Vec 为空，则返回 None。

first_mut(&mut self) -> Option<&mut T>：返回 Vec 的第一个元素的可变引用，如果 Vec 为空，则返回 None。

binary_search(&self, x: &T) -> Result：在已排序的 Vec 中搜索指定元素，并返回其索引。

sort(&mut self)：按升序对 Vec 的元素进行排序。

sort_by_key(&mut self, f: F)：按升序对 Vec 的元素进行排序，其中排序关键字由指定的函数生成。

sort_by(&mut self, compare: F)：按升序对 Vec 的元素进行排序，其中比较函数由指定的函数生成。

binary_search(&self, x: &T) -> Result：在已排序的 Vec 中搜索指定元素，并返回它的索引。如果元素不存在，则返回 Err，该 Err 包含元素应该插入的位置的索引。

binary_search_by(&self, f: F) -> Result where F: FnMut(&T) -> Ordering：在已排序的 Vec 中使用指定的比较函数搜索指定元素，并返回它的索引。如果元素不存在，则返回 Err，该 Err 包含元素应该插入的位置的索引。

binary_search_by_key(&self, key: &K, f: F) -> Result where F: FnMut(&T) -> K, K: Ord：在已排序的 Vec 中使用指定的键函数搜索指定键，并返回它的索引。如果键不存在，则返回 Err，该 Err 包含键应该插入的位置的索引。

sort(&mut self)：对 Vec 中的元素进行排序。

sort_by(&mut self, compare: F)：使用指定的比较函数对 Vec 中的元素进行排序。

sort_by_key(&mut self, f: F)：使用指定的键函数对 Vec 中的元素进行排序。

reverse(&mut self)：反转 Vec 中元素的顺序。

split_off(&mut self, at: usize) -> Vec：将 Vec 拆分为两个 Vec，从指定位置开始拆分。

chunks(&self, chunk_size: usize) -> Chunks<'_, T>：返回一个迭代器，该迭代器遍历 Vec 的不重叠的块，每个块包含指定数量的元素。

chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>：返回一个可变迭代器，该迭代器遍历 Vec 的不重叠的块，每个块包含指定数量的元素。

windows(&self, window_size: usize) -> Windows<'_, T>：返回一个迭代器，该迭代器遍历 Vec 的连续窗口，每个窗口包含指定数量的元素。

try_fold(&self, init: B, f: F) -> R where F: FnMut(B, &T) -> Result, R: From：对 Vec 中的每个元素执行指定的操作，并返回结果。如果任何操作返回 Err，则停止并返回 Err，否则返回 Ok。

try_for_each(&self, f: F) -> R where F: FnMut(&T) -> Result<(), R>, R: From<()>：对 Vec 中的每个元素执行指定的操作，并返回结果。如果任何操作返回 Err，则停止并返回 Err，否则返回 Ok。

try_for_each(&self, f: F) -> R where F: FnMut(&T) -> Result<(), R>, R: From<()>：对 Vec 中的每个元素执行指定的操作，并返回结果。如果任何操作返回 Err，则停止并返回 Err，否则返回 Ok。

contains(&self, x: &T) -> bool：如果 Vec 包含指定的元素，则返回 true，否则返回 false。

dedup(&mut self)：删除 Vec 中的重复元素。只保留第一次出现的元素。

dedup_by_key(&mut self, key: F)：删除 Vec 中的重复元素。只保留第一次出现的元素。比较是使用指定的键函数进行的。

retain(&mut self, f: F)：从 Vec 中删除不满足指定条件的所有元素。

split_off(&mut self, at: usize) -> Vec：从 Vec 中分离指定索引之后的所有元素，并返回一个新的 Vec。

truncate(&mut self, len: usize)：将 Vec 的长度截断为指定长度。如果指定长度小于 Vec 的当前长度，则删除多余的元素。

三、Vec的简单实现及其宏模拟

trait MyVec {
    type Item;
    fn new() -> Self;
    fn len(&self) -> usize;
    fn push(&mut self, element: Self::Item);
    fn pop(&mut self) -> Option;
}
impl MyVec for Vec {
    type Item = T;
    fn new() -> Vec {
        Vec::new()
    }
    fn len(&self) -> usize {
        Vec::len(self)
    }
    fn push(&mut self, element: T) {
        Vec::push(self, element)
    }
    
    fn pop(&mut self) -> Option {
        Vec::pop(self)
    }
}
macro_rules! myvec {
    ( $( $x:expr ),* ) => {
        {
            let mut vec =  as MyVec>::new();
            $(
                vec.push($x);
            )*
            vec
        }
    };
}
fn main() {
    let mut v = myvec![1,2,3,4];
    println!("{:?}, size = {}", v, v.len());
    
    if let Some(last) = v.pop() {   // 检查向量是否为空
        println!("弹出的尾部元素: {:?}", last);
        println!("{:?}, size = {}", v, v.len());
    } else {
        println!("Vector is empty");  // 向量为空的情况
    }
    v.push(5);
    println!("{:?}, size = {}", v, v.len());
}

输出：

[1, 2, 3, 4], size = 4

弹出的尾部元素: 4

[1, 2, 3], size = 3

[1, 2, 3, 5], size = 4

四、leetcode 实战

1. 长度最小的子数组 Minimum-size-subarray-sum

给定一个含有 n 个正整数的数组和一个正整数 target 。

找出该数组中满足其和 ≥ target 的长度最小的 连续子数组 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其长度。如果不存在符合条件的子数组，返回 0 。

示例 1：

输入：target = 7, nums = [2,3,1,2,4,3]

输出：2

解释：子数组 [4,3] 是该条件下的长度最小的子数组。

示例 2：

输入：target = 4, nums = [1,4,4]

输出：1

提示：

1 <= target <= 10^9

1 <= nums.length <= 10^5

1 <= nums[i] <= 10^5

代码1：

fn min_sub_array_len(target: i32, nums: Vec) -> i32 {
    let mut i = 0;
    let mut j = 0;
    let mut sum = 0;
    let mut min_len = std::usize::MAX;
    while j < nums.len() {
        sum += nums[j];
        j += 1;
        while sum >= target {
            min_len = min_len.min(j - i);
            sum -= nums[i];
            i += 1;
        }
    }
    if min_len == std::usize::MAX {
        0
    } else {
        min_len as i32
    }
}
fn main() {
    let nums = vec![2, 3, 1, 2, 4, 3];
    println!("{}", min_sub_array_len(7, nums));
    let nums = vec![1, 4, 4];
    println!("{}", min_sub_array_len(4, nums));
}

代码2：

fn min_sub_array_len(target: i32, nums: Vec) -> i32 {
    let mut min_len = i32::MAX;
    let (mut left, mut right) = (0, 0);
    let mut sum = 0;
    while right < nums.len() {
        sum += nums[right];
        while sum >= target {
            min_len = min(min_len, (right - left + 1) as i32);
            sum -= nums[left];
            left += 1;
        }
        right += 1;
    }
    if min_len == i32::MAX {
        return 0;
    }
    min_len
}
    
fn min(a: i32, b: i32) -> i32 {
    if a < b {
        a
    } else {
        b
    }
}
fn main() {
    let nums = vec![2, 3, 1, 2, 4, 3];
    println!("{}", min_sub_array_len(7, nums));
    let nums = vec![1, 4, 4];
    println!("{}", min_sub_array_len(4, nums));
}

2. 最大子数组和  Maximum Subarray

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

示例 1：

输入：nums = [-2,1,-3,4,-1,2,1,-5,4]
输出：6
解释：连续子数组 [4,-1,2,1] 的和最大，为 6 。

示例 2：

输入：nums = [1]
输出：1

示例 3：

输入：nums = [5,4,-1,7,8]
输出：23

提示：

• 1 <= nums.length <= 10^5
• -10^4 <= nums[i] <= 10^4

  进阶：如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的 分治法 求解。

  代码1： 动态规划

  fn max_sub_array(nums: &[i32]) -> i32 {
      let n = nums.len();
      let mut dp = vec![0; n];
      dp[0] = nums[0];
      for i in 1..n {
          dp[i] = std::cmp::max(dp[i-1] + nums[i], nums[i]);
      }
      let mut res = dp[0];
      for i in 1..n {
          res = std::cmp::max(res, dp[i]);
      }
      res
  }
  fn main() {
      let nums = vec![-2, 1, -3, 4, -1, 2, 1, -5, 4];
      println!("{}", max_sub_array(&nums));
      let nums = vec![1];
      println!("{}", max_sub_array(&nums));
      let nums = vec![5,4,-1,7,8];
      println!("{}", max_sub_array(&nums));
  }
  

  代码2： 贪心算法

  fn max_sub_array(nums: &[i32]) -> i32 {
      let n = nums.len();
      let (mut cur_sum, mut max_sum) = (0, nums[0]);
      for i in 0..n {
          cur_sum += nums[i];
          if cur_sum > max_sum {
              max_sum = cur_sum;
          }
          if cur_sum < 0 {
              cur_sum = 0;
          }
      }
      max_sum
  }
  fn main() {
      let nums = vec![-2, 1, -3, 4, -1, 2, 1, -5, 4];
      println!("{}", max_sub_array(&nums));
      let nums = vec![1];
      println!("{}", max_sub_array(&nums));
      let nums = vec![5,4,-1,7,8];
      println!("{}", max_sub_array(&nums));
  }
  

  输出：

  6

  1

  23

  ---

  3. 螺旋矩阵 Spiral Matrix

  给你一个 m 行 n 列的矩阵 matrix ，请按照 顺时针螺旋顺序 ，返回矩阵中的所有元素。

  示例 1：

  

  输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
  输出：[1,2,3,6,9,8,7,4,5]
  

  示例 2：

  

  输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
  输出：[1,2,3,4,8,12,11,10,9,5,6,7]
  

  提示：

  • m == matrix.length
  • n == matrix[i].length
  • 1 <= m, n <= 10
  • -100 <= matrix[i][j] <= 100

    代码1：

    fn spiral_order(matrix: &[Vec]) -> Vec {
        if matrix.is_empty() {
            return vec![];
        }
        let (m, n) = (matrix.len(), matrix[0].len());
        let mut res = vec![0; m * n];
        let (mut top, mut bottom, mut left, mut right) = (0, m - 1, 0, n - 1);
        let mut idx = 0;
        while top <= bottom && left <= right {
            for i in left..=right {
                res[idx] = matrix[top][i];
                idx += 1;
            }
            for i in top + 1..=bottom {
                res[idx] = matrix[i][right];
                idx += 1;
            }
            if top < bottom && left < right {
                for i in (left..right).rev() {
                    res[idx] = matrix[bottom][i];
                    idx += 1;
                }
                for i in (top + 1..=bottom - 1).rev() {
                    res[idx] = matrix[i][left];
                    idx += 1;
                }
            }
            top += 1;
            bottom -= 1;
            left += 1;
            right -= 1;
        }
        res
    }
    fn main() {
        let matrix = vec![
            vec![1, 2, 3],
            vec![4, 5, 6],
            vec![7, 8, 9],
        ];
        println!("{:?}", spiral_order(&matrix));
        let matrix = vec![
            vec![1, 2, 3, 4],
            vec![5, 6, 7, 8],
            vec![9,10,11,12],
        ];
        println!("{:?}", spiral_order(&matrix));
    }
    

    代码2： 递归

    fn spiral_order(matrix: Vec>) -> Vec {
        fn spiral_helper(top: usize, bottom: usize, left: usize, right: usize, res: &mut Vec, idx: &mut usize, matrix: &Vec>) {
            if top > bottom || left > right {
                return;
            }
            
            // 从左到右遍历上边界
            for i in left..=right {
                res[*idx] = matrix[top][i];
                *idx += 1;
            }
            
            // 从上到下遍历右边界
            for i in (top + 1)..=bottom {
                res[*idx] = matrix[i][right];
                *idx += 1;
            }
            
            if top < bottom && left < right {
                // 从右到左遍历下边界
                for i in (left..right).rev() {
                    res[*idx] = matrix[bottom][i];
                    *idx += 1;
                }
                
                // 从下到上遍历左边界
                for i in ((top + 1)..bottom).rev() {
                    res[*idx] = matrix[i][left];
                    *idx += 1;
                }
            }
            
            // 矩形边界变小，递归调用spiral_helper继续遍历
            spiral_helper(top + 1, bottom - 1, left + 1, right - 1, res, idx, matrix);
            
        }
        
        let m = matrix.len();
        let n = matrix[0].len();
        let mut res = vec![0; m * n]; // 用于记录遍历结果
        let mut idx = 0; // 当前结果数组的下标
        
        // 从矩形最外层开始遍历
        spiral_helper(0, m - 1, 0, n - 1, &mut res, &mut idx, &matrix);
        
        res
    }
    fn main() {
        let matrix = vec![
            vec![1, 2, 3],
            vec![4, 5, 6],
            vec![7, 8, 9],
        ];
        println!("{:?}", spiral_order(matrix));
        
        let matrix = vec![
            vec![1, 2, 3, 4],
            vec![5, 6, 7, 8],
            vec![9,10,11,12],
        ];
        println!("{:?}", spiral_order(matrix));
    }
    

    输出：

    [1, 2, 3, 6, 9, 8, 7, 4, 5]

    [1, 2, 3, 4, 8, 12, 11, 10, 9, 5, 6, 7] 

    ---

    完