C++数据结构

数组(Array

数组是最基础的数据结构，用于存储一组相同类型的数据

Other'S DataStruct都是基于此衍生或迭代，如Java集合框架 容器类集成C++标准库(STL)接口

• 固定大小，一旦声明，大小不能改变
• 直接访问元素，时间复杂为O(1)
• 适合处理大小已知，元素类型相同的集合

#include <iostream>
using namespace std;
int main()
{
int arr[5] = {1,2,3,4,5};
cout << arr[0]; //索引退化
cout << arr[5];  //越界访问，出现未定义行为
}

优缺点

• 优点：访问速度快，内存紧凑
• 缺点：大小固定，无法动态扩展，不适合处理大小不确定的数据集

容器数组(Array

• 强类型安全
• 数组的大小在编译时确定，不能在运行时改变
• 提供与vector类似的接口，具有对象语意，功能更丰富

#include <iostream>
#include <array>
using namespace std;
int main()
{
    array<int,5> myArray = {1,2,3,4,5};
    // 获取数组大小
    cout << "Array size: " << myArray.size() << endl;
    cout << myArray[0] << endl; //索引退化
    cout << "Is array empty? " << (myArray.empty()?"Yes":"No") << endl;  //空检查
    cout << "First ele: " << myArray.front() << endl; //第一元素
    cout << "Last ele: " << myArray.back() << endl;  //最后元素
    cout << myArray.at(6); //提供at边界检查,运行时抛出异常
}

结构体(Struct

结构体允许将不同的数据聚合在一起，形成一种自定义的数据类型

• 可以包含不同类型的成员变量
• 提供了对数据的基本封装，但功能有限

#include <iostream>
using namespace std;
struct Person {
  string name;
  int age;
  Person(string n,int a) : name(n),age(a) {} //构造器
}; //结构体末尾分号; 可选间接声明结构体变量
int main()
{
Person p1("nagisb",18); //构造器定义
Person p2 = {"nagisb",18}  //直接定义
cout << p1.name << endl;
}

类(Class

作为Struct的高级迭代，功能强大，与外界交互支持继承，封装，多态等特性

• 可以包含成员变量，成员函数，构造函数，析构函数
• 支持面向对象特性，如封装、继承、多态

#include <iostream>
using namespace std;
class Person {
private: //默认,封装的本质就是成员私有化
  string name;
  int age;
public: //公共，封装后与外部交互的入口
  Person(string n,int a) : name(n), age(a) {} //C++的特殊构造器形式
  void printInfo() {
    cout << "Name: " << name << "Age: " << age << endl;
  }
}; //类末尾需要；
int main()
{
  Person p("nagisb",18);
  p.printInfo();
}

链表(Linked List

动态数据结构，由一系列节点组成，每个节点包含数据和指向下个节点的指针(DataStruct概念

• 动态调整大小，不需要提前定义容量
• 插入和删除操作效率高，时间复杂度为O(1)
• 线性查找，时间复杂度为O(n)

#include <iostream>
using namespace std;
struct Node {
  int data;      //本节点数据
  Node* next; //下节点指针
};
Node* head = nullptr;  //头节点
Node* newNode = new Node(10,nullptr);
head = newNode;        //定义新节点

优缺点

• 优点：动态大小，适合频繁插入和删除场景
• 缺点：随机访问效率低，不如数组直接访问快

栈(Stack

栈是种先进后出LIFO,Last In First Out的数据结构，常用于递归，深度优先搜索等场景

• 即只允许在栈顶进行插入和删除操作头部插入，头部弹出
• 时间复杂度为O(1)

#include <iostream>
#include <stack>
using namespace std;
stack<int> s;
s.push(1);
s.push(2);
cout << s.top();  // 输出(被弹出)2
s.pop();

优缺点

• 优点：操作简单，效率高
• 缺点：只能在栈顶操作，访问其他元素需要弹出栈顶元素

队列(Queue

队列是种先进先出FIFO,First In First Out的数据结构，常用于广度优先搜索，任务调度等场景

• 插入操作在队尾进行尾部插入，删除操作在队头进行头部弹出
• 时间复杂度为O(1)

#include <iostream>
#include <queue>
using namespace std;
queue<int> q;
q.push(1);
q.push(2);
cout << q.front(); // 输出(被弹出)1 
q.pop();

优缺点

• 优点：适合按顺序处理数据的场景，如任务调度
• 缺点：无法随机访问元素

双端队列(Deque

双端队列允许在两端进行插入和删除操作，是栈和队列的结合体

• 允许在两端进行插入和删除
• 时间复杂度为O(1)

#include <iostream>
#include <deque>
using namespace std;
deque<int> dq;
dq.push_back(1);
dq.push_front(2);
cout << dq.front();    //输出(被弹出)2
dq.pop_front();

优缺点

• 优点：灵活的双向操作
• 缺点：空间占用较大，适合需要在两端频繁操作的场景

哈希表(Hash Table

哈希表是种通过键值对存储数据的数据结构，支持快速的增删改查等操作，C++种unordered_map是哈希表的实现

• 使用哈希函数快速定位元素，时间复杂度为O(1)
• 不保证元素的顺序

#include <iostream>
#include <unordered_map>
using namespace std;
unordered_map<string,int> hashtable;
hashtable["apple"] = 10;
cout << hashtable["apple"];  //通过键访问，键“对象”

优缺点

• 增删改查效率高
• 无法保证其元素顺序，哈希冲突时性能下降

映射(Map

Map是种有序的键值对容器，底层实现是红黑树。与 unordered_map 不同，它保证键的顺序，查找、插入和删除的时间复杂度为 O(log n)

• 保证元素按键的顺序排列
• 使用二叉搜索树实现

#include <iostream>
#include <string>
#include <map>
using namespace std;
map<string,int> myMap;
myMap["apple"] = 10;
cout << myMap["apple"];    //通过键访问，键“对象”

优缺点

• 优点：元素有序，适合需要按顺序处理数据的场景
• 缺点：操作效率比 unordered_map 略低

集合(Set

集合是种存储唯一元素的有序序列，底层同样为红黑树实现，保证了元素唯一且有序， 其此无序的

#include <iostream>
#include <set>
using namespace std;
set<int> s;
s.insert(1);
s.insert(2);
cout << *s.begin();  //输出起始的1

优缺点

• 优点：自动排序且唯一性
• 缺点：插入和删除效率不如无序集合

动态数组(Vector

vector 是 C++ 标准库提供的动态数组实现，可以动态扩展容量，支持随机访问

• 动态调整大小，Java默认可为动态
• 支持随机访问，时间复杂度为O(1)
• 当容量不足时，动态扩展，时间复杂度为摊销 O(1)

#include <iostream>
#include <vector>
using namespace;
vector<int> v;
v.push_back(1);
v.push_back(2);
cout << v[0] << endl;