Rust中的Vec是一種動(dòng)態(tài)數(shù)組，它可以在運(yùn)行時(shí)自動(dòng)調(diào)整大小。Vec是Rust標(biāo)準(zhǔn)庫(kù)的一部分，提供了一種高效、安全的方式來(lái)處理大量數(shù)據(jù)?；诙褍?nèi)存申請(qǐng)的連續(xù)動(dòng)態(tài)數(shù)據(jù)類(lèi)型，其索引、壓入(push)、彈出(pop) 操作的時(shí)間復(fù)雜度為 O(1) 。

一、基本概念

Vec是什么？

Vec，是“vector”的縮寫(xiě)。一種動(dòng)態(tài)數(shù)組，它可以在運(yùn)行時(shí)自動(dòng)調(diào)整大小。Vec的底層實(shí)現(xiàn)是基于數(shù)組的，因此它的性能非常高。Vec可以存儲(chǔ)任何類(lèi)型的數(shù)據(jù)，包括整數(shù)、浮點(diǎn)數(shù)、字符串等。

Vec其實(shí)是一個(gè)智能指針，用于在堆上分配內(nèi)存的動(dòng)態(tài)數(shù)組。它提供了一些方法來(lái)操作數(shù)組，如添加、刪除和訪問(wèn)元素。與C或Python中的數(shù)組不同，Vec會(huì)自動(dòng)處理內(nèi)存分配和釋放，從而避免了常見(jiàn)的內(nèi)存泄漏和懸掛指針錯(cuò)誤。

Vec的本質(zhì)就是一個(gè)三元組，指針、長(zhǎng)度、容量，在rust標(biāo)準(zhǔn)庫(kù)中的定義如下：

pub struct Vec<T, A: Allocator = Global> {
    buf: RawVec<T, A>,
    len: usize,
}
impl<T> Vec<T> {
    #[inline]
    pub const fn new() -> Self {
        Vec { buf: RawVec::NEW, len: 0 }
    }
//...略...
}

Vec的核心功能之一是動(dòng)態(tài)增長(zhǎng)和收縮。當(dāng)向Vec中添加元素時(shí)，如果堆上的內(nèi)存不足，Vec會(huì)自動(dòng)分配更多的內(nèi)存來(lái)容納元素。這個(gè)過(guò)程稱(chēng)為“擴(kuò)容”。同樣，當(dāng)從Vec中刪除元素時(shí)，如果堆上的內(nèi)存過(guò)多，Vec會(huì)自動(dòng)收縮以釋放內(nèi)存。這個(gè)過(guò)程稱(chēng)為“縮容”。這種自動(dòng)內(nèi)存管理機(jī)制使得使用Vec變得非常方便，同時(shí)也避免了手動(dòng)管理內(nèi)存的錯(cuò)誤。

除了基本的添加、刪除和訪問(wèn)元素操作之外，Vec還提供了許多其他功能。例如，它們可以按索引訪問(wèn)元素，可以使用迭代器遍歷元素，并且支持多種方法（如push()、pop()、insert()和remove()）來(lái)修改Vec的內(nèi)容。Vec還提供了一些有用的靜態(tài)方法（如capacity()、len()和is_empty()），可以用來(lái)獲取Vec的屬性。

雖然Vec是一個(gè)非常強(qiáng)大的數(shù)據(jù)結(jié)構(gòu)，但它們也有一些限制。例如，Vec在堆上分配內(nèi)存，這意味著訪問(wèn)元素的速度可能會(huì)比在棧上分配內(nèi)存的數(shù)組慢。此外，由于Vec是智能指針，因此它們的大小不是固定的，這可能會(huì)導(dǎo)致一些編程錯(cuò)誤。例如，如果嘗試將Vec賦值給一個(gè)固定大小的數(shù)組或另一個(gè)Vec，則會(huì)發(fā)生編譯時(shí)錯(cuò)誤。

Vec的特點(diǎn)

(1)動(dòng)態(tài)大?。?/p>

Vec可以根據(jù)需要自動(dòng)調(diào)整大小，無(wú)需預(yù)先分配內(nèi)存。當(dāng)元素?cái)?shù)量發(fā)生變化時(shí)，Vec會(huì)自動(dòng)重新分配內(nèi)存并復(fù)制元素。

(2)可變性：

Vec是可變的，這意味著我們可以在不創(chuàng)建新Vec的情況下修改現(xiàn)有元素。這使得我們?cè)谔幚泶罅繑?shù)據(jù)時(shí)更加靈活。

(3)泛型：

Vec是泛型的，這意味著我們可以使用相同的方法來(lái)處理不同類(lèi)型的數(shù)據(jù)。例如，我們可以使用vec![1, 2, 3]創(chuàng)建一個(gè)包含整數(shù)的Vec,使用vec!["a", "b", "c"]創(chuàng)建一個(gè)包含字符串的Vec。

動(dòng)態(tài)數(shù)組是一種基于堆內(nèi)存申請(qǐng)的連續(xù)動(dòng)態(tài)數(shù)據(jù)類(lèi)型，擁有 O(1) 時(shí)間復(fù)雜度的索引、壓入（push）、彈出（pop)。 

二、基礎(chǔ)用法

1. 創(chuàng)建

(1) Vec::new()方法

只創(chuàng)建一個(gè)空列表時(shí)，必須注明類(lèi)型（否則通不過(guò)編譯）。如下例的正確用法：

fn main() {
    let vec: Vec<i32> = Vec::new();
    println!("{:?}", vec);
}

輸出：

[] 

注：print!、println!輸出Vec時(shí)需要使用格式符 "{:?}" 。

但如果下一步要添加元素，比如使用push(x)方法，就非必須注明類(lèi)型，默認(rèn)就是 i32 類(lèi)型：

示例： 

fn main() {
    let mut vec = Vec::new();
    vec.push(1);
    vec.push(2);
    vec.push(3);
    println!("{:?}", vec);
}

輸出：

[1, 2, 3]

(2) Vec::from()方法

let vec = Vec::from([1,2,3]);

(3) vec! 宏

let vec = vec![1,2,3];

用法示例及判斷是否相等：

fn main() {
    let vec1 = Vec::from([1,2,3]);
    println!("{:?}", vec1);
    let vec2 = vec![1,2,3];
    println!("{:?}", vec2);
    assert_eq!(vec1, vec2);
    assert_eq!(vec1, [1,2,3]);
    assert_eq!(vec2, [1,2,3]);
    println!("{}", vec1 == vec2);
}

輸出：

[1, 2, 3]
[1, 2, 3]
true

vec! 宏 的另外用法： 

創(chuàng)建 len 個(gè)相同元素 n 的Vec，如：vec![n; len]。

示例：

fn main() {
    let vec = vec![0; 5];
    assert_eq!(vec, [0, 0, 0, 0, 0]);
    println!("{:?}", vec);
    let vec = vec![1; 3];
    assert_eq!(vec, [1, 1, 1]);
    println!("{:?}", vec);
    let vec = vec![1; 0];
}

以下是vec![1; 3]的等效方法，但速度較慢：

?fn main() {
    let mut vec = Vec::with_capacity(3);
    vec.resize(3, 1);
    assert_eq!(vec, [1, 1, 1]);
}

以上3種創(chuàng)建方法中，使用第3種方法的vec!宏來(lái)創(chuàng)建Vec相對(duì)比較方便。

二維Vec的創(chuàng)建和遍歷

fn main() {
    // 創(chuàng)建一個(gè)2x3的二維向量
    let matrix: Vec<Vec<i32>> = vec![
        vec![1, 2, 3], 
        vec![4, 5, 6]
    ];
    
    // 遍歷二維向量
    for row in &matrix {
        for &num in row {
            print!("{} ", num);
        }
        println!();
    }

    // 創(chuàng)建一個(gè)3x5的二維向量，所有元素都為 1
    let (m, n) = (3, 5);
    let number = 1;
    let matrix = vec![vec![number; n]; m];
    for row in &matrix {
        for &num in row {
            print!("{} ", num);
        }
        println!();
    }
}

輸出：

1 2 3 
4 5 6 
1 1 1 1 1 
1 1 1 1 1 
1 1 1 1 1 

2. 基礎(chǔ)用法

Vec內(nèi)置了非常豐富的內(nèi)置方法，以下方法收集自網(wǎng)絡(luò)，有重復(fù)暫時(shí)沒(méi)空余時(shí)間去好好整理。

new(): 創(chuàng)建一個(gè)空的 Vec。
with_capacity(capacity: usize): 創(chuàng)建一個(gè)具有指定容量的空 Vec。
capacity() -> usize: 返回 Vec 的當(dāng)前容量。
reserve(new_cap: usize): 為 Vec 分配額外的空間。
reserve_exact(new_cap: usize): 為 Vec 分配精確的額外空間。
shrink_to_fit(): 縮小 Vec 的容量以匹配其當(dāng)前大小。
len() -> usize: 返回 Vec 的當(dāng)前長(zhǎng)度。
is_empty() -> bool: 檢查 Vec 是否為空。
push(value: T): 將一個(gè)值添加到 Vec 的末尾。
pop() -> Option<T>: 刪除并返回 Vec 的最后一個(gè)元素。
insert(index: usize, element: T): 在指定位置插入一個(gè)元素。
remove(index: usize) -> T: 刪除并返回指定位置的元素。
swap(index1: usize, index2: usize): 交換指定位置上的兩個(gè)元素。
truncate(len: usize): 將 Vec 截?cái)酁橹付ㄩL(zhǎng)度。
clear(): 刪除 Vec 中的所有元素。
iter() -> Iter<T>: 返回一個(gè)迭代器，它允許按順序遍歷 Vec 中的元素。
iter_mut() -> IterMut<T>: 返回一個(gè)可變迭代器，它允許按順序遍歷 Vec 中的元素并進(jìn)行修改。
into_iter() -> IntoIter<T>: 返回一個(gè)迭代器，它允許按順序遍歷 Vec 中的元素并轉(zhuǎn)移所有權(quán)。
split_off(at: usize) -> Vec<T>: 從指定位置將 Vec 拆分為兩個(gè)獨(dú)立的 Vec。
append(&mut self, other: &mut Vec<T>): 將另一個(gè) Vec 的所有元素附加到當(dāng)前 Vec 的末尾。

swap(index1: usize, index2: usize): 交換指定位置的兩個(gè)元素。
get(index: usize) -> Option<&T>: 獲取指定位置的元素的引用。
get_mut(index: usize) -> Option<&mut T>: 獲取指定位置的元素的可變引用。
first() -> Option<&T>: 獲取 Vec 的第一個(gè)元素的引用。
first_mut() -> Option<&mut T>: 獲取 Vec 的第一個(gè)元素的可變引用。
last() -> Option<&T>: 獲取 Vec 的最后一個(gè)元素的引用。
last_mut() -> Option<&mut T>: 獲取 Vec 的最后一個(gè)元素的可變引用。
split_at(index: usize) -> (&[T], &[T]): 將 Vec 分成兩個(gè)部分，從指定位置進(jìn)行分割。
split_at_mut(index: usize) -> (&mut [T], &mut [T]): 將 Vec 分成兩個(gè)部分，從指定位置進(jìn)行分割，返回可變引用。
as_slice() -> &[T]: 將 Vec 轉(zhuǎn)換為切片，返回不可變引用。
as_mut_slice() -> &mut [T]: 將 Vec 轉(zhuǎn)換為切片，返回可變引用。
iter() -> Iter<'_, T>: 返回一個(gè)迭代器，用于遍歷 Vec 中的元素。
iter_mut() -> IterMut<'_, T>: 返回一個(gè)迭代器，用于遍歷 Vec 中的元素，并返回可變引用。
into_iter() -> IntoIter<T>: 返回一個(gè)迭代器，用于遍歷 Vec 中的元素，Vec 在迭代過(guò)程中將被移動(dòng)。
clone_from(other: &Vec<T>): 從另一個(gè) Vec 復(fù)制元素到當(dāng)前 Vec。
truncate(len: usize): 刪除 Vec 的尾部元素，直到長(zhǎng)度為指定值。
clear(): 刪除 Vec 中的所有元素。

as_slice() -> &[T]: 將 Vec 轉(zhuǎn)換為不可變的切片。
as_mut_slice() -> &mut [T]: 將 Vec 轉(zhuǎn)換為可變的切片。
split_first() -> Option<(&T, &[T])>: 返回 Vec 的第一個(gè)元素和其余部分的元組。
split_first_mut() -> Option<(&mut T, &mut [T])>: 返回 Vec 的第一個(gè)元素和其余部分的可變引用。
split_last() -> Option<(&T, &[T])>: 返回 Vec 的最后一個(gè)元素和其余部分的元組。
split_last_mut() -> Option<(&mut T, &mut [T])>: 返回 Vec 的最后一個(gè)元素和其余部分的可變引用。
chunks(chunk_size: usize) -> Chunks<'_, T>: 返回一個(gè)迭代器，該迭代器按塊大小切分 Vec。
chunks_mut(chunk_size: usize) -> ChunksMut<'_, T>: 返回一個(gè)迭代器，該迭代器按塊大小切分 Vec，并返回可變引用。
windows(window_size: usize) -> Windows<'_, T>: 返回一個(gè)迭代器，該迭代器在 Vec 上滑動(dòng)，返回指定大小的窗口。
iter() -> Iter<'_, T>: 返回一個(gè)不可變引用的迭代器，該迭代器遍歷 Vec 中的每個(gè)元素。
iter_mut() -> IterMut<'_, T>: 返回一個(gè)可變引用的迭代器，該迭代器遍歷 Vec 中的每個(gè)元素。
into_iter() -> IntoIter<T>: 返回一個(gè)擁有所有權(quán)的迭代器，該迭代器遍歷 Vec 中的每個(gè)元素。

chunks_exact(chunk_size: usize) -> ChunksExact<'_, T>: 返回一個(gè)迭代器，該迭代器按塊大小切分 Vec，每個(gè)塊都是固定大小的。
chunks_exact_mut(chunk_size: usize) -> ChunksExactMut<'_, T>: 返回一個(gè)迭代器，該迭代器按塊大小切分 Vec，每個(gè)塊都是固定大小的，并返回可變引用。
windows(window_size: usize) -> Windows<'_, T>: 返回一個(gè)迭代器，該迭代器按指定大小滑動(dòng)窗口遍歷 Vec。
iter() -> Iter<'_, T>: 返回一個(gè)不可變的迭代器，遍歷 Vec 的元素。
iter_mut() -> IterMut<'_, T>: 返回一個(gè)可變的迭代器，遍歷 Vec 的元素并返回可變引用。
into_iter() -> IntoIter<T>: 返回一個(gè)將 Vec 轉(zhuǎn)換為迭代器的方法。
retain<F>(&mut self, f: F)：在保留滿(mǎn)足給定謂詞的元素的情況下，刪除不滿(mǎn)足謂詞的所有元素。
dedup(&mut self)：刪除連續(xù)重復(fù)的元素。只保留第一個(gè)出現(xiàn)的元素，其他的都被刪除。

retain<F>(&mut self, f: F)：在保留滿(mǎn)足給定謂詞的元素的同時(shí)，移除不滿(mǎn)足謂詞的元素。
truncate(len: usize): 將 Vec 的長(zhǎng)度截?cái)酁橹付ㄩL(zhǎng)度。
dedup(): 移除 Vec 中相鄰的重復(fù)元素。
dedup_by_key<F>(&mut self, key: F)：使用指定的鍵函數(shù)，移除 Vec 中相鄰的具有相同鍵的元素。
clone_from(&self, source: &[T]): 從指定的 slice 復(fù)制元素到 Vec 中。
extend<I>(&mut self, iter: I)：將迭代器中的元素添加到 Vec 的末尾。
extend_from_slice(slice: &[T]): 將 slice 中的元素添加到 Vec 的末尾。
resize(&mut self, new_len: usize, value: T)：將 Vec 的長(zhǎng)度更改為指定長(zhǎng)度，并使用指定的值填充新元素。
resize_with<F>(&mut self, new_len: usize, f: F)：將 Vec 的長(zhǎng)度更改為指定長(zhǎng)度，并使用指定的函數(shù)填充新元素。
swap_remove(index: usize) -> T：刪除并返回指定位置的元素，并用最后一個(gè)元素替換它。
truncate(len: usize): 將 Vec 的長(zhǎng)度截?cái)酁橹付ㄩL(zhǎng)度。

resize_with<F>(&mut self, new_len: usize, f: F)：將 Vec 的長(zhǎng)度更改為指定長(zhǎng)度，并使用指定的函數(shù)生成新元素。
try_reserve(n: usize) -> Result<(), AllocError>：嘗試為至少包含指定數(shù)量的元素的 Vec 分配空間。
shrink_to_fit(): 縮小 Vec 的容量以匹配其當(dāng)前長(zhǎng)度。
as_ptr() -> *const T：返回 Vec 的指針。
as_mut_ptr() -> *mut T：返回 Vec 的可變指針。
capacity() -> usize：返回 Vec 的容量。
reserve(&mut self, additional: usize)：為 Vec 分配額外的空間。
reserve_exact(&mut self, additional: usize)：為 Vec 分配確切的額外空間。
set_len(&mut self, len: usize)：設(shè)置 Vec 的長(zhǎng)度，不檢查新長(zhǎng)度是否小于或大于容量。
into_boxed_slice(self) -> Box<[T]>：將 Vec 轉(zhuǎn)換為包含所有元素的堆分配數(shù)組。
into_raw_parts(self) -> (*mut T, usize, usize)：將 Vec 轉(zhuǎn)換為原始指針，長(zhǎng)度和容量的三元組。

into_boxed_slice(self) -> Box<[T]>：將 Vec 轉(zhuǎn)換為包含所有元素的 Box<[T]>。
into_raw_parts(self) -> (*mut T, usize, usize)：將 Vec 轉(zhuǎn)換為其原始指針、長(zhǎng)度和容量的元組。
from_raw_parts(ptr: *mut T, len: usize, cap: usize) -> Vec<T>：從原始指針、長(zhǎng)度和容量的元組創(chuàng)建 Vec。
from_raw_parts_mut(ptr: *mut T, len: usize, cap: usize) -> Vec<T>：從原始指針、長(zhǎng)度和容量的元組創(chuàng)建可變的 Vec。
drain<R>(&mut self, range: R) -> Drain<'_, T>：刪除指定范圍內(nèi)的元素，并返回一個(gè)迭代器，該迭代器遍歷已刪除的元素。

splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, R::End, I::IntoIter>：將指定范圍內(nèi)的元素替換為迭代器中的元素，并返回一個(gè)迭代器，該迭代器遍歷已刪除的元素。
retain<F>(&mut self, f: F)：在保留滿(mǎn)足給定謂詞的元素的同時(shí)，移除不滿(mǎn)足謂詞的元素。
partition<F>(&mut self, f: F) -> (Vec<T>, Vec<T>)：根據(jù)給定謂詞，將 Vec 中的元素分成兩個(gè)新 Vec。
sort(&mut self)：對(duì) Vec 中的元素進(jìn)行排序。
sort_by_key<K, F>(&mut self, key: F)：使用指定的鍵函數(shù)，對(duì) Vec 中的元素進(jìn)行排序。
sort_by<F>(&mut self, compare: F)：使用指定的比較函數(shù)，對(duì) Vec 中的元素進(jìn)行排序。
sort_unstable(): 對(duì) Vec 中的元素進(jìn)行不穩(wěn)定排序。
splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<'_, R::End, I::IntoIter>：將指定范圍內(nèi)的元素替換為迭代器中的元素，并返回一個(gè)迭代器，該迭代器遍歷已刪除的元素。
split_off(&mut self, at: usize) -> Vec<T>：將 Vec 拆分為兩個(gè) Vec，從指定位置開(kāi)始拆分。
swap_remove(&mut self, index: usize) -> T：刪除指定索引處的元素并返回它。
swap_remove_item(&mut self, item: &T) -> bool：查找并刪除第一個(gè)等于給定元素的元素，并返回是否找到該元素。
truncate(&mut self, len: usize)：將 Vec 的長(zhǎng)度截?cái)酁橹付ㄩL(zhǎng)度。
unwrap()：將包裝在 Option 中的 Vec 解包，如果是 None，則 panic。
unwrap_or(default: Vec<T>) -> Vec<T>：將包裝在 Option 中的 Vec 解包，如果是 None，則返回提供的默認(rèn)值。
unwrap_or_default() -> Vec<T>：將包裝在 Option 中的 Vec 解包，如果是 None，則返回默認(rèn)值。

unwrap_or(default: Vec<T>) -> Vec<T>：將包裝在 Option 中的 Vec 解包，如果是 None，則返回指定的默認(rèn)值。
unwrap_or_else<F: FnOnce() -> Vec<T>>(f: F) -> Vec<T>：將包裝在 Option 中的 Vec 解包，如果是 None，則調(diào)用指定的函數(shù)生成默認(rèn)值。
zip<U>(self, other: U) -> Zip<Self, U::IntoIter>：創(chuàng)建一個(gè)迭代器，該迭代器通過(guò)將 self 和其他迭代器的元素進(jìn)行配對(duì)來(lái)生成元組。
iter() -> Iter<'_, T>：返回一個(gè)迭代器，該迭代器遍歷 Vec 的元素。
iter_mut() -> IterMut<'_, T>：返回一個(gè)可變迭代器，該迭代器遍歷 Vec 的元素。
into_iter(self) -> IntoIter<T>：將 Vec 轉(zhuǎn)換為其元素的迭代器。
len() -> usize：返回 Vec 的長(zhǎng)度。
is_empty() -> bool：如果 Vec 為空，則返回 true，否則返回 false。
last() -> Option<&T>：返回 Vec 的最后一個(gè)元素的引用，如果 Vec 為空，則返回 None。
last_mut() -> Option<&mut T>：返回 Vec 的最后一個(gè)元素的可變引用，如果 Vec 為空，則返回 None。
split_first(&self) -> Option<(&T, &[T])>：返回 Vec 的第一個(gè)元素的引用和剩余元素的 slice，如果 Vec 為空，則返回 None。
split_first_mut(&mut self) -> Option<(&mut T, &mut [T])>：返回 Vec 的第一個(gè)元素的可變引用和剩余元素的可變 slice，如果 Vec 為空，則返回 None。

is_empty() -> bool：如果 Vec 為空，則返回 true，否則返回 false。
as_slice(&self) -> &[T]：將 Vec 轉(zhuǎn)換為其元素的切片。
as_mut_slice(&mut self) -> &mut [T]：將 Vec 轉(zhuǎn)換為其元素的可變切片。
last(&self) -> Option<&T>：返回 Vec 的最后一個(gè)元素的引用，如果 Vec 為空，則返回 None。
last_mut(&mut self) -> Option<&mut T>：返回 Vec 的最后一個(gè)元素的可變引用，如果 Vec 為空，則返回 None。
first(&self) -> Option<&T>：返回 Vec 的第一個(gè)元素的引用，如果 Vec 為空，則返回 None。
first_mut(&mut self) -> Option<&mut T>：返回 Vec 的第一個(gè)元素的可變引用，如果 Vec 為空，則返回 None。
binary_search(&self, x: &T) -> Result<usize, usize>：在已排序的 Vec 中搜索指定元素，并返回其索引。
sort(&mut self)：按升序?qū)?Vec 的元素進(jìn)行排序。
sort_by_key<K, F>(&mut self, f: F)：按升序?qū)?Vec 的元素進(jìn)行排序，其中排序關(guān)鍵字由指定的函數(shù)生成。
sort_by<F>(&mut self, compare: F)：按升序?qū)?Vec 的元素進(jìn)行排序，其中比較函數(shù)由指定的函數(shù)生成。

binary_search(&self, x: &T) -> Result<usize, usize>：在已排序的 Vec 中搜索指定元素，并返回它的索引。如果元素不存在，則返回 Err，該 Err 包含元素應(yīng)該插入的位置的索引。
binary_search_by<F>(&self, f: F) -> Result<usize, usize> where F: FnMut(&T) -> Ordering：在已排序的 Vec 中使用指定的比較函數(shù)搜索指定元素，并返回它的索引。如果元素不存在，則返回 Err，該 Err 包含元素應(yīng)該插入的位置的索引。
binary_search_by_key<K, F>(&self, key: &K, f: F) -> Result<usize, usize> where F: FnMut(&T) -> K, K: Ord：在已排序的 Vec 中使用指定的鍵函數(shù)搜索指定鍵，并返回它的索引。如果鍵不存在，則返回 Err，該 Err 包含鍵應(yīng)該插入的位置的索引。
sort(&mut self)：對(duì) Vec 中的元素進(jìn)行排序。
sort_by<F>(&mut self, compare: F)：使用指定的比較函數(shù)對(duì) Vec 中的元素進(jìn)行排序。
sort_by_key<K, F>(&mut self, f: F)：使用指定的鍵函數(shù)對(duì) Vec 中的元素進(jìn)行排序。
reverse(&mut self)：反轉(zhuǎn) Vec 中元素的順序。
split_off(&mut self, at: usize) -> Vec<T>：將 Vec 拆分為兩個(gè) Vec，從指定位置開(kāi)始拆分。

chunks(&self, chunk_size: usize) -> Chunks<'_, T>：返回一個(gè)迭代器，該迭代器遍歷 Vec 的不重疊的塊，每個(gè)塊包含指定數(shù)量的元素。
chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<'_, T>：返回一個(gè)可變迭代器，該迭代器遍歷 Vec 的不重疊的塊，每個(gè)塊包含指定數(shù)量的元素。
windows(&self, window_size: usize) -> Windows<'_, T>：返回一個(gè)迭代器，該迭代器遍歷 Vec 的連續(xù)窗口，每個(gè)窗口包含指定數(shù)量的元素。
try_fold<B, F, R>(&self, init: B, f: F) -> R where F: FnMut(B, &T) -> Result<B, R>, R: From<B>：對(duì) Vec 中的每個(gè)元素執(zhí)行指定的操作，并返回結(jié)果。如果任何操作返回 Err，則停止并返回 Err，否則返回 Ok。
try_for_each<F, R>(&self, f: F) -> R where F: FnMut(&T) -> Result<(), R>, R: From<()>：對(duì) Vec 中的每個(gè)元素執(zhí)行指定的操作，并返回結(jié)果。如果任何操作返回 Err，則停止并返回 Err，否則返回 Ok。

try_for_each<F, R>(&self, f: F) -> R where F: FnMut(&T) -> Result<(), R>, R: From<()>：對(duì) Vec 中的每個(gè)元素執(zhí)行指定的操作，并返回結(jié)果。如果任何操作返回 Err，則停止并返回 Err，否則返回 Ok。
contains(&self, x: &T) -> bool：如果 Vec 包含指定的元素，則返回 true，否則返回 false。
dedup(&mut self)：刪除 Vec 中的重復(fù)元素。只保留第一次出現(xiàn)的元素。
dedup_by_key<F>(&mut self, key: F)：刪除 Vec 中的重復(fù)元素。只保留第一次出現(xiàn)的元素。比較是使用指定的鍵函數(shù)進(jìn)行的。
retain<F>(&mut self, f: F)：從 Vec 中刪除不滿(mǎn)足指定條件的所有元素。
split_off(&mut self, at: usize) -> Vec<T>：從 Vec 中分離指定索引之后的所有元素，并返回一個(gè)新的 Vec。
truncate(&mut self, len: usize)：將 Vec 的長(zhǎng)度截?cái)酁橹付ㄩL(zhǎng)度。如果指定長(zhǎng)度小于 Vec 的當(dāng)前長(zhǎng)度，則刪除多余的元素。

三、Vec的簡(jiǎn)單實(shí)現(xiàn)及其宏模擬

trait MyVec {
    type Item;
    fn new() -> Self;
    fn len(&self) -> usize;
    fn push(&mut self, element: Self::Item);
    fn pop(&mut self) -> Option<Self::Item>;
}

impl<T> MyVec for Vec<T> {
    type Item = T;

    fn new() -> Vec<T> {
        Vec::new()
    }

    fn len(&self) -> usize {
        Vec::len(self)
    }

    fn push(&mut self, element: T) {
        Vec::push(self, element)
    }
    
    fn pop(&mut self) -> Option<T> {
        Vec::pop(self)
    }
}

macro_rules! myvec {
    ( $( $x:expr ),* ) => {
        {
            let mut vec = <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 實(shí)戰(zhàn)

1. 長(zhǎng)度最小的子數(shù)組 Minimum-size-subarray-sum

給定一個(gè)含有 n 個(gè)正整數(shù)的數(shù)組和一個(gè)正整數(shù) target 。

找出該數(shù)組中滿(mǎn)足其和 ≥ target 的長(zhǎng)度最小的 連續(xù)子數(shù)組 [numsl, numsl+1, ..., numsr-1, numsr] ，并返回其長(zhǎng)度。如果不存在符合條件的子數(shù)組，返回 0 。

示例 1：

輸入：target = 7, nums = [2,3,1,2,4,3]
輸出：2
解釋?zhuān)鹤訑?shù)組 [4,3] 是該條件下的長(zhǎng)度最小的子數(shù)組。

示例 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>) -> 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>) -> 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. 最大子數(shù)組和  Maximum Subarray

給你一個(gè)整數(shù)數(shù)組 nums ，請(qǐng)你找出一個(gè)具有最大和的連續(xù)子數(shù)組（子數(shù)組最少包含一個(gè)元素），返回其最大和。

子數(shù)組 是數(shù)組中的一個(gè)連續(xù)部分。

示例 1：

<strong>輸入：</strong>nums = [-2,1,-3,4,-1,2,1,-5,4]
<strong>輸出：</strong>6
<strong>解釋?zhuān)?lt;/strong>連續(xù)子數(shù)組 [4,-1,2,1] 的和最大，為 6 。

示例 2：

<strong>輸入：</strong>nums = [1]
<strong>輸出：</strong>1

示例 3：

<strong>輸入：</strong>nums = [5,4,-1,7,8]
<strong>輸出：</strong>23

提示：

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

進(jìn)階：如果你已經(jīng)實(shí)現(xiàn)復(fù)雜度為 O(n) 的解法，嘗試使用更為精妙的 分治法 求解。

代碼1： 動(dòng)態(tài)規(guī)劃

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

給你一個(gè) m 行 n 列的矩陣 matrix ，請(qǐng)按照 順時(shí)針螺旋順序 ，返回矩陣中的所有元素。

示例 1：

<strong>輸入：</strong>matrix = [[1,2,3],[4,5,6],[7,8,9]]
<strong>輸出：</strong>[1,2,3,6,9,8,7,4,5]

示例 2：

<strong>輸入：</strong>matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
<strong>輸出：</strong>[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<i32>]) -> Vec<i32> {
    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<i32>>) -> Vec<i32> {
    fn spiral_helper(top: usize, bottom: usize, left: usize, right: usize, res: &mut Vec<i32>, idx: &mut usize, matrix: &Vec<Vec<i32>>) {
        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;
            }
        }
        
        // 矩形邊界變小，遞歸調(diào)用spiral_helper繼續(xù)遍歷
        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]; // 用于記錄遍歷結(jié)果
    let mut idx = 0; // 當(dāng)前結(jié)果數(shù)組的下標(biāo)
    
    // 從矩形最外層開(kāi)始遍歷
    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] 

到此這篇關(guān)于Rust 動(dòng)態(tài)數(shù)組Vec基本概念及用法的文章就介紹到這了,更多相關(guān)Rust 動(dòng)態(tài)數(shù)組Vec內(nèi)容請(qǐng)搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評(píng)論