4. 数据结构

  #include <iostream>
#include <vector>
#include <string>
#include <format>

template<typename T>
void printVector(const std::vector<T>& vec,std::string varname) {
	std::cout << varname << " = {";
	/*
	for (const auto& element : vec) {
		std::cout << element << ",";
	}
	*/
	for (size_t i = 0; i < vec.size(); i++) {
		std::cout << vec[i];
		if (i != vec.size() - 1) {
			std::cout << ", ";
		}
	}
	std::cout<<"}" << std::endl;
}

int main() {
	// 建立 vector
	std::vector<int> vec; // 建立一个空的 vector 
	std::vector<int> vec2(5); // 建立一个长度为 5 的 vector，初始化值默认为 0 
	std::vector<int> vec3(5, 10); // 建立一个长度为 5 的 vector，初始化值为 10  

	// 用定义的 printVector() 函数打印 vector
	printVector(vec,"vec");
	printVector(vec2,"vec2");
	printVector(vec3,"vec3");

	// 使用 push_back() 向 vector 对象添加元素
	vec.push_back(1);
	vec.push_back(2);
	vec.push_back(3);
	vec.push_back(4);
	printVector(vec,"vec");
	vec2.push_back(7);
	printVector(vec2, "vec2");

	// 访问元素
	std::cout << std::format("Using index operator []: {}; or the at() method: {}", vec[1], vec.at(1))<<std::endl;

	// 迭代 vector——使用 range-based for loop 方法
	for (int value : vec) {
		std::cout << value << " ";
	}
	std::cout << std::endl;
	// 迭代 vector——使用迭代器（iterator）
	for (std::vector<int>::iterator it = vec.begin();it != vec.end();++it){ // 可用 auto 替代 std::vector<int>::iterator
		std::cout << *it << " ";
	}
	std::cout << std::endl;
	// 迭代 vector——使用逆向迭代器（reverse_iterator）
	for (std::vector<int>::reverse_iterator it = vec.rbegin(); it != vec.rend(); it++) {
		std::cout << *it << " ";
	}
	std::cout << std::endl;

	// 移除元素——使用 pop_back()方法移除最后一个元素
	vec.pop_back();
	printVector(vec, "vec");
	// 移除元素——使用 erase()方法移除指定的元素 
	vec.erase(vec.begin() + 1);
	printVector(vec, "vec");

	// size() 返回元素的数量
	std::cout << std::format("vec size = {}", vec.size()) << std::endl;
	// capacity() 返回 vector 容器在需要调整大小之前可以容纳的元素数量
	std::cout << std::format("vec capacity = {}", vec.capacity()) << std::endl;
	// clear() 从 vector 容器中移除所有元素
	vec.clear();
	// empty() 检查 vector 是否为空
	std::cout << std::format("vec is empty = {}", vec.empty()) << std::endl;

	return 0;
}
  

  #include <iostream>

void modify(int& num) {
	num += 10;
	std::cout << "Executed function modify().\n";
}

void modifyC(int num) {
	num += 10;
	std::cout << "Executed function modifyC().\n";
}

int main() {
	int value = 5;
	modify(value);
	std::cout << "Modified value: " << value << std::endl;

	modifyC(value);
	std::cout << "Modified value: " << value << std::endl;

	return 0;
}
  

  #include <iostream>
#include <vector>

int main() {
	std::vector<int> vec = { 0,1,2,3,4,5 };
	for (auto i : vec)
		std::cout << i << " ";
	std::cout << std::endl;

	return 0;
}
  

  #include <iostream>
#include <list>
#include <format>

template <typename Container>
void printContainer(const Container& container) {
	std::cout << "{";
	for (auto it = container.begin(); it != container.end(); ++it) {
		std::cout << *it;
		if (std::next(it) != container.end()) {
			std::cout << ",";
		}
	}
	std::cout << "}" << std::endl;
}


int main() {
	// 声明一个链表
	std::list<int> myListA;
	// 用 push_front() 和 push_back() 在首尾追加元素
	myListA.push_front(7);
	myListA.push_back(9);
	printContainer(myListA);

	// 声明并初始化一个链表
	std::list<int> myListB = { 2,3,1,5,4 };
	printContainer(myListB);
	std::list<int> myListC { 6,7,8,9,10 };
	printContainer(myListC);
	std::list<int> myListD({ 11,12,13,14,15 });
	printContainer(myListD);

	// 访问元素。因为链表的元素不是连续存储在内存中，不能使用 [] 运算符随机访问元素，需要使用迭代器或 front() 和 back() 等方法
	int firstElement = myListB.front();
	int lastElement = myListB.back();
	std::cout << std::format("first element = {}; last element = {}\n", firstElement, lastElement);

	// 迭代一个链表——Range-based for loop
	for (int num : myListD) {
		std::cout << num << ' ';
	}
	std::cout << std::endl;

	// 迭代一个链表——使用迭代器
	for (std::list<int>::iterator it = myListC.begin(); it != myListC.end(); ++it) {
		std::cout << *it << " ";
	}
	std::cout << std::endl;

	// 移除元素
	myListD.pop_front();
	myListD.pop_back();
	printContainer(myListD);

	// 使用 erase()方法，配合迭代器移除指定位置的元素 
	auto it = myListC.begin();
	std::advance(it, 2); // 移动迭代器到指定位置，这里为开始位置后的第2位
	myListC.erase(it);
	printContainer(myListC);

	// 指定位置插入元素
	auto it2 = myListC.end();
	std::advance(it2, -2); // 用 std::advance()传入负数反向移动迭代器
	myListC.insert(it2, 8);
	printContainer(myListC);

	// 清空链表，即移除所有元素
	myListC.clear();

	// 检查列表是否为空
	if (myListC.empty())
		std::cout << "myListC is empty." << std::endl;

	// 排序和反转链表
	myListB.sort();
	printContainer(myListB);
	myListB.reverse();
	printContainer(myListB);

	return 0;
}
  

  #include <iostream>
#include <deque>
#include <format>

template <typename Container>
void printContainer(const Container& container) {
	std::cout << "{";
	for (auto it = container.begin(); it != container.end(); ++it) {
		std::cout << *it;
		if (std::next(it) != container.end()) {
			std::cout << ",";
		}
	}
	std::cout << "}" << std::endl;
}


int main() {
	// 声明双端队列
	std::deque<int> myDequeA;
	//声明并初始化双端队列
	std::deque<int> myDequeB = { 1,2,3,4,5 };
	// 指定大小和默认值声明并初始化双端队列
	std::deque<int> myDequeC(5, 10);

	// 向双端队列中添加元素
	myDequeA.push_front(9);
	myDequeA.push_back(7);
	myDequeA.push_front(8);
	myDequeA.push_back(6);

	// 打印双端队列元素
	printContainer(myDequeA);
	printContainer(myDequeB);
	printContainer(myDequeC);

	// Range-based for loop 方法迭代双端队列
	std::cout << "myDequeB element: ";
	for (int element : myDequeB)
		std::cout << element << " ";
	std::cout << "\n";

	// 移除双端队列开端和末端的元素
	myDequeB.pop_front();
	myDequeB.pop_back();
	printContainer(myDequeB);

	// 访问元素
	int firstElementIdx = myDequeB[0];
	int firstElementAt = myDequeB.at(0);
	std::cout << std::format("Using idx: {}; Using at: {}", firstElementIdx, firstElementAt) << std::endl;

	int frontElement = myDequeB.front();
	int backElement = myDequeB.back();
	std::cout << std::format("front(): {}; back(): {}", frontElement, backElement) << std::endl;

	// 双端队列大小和是否为空
	std::cout << "Size of myDequeB: " << myDequeB.size() << "\n";
	std::cout << std::format("Is myDequeB empty ? {}\n", myDequeB.empty());

	return 0;
}
  

  #include <iostream>
#include <set>
#include <format>

template <typename Container>
void printContainer(const Container& container) {
	std::cout << "{";
	for (auto it = container.begin(); it != container.end(); ++it) {
		std::cout << *it;
		if (std::next(it) != container.end()) {
			std::cout << ",";
		}
	}
	std::cout << "}" << std::endl;
}


int main() {
	// 声明集合并插入元素
	std::set<int> mySetA;
	mySetA.insert(7);
	mySetA.insert(3);
	mySetA.insert(7); //重复的元素并不会被加入集合中

	printContainer(mySetA);

	// 声明并初始化集合
	std::set<int> mySetB = { 1,2,3,4,5 };
	printContainer(mySetB);
	std::set<int> mySetC { 6,7,8,9,10 };
	printContainer(mySetC);
	std::set<int> mySetD({ 11,12,13,14,15 });
	printContainer(mySetD);

	// 迭代集合
	for (auto it = mySetB.begin(); it != mySetB.end(); ++it) {
		std::cout << *it << " ";
	}
	std::cout << "\n";

	// range-based for loop 方法迭代集合
	for (int x : mySetC) {
		std::cout << x << " ";
	}
	std::cout << "\n";

	// 查找元素。 find()函数搜索一个元素并返回一个迭代器。如果未找到该元素则返回 mySet.end()
	auto it = mySetD.find(13);
	if (it != mySetD.end()) {
		std::cout << std::format("Found {}\n", *it);
	}
	else {
		std::cout << "13 not found" << std::endl;
	}

	// 移除元素。可以直接移除值，或直接移除迭代器
	mySetD.erase(13);
	mySetD.erase(mySetD.begin());
	printContainer(mySetD);

	// 检查集合大小
	std::cout << std::format("mySetD Size: {}\n", mySetD.size());

	// 移除集合中的所有元素并检查是否为空
	mySetD.clear();
	std::cout << std::format("mySetD is empty: {}\n", mySetD.empty());

	// 自定义排序。默认情况下。std::set 按升序对元素排序，可以使用自定义比较器（comparator）降序创建一个集合
	std::set<int, std::greater<int>> mySetDescending;
	mySetDescending.insert(7);
	mySetDescending.insert(3);
	printContainer(mySetDescending);

	// 范围操作（range operations）。
	auto lower = mySetC.lower_bound(8); // 返回第一个不小于 x 的元素的迭代器
	auto upper = mySetC.upper_bound(8); // 返回第一个大于 x 的元素的迭代器
	if (lower != mySetC.end()) {
		std::cout << std::format("(mySetC) Lower bound of 8: {}\n", *lower);
	}
	if (upper != mySetC.end()) {
		std::cout << std::format("(mySetC) Upper bound of 8: {}\n", *upper);
	}

	// 合并两个集合。重复的元素仅保留一个
	mySetA.insert(mySetB.begin(), mySetB.end());
	printContainer(mySetA);

	// 比较运算符。== 和!=
	std::set<int> mySetF = { 1,2,3,4,5,7 };
	if (mySetA == mySetF) {
		std::cout << "mySetA is equal to mySetF\n";
	}
	else if (mySetA != mySetF){
		std::cout << "mySetA is not equal to mySetF\n";
	}

	return 0;
}
  

  #include <iostream>
#include <set>
#include <format>

template <typename Container>
void printContainer(const Container& container) {
	std::cout << "{";
	for (auto it = container.begin(); it != container.end(); ++it) {
		std::cout << *it;
		if (std::next(it) != container.end()) {
			std::cout << ",";
		}
	}
	std::cout << "}" << std::endl;
}


int main() {
	// 声明并初始化多重集合
	std::multiset<int> myMultiset = { 1,2,2,2,3,3,4,5 };	
	printContainer(myMultiset);
	std::cout << std::format("Counting element 2: {}\n", myMultiset.count(2));
	myMultiset.insert(2);
	std::cout << std::format("After inserting an additional 2, counting element 2: {}\n", myMultiset.count(2));

	return 0;
}
  

  #include <iostream>
#include <map>
#include <format>

template<typename K, typename V, typename F>
void printMap(const std::map<K, V, F>& myMap) {
	std::cout << "{";
	for (auto it = myMap.begin(); it != myMap.end(); ++it) {
		std::cout << it->first << ":" << it->second;
		if (std::next(it) != myMap.end()) {
			std::cout << ", ";
		}
	}
	std::cout << "}" << std::endl;
}

struct CustomCompare {
	bool operator()(const std::string& a, const std::string& b) const {
		return a > b; // /按降序排序
	}
};

int main() {
	//声明空的映射
	std::map<std::string, int> myMapA;

	//用 insert() 和 operator[] 增加键值对
	myMapA.insert({ "apple", 5 });
	myMapA["orange"]= 7;
	myMapA["banana"] = 13;
	printMap(myMapA);

	// 根据键访问映射值
	std::cout << std::format("Value for key 'apple': {}; 'banana': {}\n", myMapA["apple"], myMapA.at("banana"));
	
	// 迭代键值对
	for (const auto& pair:myMapA) {
		std::cout << std::format("{}:{} ", pair.first, pair.second);
	}
	std::cout << "\n";

	std::map<std::string, int>::iterator it_map = myMapA.begin();
	while (it_map != myMapA.end()) {
		std::cout << std::format("{}:{} ", it_map->first, it_map->second);
		++it_map;
	}
	std::cout << "\n";

	// 查找元素
	auto it = myMapA.find("orange");
	if (it != myMapA.end()) {
		std::cout << std::format("Found orange with value: {}\n", it->second);
	}
	else {
		std::cout << "Orange not found\n";
	}

	// 移除元素
	myMapA.erase("banana");
	printMap(myMapA);

	// 检查键值对数量
	std::cout << std::format("Size: {}\n", myMapA.size());

	// 清除映射容器中的所有元素
	myMapA.clear();
	std::cout << std::format("myMapA is empty: {}\n",myMapA.empty());

	// 自定义排序
	std::map<std::string, int, CustomCompare> myCustomMap = {
		{"Henry",21},
		{"Oliver",19},
		{"Lily",33}
	};
	myCustomMap["Emily"] = 67;
	myCustomMap.emplace("Amelia", 39); // 允许原地构造元素，从而避免不必要的复制或移动
	printMap(myCustomMap);

	return 0;
}
  

  #include <iostream>
#include <map>

template<typename K, typename V, typename F>
void printMultiMap(const std::multimap<K, V, F>& myMap) {
	std::cout << "{";
	for (auto it = myMap.begin(); it != myMap.end(); ++it) {
		std::cout << it->first << ":" << it->second;
		if (std::next(it) != myMap.end()) {
			std::cout << ", ";
		}
	}
	std::cout << "}" << std::endl;
}


int main() {
	std::multimap<int, std::string> myMultiMap = {
		{1,"Amelia"},
		{1, "Amelia"},
		{3,"Emily"},
		{4,"Henry"},
		{3,"Emily"},
		{5,"Lily"}	
	};
	printMultiMap(myMultiMap);
	myMultiMap.emplace(3, "Oliver");
	printMultiMap(myMultiMap);

	return 0;
}
  

  #include <iostream>
#include <unordered_set>
#include <unordered_map>


int main() {
	std::unordered_set<int> myUnorderedSet = { 3,2,5,4,1 };
	std::cout << "Contents of unordered_set: ";
	for (const auto& element : myUnorderedSet)
		std::cout << element << " ";
	std::cout << std::endl;

	std::unordered_multiset<int> myUnorderedMultiset = { 3,2,3,5,4,1,5,5 };
	std::cout << "Contents of unordered_multiset: ";
	for (const auto& element : myUnorderedMultiset)
		std::cout << element << " ";
	std::cout << std::endl;

	std::unordered_map<std::string, int> myUnorderedMap = { {"apple",9},{"orange",23} };
	std::cout << "Contents of unordered_map: ";
	for (const auto& pair : myUnorderedMap)
		std::cout << pair.first << ":" << pair.second << " ";
	std::cout << std::endl;

	std::unordered_multimap<std::string, int> myUnorderedMultimap = { {"apple",9},{"orange",23},{"orange",7} };
	std::cout << "Contents of unordered_multimap: ";
	for (const auto& pair : myUnorderedMultimap)
		std::cout << pair.first << ":" << pair.second << " ";
	std::cout << std::endl;

	return 0;
}
  

  #include <iostream>
#include <stack>
#include <format>

int main() {
	// 声明一个栈
	std::stack<int> myStack;

	// 将元素压入堆栈
	myStack.push(10);
	myStack.push(20);
	myStack.emplace(30);
	std::cout << std::format("Stack size after pushes: {}\n", myStack.size());


	// 访问栈顶元素
	std::cout << std::format("Top element: {}\n", myStack.top());

	// 从栈中移除元素
	myStack.pop();
	std::cout << std::format("Top element after one top: {}\n", myStack.top());

	// 检查栈是否为空
	if (!myStack.empty()) {
		std::cout << "The stack is not empty.\n";
	}
	else {
		std::cout << "The stack is empty.\n";
	}

	// 通过弹出 pop() 打印所有元素
	std::cout << "Popping all elements from stack: ";
	while (!myStack.empty()) {
		std::cout << myStack.top() << " ";
		myStack.pop();
	}
	std::cout << std::endl;

	return 0;
}
  

  #include <iostream>
#include <queue>
#include <format>

template <typename T, typename V, typename G>
void printPQueue(std::priority_queue<T,V,G> pq) {
	std::cout << "{";
	if (!pq.empty()) {
		std::cout << pq.top();
		pq.pop();
	}
	while (!pq.empty()) {
		std::cout << "," << pq.top();
		pq.pop();
	}
	std::cout << "}" << std::endl;
}

int main() {
	// 声明一个队列，并将元素压入队列
	std::queue<int> myQueue;
	myQueue.push(10);
	myQueue.push(20);
	myQueue.emplace(30);
	myQueue.emplace(40);

	// 说明先进先出（FIFO）
	std::cout << std::format("Front element: {}; Back element: {}\n", myQueue.front(), myQueue.back());
	myQueue.pop();
	std::cout << std::format("Front element after one pop: {}\n", myQueue.front());

	// 将数组元素压入声明的优先队列
	int arrayA[6] = { 23,10,3,6,7,5 };
	std::priority_queue<int> myPriorityQueueA;
	for (int i = 0; i < sizeof(arrayA) / sizeof(arrayA[0]); i++)
		myPriorityQueueA.push(arrayA[i]);

	// 优先级队列在 c++ 中默认实现为最大堆（heap）
	printPQueue(myPriorityQueueA);

	// 在创建优先级队列时传递参数 std::greater<int>，将其更改为最小堆
	std::priority_queue<int, std::vector<int>, std::greater<int>> myPriorityQueueB(arrayA, arrayA + sizeof(arrayA) / sizeof(arrayA[0]));
	printPQueue(myPriorityQueueB);

	return 0;
}
  

  using System;
using System.Collections.Generic;

class Program
{
    public static void PrintCollection<T>(IEnumerable<T> collection)
    {
        string formatted = "[" + string.Join(",", collection) + "]";
        Console.WriteLine(formatted);
    }


    static void Main()
    {
        // 创建 List<T> 后追加元素
        List<int> numbers = new List<int>(); // 整型
        List<string> names = new List<string>(); // 字符串

        // 添加元素——单个元素
        numbers.Add(30);
        numbers.Add(50);
        names.Add("Amelia");
        names.Add("Lily");
        names.Add("Amelia");

        PrintCollection(numbers);
        PrintCollection(names);

        // 添加元素——添加多个元素
        numbers.AddRange(new int[] { 70, 60, 80 });
        numbers.AddRange([110, 100, 120]);
        PrintCollection(numbers);

        // 创建和初始化 List<T>
        List<string> language = ["C", "C++", "C#", "Python"];
        PrintCollection(language);

        // 通过索引访问元素
        int secondNumber = numbers[1];
        string firstName = names[0];

        Console.WriteLine($"second number: {secondNumber} \nfirst name: {firstName}");

        // 在指定索引处插入元素
        names.Insert(2, "Henry");
        PrintCollection(names);

        // 移除元素
        names.Remove("Amelia"); // 移除第1次出现的指定元素
        PrintCollection(names);

        names.RemoveAt(1); // 移除指定索引处的元素
        PrintCollection(names);

        names.Clear(); // 清除所有元素
        PrintCollection(names);

        // 搜索元素
        int found = numbers.Find(x => x > 70); // 查找符合条件的第一个元素。=> 为 lambda 运算符或箭头运算符
        Console.WriteLine($"(x > 70 in numbers) found the first element: {found}");

        List<int> allNumbersGreaterThan70 = numbers.FindAll(x => x>70); // 查找符合条件的所有元素
        Console.Write("(x > 70 in numbers) found all elements: ");
        PrintCollection(allNumbersGreaterThan70);

        int index = language.IndexOf("C#"); // 查找元素，返回第一次出现该元素的索引
        Console.WriteLine($"Found the index of the first occurence of C#: {index}");

        bool hasCShape = language.Contains("C#"); // 检查一个特定的元素是否在列表中
        Console.WriteLine($"C# in language list: {hasCShape}");

        // 排序和反转
        numbers.Sort(); // 按升序对元素进行排序
        numbers.Reverse(); // 反转元素的顺序
        PrintCollection(numbers);

        // 遍历列表
        foreach (string lan in language) // 用 foreach 方法
        {
            Console.Write($"{lan} ");
        }
        Console.WriteLine();
        for (int i = 0; i< language.Count; i++) // 用 for 循环
        {
            Console.Write($"{language[i]} ");
        }
        Console.WriteLine();

        // 获取列表信息
        Console.WriteLine($"Get the number of elements in the list: {numbers.Count}"); // 获取元素数量
        Console.WriteLine($"Gets or sets the total number of elements the list can hold before resizing: {numbers.Capacity}");
    }
}
  

  using System;
using System.Collections.Generic;

class Program
{
    public static void PrintDictionary<TKey,TValue>(Dictionary<TKey,TValue> dictionary)
    {
        string formatted = "{" + string.Join(",", dictionary.Select(kv => $"{kv.Key}:{kv.Value}")) + "}";
        Console.WriteLine(formatted);   
    }

    public static void PrintCollection<T>(IEnumerable<T> collection)
    {
        string formatted = "[" + string.Join(",", collection) + "]";
        Console.WriteLine(formatted);
    }

    static void Main()
    {
        // 创建一个空字典后添加键值对
        Dictionary<int, string> numberNames= new Dictionary<int, string>();
        Dictionary<string,string> capitals = new Dictionary<string,string>();

        // 添加元素——用 Add() 方法添加键值对
        numberNames.Add(7, "seven");
        numberNames.Add(9, "nine");
        numberNames.Add(11, "eleven");

        // 添加元素——使用索引器（indexer），通过键直接赋值来添加或更新元素
        capitals["China"] = "Beijing";
        capitals["USA"] = "Washington";
        capitals["France"] = "Paris";

        PrintDictionary(numberNames);
        PrintDictionary(capitals);

        // 创建并初始化字典
        Dictionary<string, int> score = new Dictionary<string, int>
        {
            {"Henry",99 },
            {"Oliver",86 },
            {"Emily",91 },
            {"Lily",76 }
        };
        PrintDictionary(score);

        // 访问元素。通过键访问字典中的值
        string name = numberNames[9];
        Console.WriteLine($"9:{name}");
        Console.WriteLine($"Emily:{score["Emily"]}");

        // 移除元素
        score.Remove("Lily"); // 按键移除键值对
        PrintDictionary(score);
         
        score.Clear(); // 清除所有元素（键值对）
        PrintDictionary(score);

        // 检查元素
        bool hasKey = capitals.ContainsKey("USA"); // 检查字典中是否存在指定的键
        bool hasValue = capitals.ContainsValue("Washington"); // 检查字典中是否存在指定的值
        Console.WriteLine($"has key 'USA':{hasKey}; has value 'Washington':{hasValue}");


        // 遍历字典（键值对）
        foreach (var kvp in capitals) // 用 var 推断变量的数据类型
        {
            Console.WriteLine($"Country: {kvp.Key}, Capital: {kvp.Value}");
        }

        foreach (KeyValuePair<int,string> kvp in numberNames){ // 用 KeyValuePair<> 指明变量数据类型
            Console.WriteLine($"Country: {kvp.Key}, Capital: {kvp.Value}");
        }

        // 返回字典键或值的集合
        ICollection<int> numberNames_keys = numberNames.Keys;
        ICollection<string> numberNames_values=numberNames.Values;
        PrintCollection(numberNames_keys);
        PrintCollection(numberNames_values);

        // 获取字典信息——键值对的数量
        Console.WriteLine($"key-value pairs number: {numberNames.Count}");

        // 更新字典元素
        numberNames[11] = "5+6";
        PrintDictionary(numberNames);
    }
}
  

  using System;
using System.Collections.Generic;

class Program
{
    public static void PrintCollection<T>(IEnumerable<T> collection)
    {
        string formatted = "[" + string.Join(",", collection) + "]";
        Console.WriteLine(formatted);
    }

    static void Main()
    {
        // 声明空的哈希集合        
        HashSet<int> numbers = new HashSet<int>();
        PrintCollection(numbers);
        HashSet<string> fruits = new HashSet<string>();

        // 添加元素
        numbers.Add(36);
        numbers.Add(6);
        numbers.Add(20);
        numbers.Add(6);

        fruits.Add("Cherry");
        fruits.Add("Peach");
        fruits.Add("Lemon");
        fruits.Add("Grape");
        PrintCollection(numbers);
        PrintCollection(fruits);

        // 声明并初始化集合
        HashSet<string> names = new HashSet<string> { "Oliver", "Lily", "Henry", "Emily", "Amelia" };
        PrintCollection(names);

        // 移除元素
        fruits.Remove("Lemon"); // 移除指定的元素
        PrintCollection(fruits);

        fruits.Clear(); // 清空集合
        PrintCollection(fruits);

        // 检查元素
        bool hasEmily = names.Contains("Emily");
        Console.WriteLine($"Emily exists in the names set: {hasEmily}");

        // 遍历集合
        foreach (var name in names)
        {
            Console.Write($"{name} ");
        }
        Console.WriteLine();

        // 集合运算。HashSet<T> 支持多种集合运算，如并集（UnionWith）、交集（IntersectWith）、差集（ExceptWith）和对称差运算（SymmetricExceptionWith）等
        HashSet<int> num1 = new HashSet<int> { 1, 2, 3, 4, 5 };
        HashSet<int> copiedNum1=new HashSet<int> (num1);
        HashSet<int> num2 = new HashSet<int> { 3, 4, 5, 6, 7 };
        HashSet<int> num3 = new HashSet<int> { 11,12,13,14,15 };
        num1.UnionWith(num2); // 并集（Union），组合两个集合，并仅保留一个重复元素
        PrintCollection(num1);

        num1.IntersectWith(num2); //交集（Intersection），只保留两个集合中都存在的元素
        PrintCollection(num1);
        
        num2.ExceptWith(copiedNum1); //差集（Difference），删除在另一个集合中可以找到的元素
        PrintCollection(num2);

        copiedNum1.SymmetricExceptWith(num1); // 对称差运算（Symmetric Difference），保留两个集合中非交集的部分
        PrintCollection(copiedNum1);

        // 返回集合中元素的数量
        Console.WriteLine($"The number of names: {names.Count}");
    }
}
  

  using System;
using System.Collections.Generic;

class Program
{
    public static void PrintCollection<T>(IEnumerable<T> collection)
    {
        string formatted = "[" + string.Join(",", collection) + "]";
        Console.WriteLine(formatted);
    }

    static void Main()
    {
        // 创建和初始化队列
        Queue<int> numbers = new Queue<int>();
        Queue<string> names = new Queue<string>(new[] { "Oliver", "Lily", "Henry", "Emily", "Amelia" });

        // 添加元素
        numbers.Enqueue(1);
        numbers.Enqueue(7);
        numbers.Enqueue(5);
        numbers.Enqueue(9);
        numbers.Enqueue(18);

        PrintCollection(numbers);
        PrintCollection(names);

        // 移除元素
        int firstNumber = numbers.Dequeue();// 移除并返回队列中最前面的元素。队列为空时调用此方法会抛出 InvalidOperationException
        Console.WriteLine(firstNumber);
        PrintCollection(numbers);

        // 查看元素
        int nextNumber = numbers.Peek(); // 查看队列中最前面的元素，但不移除它。队列为空时调用此方法会抛出 InvalidOperationException
        Console.WriteLine(nextNumber);
        PrintCollection(numbers);

        // 检查队列状态
        Console.WriteLine($"The number of elements in numbers: {numbers.Count}"); // 返回队列中元素的数量
        Console.WriteLine($"If Henry in names: {names.Contains("Henry")}"); // 检查队列中是否包含指定元素

        // 清空队列
        numbers.Clear();
        bool isEmpty = numbers.Count == 0;
        Console.WriteLine(isEmpty);

        // 遍历队列
        foreach (string name in names)
        {
            Console.Write($"{name} ");
        }
        Console.WriteLine();
    }
}
  

  using System;
using System.Collections.Generic;

class Program
{
    public static void PrintCollection<T>(IEnumerable<T> collection)
    {
        string formatted = "[" + string.Join(",", collection) + "]";
        Console.WriteLine(formatted);
    }

    static void Main()
    {
        // 创建和初始化 Stack<T>
        Stack<int> numbers = new Stack<int>();
        Stack<string> names = new Stack<string>(new[] { "Oliver", "Lily", "Henry", "Emily", "Amelia" });

        // 添加元素
        numbers.Push(1);
        numbers.Push(7);
        numbers.Push(5);
        numbers.Push(9);
        numbers.Push(18);

        PrintCollection(numbers);
        PrintCollection(names);

        // 移除元素
        int topNumber = numbers.Pop(); // 移除并返回栈顶的元素。栈为空时调用此方法会抛出 InvalidOperationException
        Console.WriteLine(topNumber);
        PrintCollection(numbers);

        // 查看元素
        int nextTopNumber = numbers.Peek(); // 查看栈顶的元素，但不移除它。栈为空时调用此方法会抛出 InvalidOperationException
        Console.WriteLine(nextTopNumber);
        PrintCollection(numbers);

        // 检查栈状态
        Console.WriteLine($"The number of elements in the stack: {numbers.Count}"); // 返回栈中元素的数量
        Console.WriteLine($"If Henry in names: {names.Contains("Henry")}"); // 检查栈中是否包含指定的元素

        // 清空栈
        numbers.Clear();
        bool isEmpty = numbers.Count == 0;  
        Console.WriteLine($"numbers is empty: {isEmpty}");

        // 遍历栈
        foreach (var name in names)
        {
            Console.Write($"{name} ");
        }
        Console.WriteLine();

        // 复制栈
        Stack<string> copiedNames=new Stack<string>(names.ToArray());
        PrintCollection(copiedNames);

        // 栈到数组
        string[] arrayName=new string[names.Count*2];
        names.CopyTo(arrayName, names.Count);
        PrintCollection(arrayName);
    }
}
  

  using System;
using System.Collections.Generic;
using System.Net.Http.Headers;

class Program
{
    public static void PrintCollection<T>(IEnumerable<T> collection)
    {
        string formatted = "[" + string.Join(",", collection) + "]";
        Console.WriteLine(formatted);
    }

    static void Main()
    {
        // 创建和初始化链表
        LinkedList<int> numbers = new LinkedList<int>();
        LinkedList<string> names= new LinkedList<string>(new[] { "Oliver", "Lily", "Henry", "Emily", "Amelia" });

        // 添加元素
        numbers.AddFirst(1); // List: 1 在列表的开头添加一个元素
        numbers.AddFirst(2); // List: 2 -> 1
        numbers.AddLast(3); // List: 2 -> 1 -> 3 在列表的末尾添加一个元素
        numbers.AddLast(4); // List: 2 -> 1 -> 3 -> 4
        PrintCollection(numbers);

        var node1 = numbers.Find(1);
        Console.WriteLine(node1);
        numbers.AddAfter(node1, 5); // List: 2 -> 1 -> 5-> 3 -> 4 在指定的现有节点之后添加一个新节点
        numbers.AddBefore(node1, 6); // List: 2 -> 6 -> 1 -> 5-> 3 -> 4 在指定的现有节点之前添加一个新节点
        PrintCollection(numbers);

        // 移除元素
        numbers.Remove(1); // 移除指定节点
        PrintCollection(numbers);

        numbers.RemoveFirst(); // 删除列表中的第一个节点
        numbers.RemoveLast(); // 删除列表中的最后一个节点
        PrintCollection(numbers);

        // 查找元素
        bool hasFive = numbers.Contains(5);
        Console.WriteLine($"5 in numbers: {hasFive}");

        // 遍历链表
        foreach (int number in numbers)
        {
            Console.Write($"{number} ");
        }
        Console.WriteLine();

        // 获取链表节点
        LinkedListNode<int> node = numbers.Find(5);
        if (node != null)
        {
            Console.WriteLine($"Found node: {node}");
        }
    }
}
  

  # 创建列表
my_list = []  # 用 [] 建立一个空列表
fruits = [
    "apple",
    "banana",
    "orange",
    "Cherry",
    "Peach",
]  # 建立仅包含字符串（元素）的列表
mixed = [3.141, "Lemon", 7, True]  # 创建一个混合类型的列表
letters = list("Hello!")  # 用 list 创建一个列表
numbers = list(range(0, 10, 1))  # 用 list 传入 range() 区间建立序列列表
names = list(
    enumerate(["Oliver", "Lily", "Henry", "Emily", "Amelia"], start=1)
)  # 传入可迭代对象建立列表

print(
    f"my_list={my_list}\nfruits={fruits}\nmixed={mixed}\nletters={letters}\nnumbers={numbers}\nnames={names}"
)

# 访问列表元素——使用索引值，列表索引值从 0 开始；为正数从前向后计数；为负数时，从后向前计数
print(f"fruits[0]={fruits[0]}\nfruits[3]={fruits[3]}\nfruits[-2]={fruits[-2]}")

# 修改元素
fruits[3] = "Plum"
# 添加元素
fruits.append("Grape")  # 在末尾添加元素
print(fruits)
fruits.extend(["Kiwi", "Mango", "orange"])  # 追加另一个列表的元素
print(fruits)
fruits.insert(1, "Lemon")  # 在指定位置添加元素
print(fruits)

# 删除元素
fruits.remove("apple")  # 直接删除元素
print(fruits)
popped_fruit = fruits.pop(
    3
)  # 按索引删除元素并返回该索引对应的元素；如果不指定索引则删除并返回最后一个元素
print(popped_fruit)
print(fruits)

del fruits[0]  # 用 del 直接删除指定索引的元素
print(fruits)

# 复制列表
copiedMixed = mixed.copy()  # 用方法 copy() 返回列表的浅复制（shallow copy）
print(copiedMixed)

# 元素计数
print(f"The number of times 'orange' in fruits list: {fruits.count("orange")}")

# 反转列表
copiedMixed.reverse()  # in place
print(copiedMixed)

# 返回元素索引值
print(
    f"The index of the first item whose value is equal to 'orange': {fruits.index("orange")}"
)
print(
    f"To a particular subsequence of the fruits list, 'orange' index: {fruits.index("orange",3)}"
)

# 列表切片/分片（List Slicing）。给始末索引值及步幅值，语法为list[a:b:c]，a为开始值，b为结束值，C为步幅值（默认为1）。三个参数可以配置负值逆序。a 或 b 忽略时则默认为从始或到末
# Slicing——访问列表元素
subset_1 = numbers[1:5:2]
print(subset_1)
print(numbers[:3])
print(numbers[-3:-1])
print(numbers[-3:])
print(numbers[:])

# Slicing——分片赋值
numbers[5:8] = list(range(10, 13))
print(numbers)
numbers[2:2] = [101, 102, 103]  # 相当于在索引 2 处插入了另一个列表
print(numbers)

# Slicing——删除元素
del numbers[2:8]
print(numbers)

# 排序列表
numbers.sort()  # in place
print(numbers)

# 内置函数：求最大值、最小值、求和、计算列表的长度
print(
    f"Max value: {max(numbers)}; Min vvalue: {min(numbers)}; Sum: {sum(numbers)}；list length: {len((numbers))}"
)

# 清空列表
numbers.clear()
print(len(numbers))

# 嵌套列表
nested_list = [[1, 2], [3, 4]]
print(nested_list[1][0])

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

flipped_matrix = [
    [row[i] for row in matrix] for i in range(4)
]  # 使用了列表推导式（参语句考循环部分）
print(flipped_matrix)
  

  # 建立元组
tup = (
    2,
    5,
    6,
)
print(tup)
print(type(tup))
print(type((2, 5, 6)))

print(3 * (20 * 3))  # 为表达式
print(3 * (20 * 3,))  # 为元组

tup_0 = tuple([5, 8, 9])
print(tup_0)
tup_1 = tuple((5, 8, 9))
print(tup_1)

tup_0N1 = tup_0 + tup_1
print(tup_0N1)

print(tup_0N1.count(5))
print(tup_0N1.index(8))

# 元组可以嵌套（嵌套元组）
nested_tup = tup, (11, 12, 13)
print(nested_tup)

# 列表中具有保持序列不变性的方法同样适用于元组
print(tup[1])
print(tup[:2])
print(
    f"Max value: {max(tup)}; Min vvalue: {min(tup)}; Sum: {sum(tup)}；list length: {len((tup))}"
)

# 元组是不可变对象
tup_0N1[2] = (
    9999  # 尝试修改项值时，将提示错误，TypeError: 'tuple' object does not support item assignment
)
  

  # 建立字典
score = {"Henry": 99, "Oliver": 86, "Emily": 91, "Lily": 76}  # 使用 {} 建立字典
capitals = dict(
    China="Beijing", USA="Washington", France="Paris"
)  # 使用 dict() 建立字典

# 建立空字典并添加元素
numberNames = {}
numberNames[7] = "seven"
numberNames[9] = "nine"
numberNames[11] = "eleven"

print(f"score={score}\ncapitals={capitals}\nnumberNames={numberNames}")

# 其它建立字典的方式
a = dict(one=1, two=2, three=3)
b = {'one': 1, 'two': 2, 'three': 3}
c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
d = dict([('two', 2), ('one', 1), ('three', 3)])
e = dict({'three': 3, 'one': 1, 'two': 2})
f = dict({'one': 1, 'three': 3}, two=2)
print(a == b == c == d == e == f)

# 访问字典元素
name = numberNames[9]
print(name)
print(f"{capitals["China"]}")
print(
    f"{capitals.get("UK","Not Found!")}"
)  # 通过键提取元素，如果键不存在则会引发 KeyError 异常，可以使用 get()方法安全访问
print(f"{capitals.get("USA","Not Found!")}")

# 添加或更新键值对
numberNames[11] = "5+6"
numberNames[13] = "thirteen"
print(numberNames)

# 删除键值对——使用 pop() 方法，返回键对应的元素
eleven = numberNames.pop(11)
print(eleven)

# 删除键值对——使用 popitem() 方法，删除并返回最后一个插入的键值对
last_item = numberNames.popitem()
print(last_item)

# 删除键值对——使用 del 关键字
del numberNames[7]
print(numberNames)

# 检查字典是否有给定的键
if "Lily" in score:
    print("Lily exists in the score dictionary.")

# 计算字典键值对的数量
print(f"The number of kvps: {len(score)}")

# 遍历字典
for key in score:  # 遍历键。或 for key in score.keys()
    print(f"{key}: {score[key]}", end=" ")
print()
for value in score.values():  # 遍历值
    print(f"{value}", end=" ")
print()
for key, value in score.items():  # 遍历键值对
    print(f"{key}:{value}", end=" ")
print()

# 复制字典
copied_score = score.copy()  # 为浅复制（shallow copy）

# 更新字典
score_supplementary = dict(Oliver=150, Amelia=59)
score.update(
    score_supplementary
)  # 用 update() 更新字典，如果已存在键，则更新其元素；否则，增加该键值对
print(score)

copied_score.setdefault(
    "Amelia", 59
)  # setdefault() 方法仅能增加当前字典中不存在的键。如果传入了已有的键，则不更新，可以避免对原有参数无意中的修改
copied_score.setdefault("Olive", 150)
print(copied_score)

tel1 = {"jack": 4098, "sape": 4139}
tel2 = {"guido": 4127, "sape": 0000}
tel = tel1 | tel2  # 在 Python 3.9 及以后版本中，可以使用 | 操作符合并字典
print(tel)

# 清空字典
tel.clear()
print(tel)

# 嵌套字典
nested_dict = {
    "person1": {"name": "Alice", "age": 25},
    "person2": {"name": "Bob", "age": 30},
}

print(nested_dict["person1"]["name"])
  

  # 建立集合。重复的元素会被移除
num1 = {1, 2, 3, 4, 5}  # 使用 {} 建立集合
num2 = set([3, 3, 4, 5, 6, 7])  # 使用 set() 函数
num3 = {11, 12, 13, 14, 15}
empty_set = set()  # 建立空的集合

print(f"num1={num1}\nnum2={num2}\nnum3={num3}\nempty_set={empty_set}")

# 添加元素
empty_set.add(14)  # add() 方法添加单个元素
empty_set.update([15, 16, 17, 18])  # 用 update()方法添加多个元素

print(empty_set)

# 循环遍历集合来访问集合元素
for item in num1:
    print(f"{item}", end=" ")
print()

# 删除元素
empty_set.remove(14)  # 用 remove() 根据值删除元素。如果元素不存在，会引发 KeyError
print(empty_set)
empty_set.discard(16)  # 用discard() 根据值删除元素。如果元素不存在，不会引发错误
print(empty_set)
removed_item = (
    empty_set.pop()
)  # 随机删除并返回一个元素。由于集合是无序的，无法预测删除哪个元素
print(f"removed item: {removed_item}; empty_set: {empty_set}")
empty_set.clear()  # 清空集合
print(empty_set)

# 浅复制
copied_num3 = num3.copy()

# 获取集合的元素数量
print(f"The number of elements in copied_num3 set: {len(copied_num3)}")

# 成员运算符

print(f"If 13 in copied_num3: {13 in copied_num3}")

# 集合到列表
unique_list = list(num3)
print(unique_list)

# 集合的运算
S_1 = set([1, 2, 3, 4, 5])
S_2 = set([4, 5, 6, 7, 8])
S_1_copy1, S_1_copy2, S_1_copy3 = [S_1.copy() for i in range(3)]
S_2_copy1, S_2_copy2, S_2_copy3 = [S_2.copy() for i in range(3)]
print(S_1)
print(S_2)
print("_" * 50)

## 并集
print(S_1 | S_2)
print(S_1.union(S_2))
print("_" * 50)

## 交集
print(S_1 & S_2)
print(S_1.intersection(S_2))
print("_" * 50)

## 差集
print(S_1 - S_2)
print(S_1.difference(S_2))
print(S_2 - S_1)
print(S_2.difference(S_1))
print("_" * 50)

## symmetric对称差集
print(S_1 ^ S_2)
print(S_1.symmetric_difference(S_2))
print("_" * 50)

print("#" * 50)
S_1_copy1.intersection_update(S_2_copy1)
print(S_1_copy1)

S_1_copy2.difference_update(S_2_copy2)
print(S_1_copy2)

S_1_copy3.symmetric_difference_update(S_2_copy3)
print(S_1_copy3)

print("_" * 50)
print(S_1.isdisjoint(S_2))

print(set([1, 2]).issubset(S_1))
print(S_1.issuperset(set([1, 2])))

# frozenset()——不可变（immutable）集合
FS_1 = frozenset([1, 2, 3, 4, 5])
FS_2 = frozenset([4, 5, 6, 7, 8])

print("_" * 50)
print(FS_1.isdisjoint(FS_2))
print(FS_1.difference(FS_2))
print(FS_1 | FS_2)