1. 双向链表（Doubly Linked List）-----支持双向遍历。

C++实现

#include <iostream>struct Node {int data;Node* prev;Node* next;
};class DoublyLinkedList {
private:Node* head;
public:DoublyLinkedList() : head(nullptr) {}// 在链表末尾插入节点void append(int data) {Node* newNode = new Node{data, nullptr, nullptr};if (!head) {head = newNode;} else {Node* temp = head;while (temp->next) {temp = temp->next;}temp->next = newNode;newNode->prev = temp;}}// 打印链表void print() {Node* temp = head;while (temp) {std::cout << temp->data << " <-> ";temp = temp->next;}std::cout << "nullptr" << std::endl;}~DoublyLinkedList() {Node* temp;while (head) {temp = head;head = head->next;delete temp;}}
};int main() {DoublyLinkedList list;list.append(1);list.append(2);list.append(3);list.print();return 0;
}

2. 循环链表（Circular Linked List）-----尾节点指向头节点。

C语言实现

#include <stdio.h>
#include <stdlib.h>struct Node {int data;struct Node* next;
};// 在循环链表末尾插入节点
void append(struct Node** head, int data) {struct Node* newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = data;if (*head == NULL) {*head = newNode;newNode->next = *head;} else {struct Node* temp = *head;while (temp->next != *head) {temp = temp->next;}temp->next = newNode;newNode->next = *head;}
}// 打印循环链表
void printList(struct Node* head) {if (head == NULL) return;struct Node* temp = head;do {printf("%d -> ", temp->data);temp = temp->next;} while (temp != head);printf("HEAD\n");
}int main() {struct Node* head = NULL;append(&head, 1);append(&head, 2);append(&head, 3);printList(head);return 0;
}

3. 二叉搜索树（Binary Search Tree, BST）--支持插入、查找和中序遍历。

C++实现

#include <iostream>struct TreeNode {int data;TreeNode* left;TreeNode* right;TreeNode(int val) : data(val), left(nullptr), right(nullptr) {}
};// 插入节点
TreeNode* insert(TreeNode* root, int data) {if (root == nullptr) {return new TreeNode(data);}if (data < root->data) {root->left = insert(root->left, data);} else {root->right = insert(root->right, data);}return root;
}// 查找节点
bool search(TreeNode* root, int data) {if (root == nullptr) return false;if (root->data == data) return true;if (data < root->data) return search(root->left, data);return search(root->right, data);
}// 中序遍历
void inorder(TreeNode* root) {if (root != nullptr) {inorder(root->left);std::cout << root->data << " ";inorder(root->right);}
}int main() {TreeNode* root = nullptr;root = insert(root, 5);insert(root, 3);insert(root, 7);insert(root, 2);insert(root, 4);std::cout << "中序遍历结果: ";inorder(root);std::cout << std::endl;std::cout << "查找节点 4: " << (search(root, 4) ? "找到" : "未找到") << std::endl;return 0;
}

4. 图的深度优先搜索（DFS）---深度优先和广度优先遍历。

C++实现

#include <iostream>
#include <list>
#include <vector>class Graph {
private:int V; // 顶点数std::vector<std::list<int>> adj; // 邻接表void DFSUtil(int v, std::vector<bool>& visited) {visited[v] = true;std::cout << v << " ";for (int neighbor : adj[v]) {if (!visited[neighbor]) {DFSUtil(neighbor, visited);}}}public:Graph(int V) : V(V), adj(V) {}void addEdge(int v, int w) {adj[v].push_back(w);}void DFS(int start) {std::vector<bool> visited(V, false);DFSUtil(start, visited);}
};int main() {Graph g(4);g.addEdge(0, 1);g.addEdge(0, 2);g.addEdge(1, 2);g.addEdge(2, 0);g.addEdge(2, 3);g.addEdge(3, 3);std::cout << "从顶点 2 开始的DFS遍历结果: ";g.DFS(2);std::cout << std::endl;return 0;
}

5. 图的广度优先搜索（BFS）

C++实现

#include <iostream>
#include <list>
#include <queue>class Graph {
private:int V; // 顶点数std::vector<std::list<int>> adj; // 邻接表public:Graph(int V) : V(V), adj(V) {}void addEdge(int v, int w) {adj[v].push_back(w);}void BFS(int start) {std::vector<bool> visited(V, false);std::queue<int> queue;visited[start] = true;queue.push(start);while (!queue.empty()) {int v = queue.front();std::cout << v << " ";queue.pop();for (int neighbor : adj[v]) {if (!visited[neighbor]) {visited[neighbor] = true;queue.push(neighbor);}}}}
};int main() {Graph g(4);g.addEdge(0, 1);g.addEdge(0, 2);g.addEdge(1, 2);g.addEdge(2, 0);g.addEdge(2, 3);g.addEdge(3, 3);std::cout << "从顶点 2 开始的BFS遍历结果: ";g.BFS(2);std::cout << std::endl;return 0;
}

6. 堆（Heap）

最小堆（C++实现）-----支持插入和弹出最小元素。

#include <iostream>
#include <vector>
#include <algorithm>class MinHeap {
private:std::vector<int> heap;void heapifyUp(int index) {while (index > 0) {int parent = (index - 1) / 2;if (heap[index] >= heap[parent]) break;std::swap(heap[index], heap[parent]);index = parent;}}void heapifyDown(int index) {int left, right, smallest;while (true) {left = 2 * index + 1;right = 2 * index + 2;smallest = index;if (left < heap.size() && heap[left] < heap[smallest]) {smallest = left;}if (right < heap.size() && heap[right] < heap[smallest]) {smallest = right;}if (smallest == index) break;std::swap(heap[index], heap[smallest]);index = smallest;}}public:void push(int value) {heap.push_back(value);heapifyUp(heap.size() - 1);}int pop() {int root = heap[0];heap[0] = heap.back();heap.pop_back();heapifyDown(0);return root;}void print() {for (int i : heap) {std::cout << i << " ";}std::cout << std::endl;}
};int main() {MinHeap heap;heap.push(5);heap.push(3);heap.push(8);heap.push(1);heap.push(2);heap.print();std::cout << "弹出最小元素: " << heap.pop() << std::endl;heap.print();return 0;
}