از بردارها گرفته تا هاشست: پیمایش ساختارهای داده Rust

fn main() {
    // Create an empty vector
    let mut numbers: Vec<i32> = Vec::new();

    // Create and initialize a vector using a macro
    let mut names = vec!["Alice", "Bob", "Carol"];

    // Add elements to the vector
    numbers.push(1);
    numbers.push(2);
    numbers.push(3);

    // Remove elements from the vector
    numbers.pop(); // Removes and returns the last element

    // Access elements in the vector
    if let Some(first_name) = names.get(0) {
        println!("The first name is: {}", first_name);
    }

    // Iterate through vector elements
    for name in &names {
        println!("{}", name);
    }

    // Modify elements in the vector
    if let Some(first_name) = names.get_mut(0) {
        *first_name = "Dave";
    }

    // Use an iterator to process vector elements
    let numbers_squared: Vec<i32> = numbers.iter().map(|&x| x * x).collect();
    println!("Squared numbers: {:?}", numbers_squared);

    // Extend the vector with additional elements
    numbers.extend([4, 5, 6].iter().copied());

    // Directly access elements using an index
    println!("Second name: {}", names[1]); // Note: Direct indexing may panic
}

use std::collections::HashMap;

fn main() {
    // Create an empty hash map
    let mut book_reviews: HashMap<String, String> = HashMap::new();

    // Add elements to the hash map
    book_reviews.insert("The Hobbit".to_string(), "Excellent fantasy book".to_string());
    book_reviews.insert("The Catcher in the Rye".to_string(), "Classic novel".to_string());

    // Access elements in the hash map
    if let Some(review) = book_reviews.get("The Hobbit") {
        println!("Review of The Hobbit: {}", review);
    }

    // Remove elements from the hash map
    book_reviews.remove("The Catcher in the Rye");

    // Iterate over the hash map
    for (book, review) in &book_reviews {
        println!("{}: {}", book, review);
    }

    // Update elements in the hash map
    book_reviews.entry("The Hobbit".to_string()).or_insert("No review found".to_string());
    book_reviews.entry("1984".to_string()).or_insert("Dystopian science fiction".to_string());

    let mut scores = HashMap::new();

    // Insert directly using `insert`
    scores.insert("Blue", 10);
    scores.insert("Blue", 25); // Overwrites the previous value

    // Use `entry` to update or insert
    scores.entry("Yellow").or_insert(50); // Inserts because "Yellow" does not exist
    scores.entry("Blue").or_insert(50);   // Does nothing because "Blue" already exists

    // Result: {"Blue": 25, "Yellow": 50}

    // Check if a key exists
    if book_reviews.contains_key("1984") {
        println!("Review for 1984 is available.");
    }
}

use std::collections::HashSet;

fn main() {
    // Create an empty set
    let mut numbers = HashSet::new();

    // Add elements to the set
    numbers.insert(1);
    numbers.insert(2);
    numbers.insert(3);

    // Remove an element from the set
    numbers.remove(&3);

    // Check if an element exists in the set
    if numbers.contains(&1) {
        println!("1 is in the set");
    }

    // Iterate over the set
    for number in &numbers {
        println!("{}", number);
    }

    // Set operations: union, intersection, difference, symmetric difference

    // At this point, numbers contain {1, 2}

    let other_numbers = [2, 3, 4].iter().cloned().collect::<HashSet<_>>();
    // other_numbers contain {2, 3, 4}

    let union = numbers.union(&other_numbers).cloned().collect::<HashSet<_>>();
    println!("Union: {:?}", union);
    // Union: `{1, 2, 3, 4}` (all unique elements from both sets)

    let intersection = numbers.intersection(&other_numbers).cloned().collect::<HashSet<_>>();
    println!("Intersection: {:?}", intersection);
    // Intersection: `{2}` (common elements)

    let difference = numbers.difference(&other_numbers).cloned().collect::<HashSet<_>>();
    println!("Difference: {:?}", difference);
    // Difference: `{1}` (elements in `numbers` but not in `other_numbers`)

    let symmetric_difference = numbers.symmetric_difference(&other_numbers).cloned().collect::<HashSet<_>>();
    println!("Symmetric Difference: {:?}", symmetric_difference);
    // Symmetric Difference: `{1, 3, 4}` (elements unique to each set)
}

use std::collections::LinkedList;

fn main() {
    // Create a new empty linked list
    let mut list: LinkedList<i32> = LinkedList::new();

    // Add elements to the back of the list
    list.push_back(1);
    list.push_back(2);

    // Add elements to the front of the list
    list.push_front(0);

    // Pop elements from the front and back of the list
    assert_eq!(list.pop_front(), Some(0));
    assert_eq!(list.pop_back(), Some(2));

    // Iterate over the list
    for elem in list.iter() {
        println!("{}", elem);
    }

    // Modify elements in the list (requires using an iterator)
    let mut iter_mut = list.iter_mut();
    if let Some(first_elem) = iter_mut.next() {
        *first_elem = 3;
    }

    // Print the modified list
    println!("Modified list: {:?}", list);
}

use std::collections::BTreeMap;

fn main() {
    // Create a new empty BTreeMap
    let mut map: BTreeMap<String, i32> = BTreeMap::new();

    // Insert key-value pairs into the BTreeMap
    map.insert("apple".to_string(), 3);
    map.insert("banana".to_string(), 2);
    map.insert("pear".to_string(), 4);

    // Retrieve the value corresponding to a key
    if let Some(v) = map.get("apple") {
        println!("apple: {}", v);
    }

    // Remove a key-value pair
    map.remove("banana");

    // Iterate over the BTreeMap
    for (key, value) in &map {
        println!("{}: {}", key, value);
    }

    // Range query: get all key-value pairs with keys between "apple" and "pear" (inclusive)
    let range = map.range("apple".to_string()..="pear".to_string());
    for (key, value) in range {
        println!("Range query: {}: {}", key, value);
    }
}

use std::collections::BTreeSet;

fn main() {
    // Create a new empty BTreeSet
    let mut set: BTreeSet<i32> = BTreeSet::new();

    // Add elements to the set
    set.insert(12);
    set.insert(5);
    set.insert(18);

    // Check if an element exists
    if set.contains(&12) {
        println!("Set contains 12");
    }

    // Remove an element
    set.remove(&5);

    // Iterate over the set (elements will be in ascending order)
    for num in &set {
        println!("{}", num);
    }

    // Range query: retrieve all elements greater than or equal to 10 and less than 20
    for num in set.range(10..20) {
        println!("Range query: {}", num);
    }
}

use std::collections::BinaryHeap;

fn main() {
    // Create a new empty BinaryHeap
    let mut heap = BinaryHeap::new();

    // Add elements to the heap
    heap.push(1);
    heap.push(5);
    heap.push(2);

    // Peek at the maximum element in the heap without removing it
    if let Some(max) = heap.peek() {
        println!("Max element: {}", max);
    }

    // Remove and return the maximum element
    println!("Removed max element: {}", heap.pop().unwrap());

    // Iterate over the heap (the order of iteration is not sorted)
    for num in &heap {
        println!("{}", num);
    }
}