代码随想录一刷总结

**代码随想录一刷总结**

作为一名程序员，持续学习和进步是非常重要的。最近，我花了大约一个月的时间，一刷《代码随想录》这本书。这本书由作者周海汉编写，内容涵盖了计算机基础、数据结构与算法、操作系统、数据库等多个方面。

**第一部分：计算机基础**

第一部分主要讲述了计算机的基本概念，如二进制、十进制、内存管理等。这些知识对于任何程序员来说都是非常重要的基础。

* **二进制与十进制**:这部分内容主要是关于数字系统的转换，包括二进制与十进制之间的转换，以及如何使用二进制来表示计算机中的数据。
* **内存管理**:这部分内容讲述了计算机中内存的分配和回收，包括栈、堆等不同类型的内存管理。

**第二部分：数据结构与算法**

第二部分主要讲述了数据结构与算法的基本概念，如链表、树、图等。这些知识对于任何程序员来说都是非常重要的基础。

* **链表**:这部分内容主要是关于链表的定义、操作等。
* **树**:这部分内容主要是关于树的定义、操作等。
* **图**:这部分内容主要是关于图的定义、操作等。

**第三部分：操作系统**

第三部分主要讲述了操作系统的基本概念，如进程管理、线程管理等。这些知识对于任何程序员来说都是非常重要的基础。

* **进程管理**:这部分内容主要是关于进程的创建、终止、通信等。
* **线程管理**:这部分内容主要是关于线程的创建、终止、通信等。

**第四部分：数据库**

第四部分主要讲述了数据库的基本概念，如关系模型、SQL 等。这些知识对于任何程序员来说都是非常重要的基础。

* **关系模型**:这部分内容主要是关于关系模型的定义、操作等。
* **SQL**:这部分内容主要是关于 SQL 的定义、操作等。

**总结**

通过一刷《代码随想录》，我对计算机基础、数据结构与算法、操作系统、数据库等多个方面有了更深入的理解。这些知识对于任何程序员来说都是非常重要的基础。希望这篇文章能够帮助到更多的人。

**参考资料**

* 《代码随想录》周海汉编著* 《计算机网络》张涛编著* 《数据结构与算法》王道编著**示例代码**

### 链表的定义和操作

cpp// 定义链表结点struct Node {
 int data;
 Node* next;
};

// 定义链表类class LinkedList {
public:
 Node* head;

 // 构造函数 LinkedList() : head(nullptr) {}

 // 销毁函数 ~LinkedList() { clear(); }

 // 清空链表 void clear() {
 while (head != nullptr) {
 Node* temp = head;
 head = head->next;
 delete temp;
 }
 }

 // 插入结点 void insert(int data) {
 Node* newNode = new Node();
 newNode->data = data;
 newNode->next = head;
 head = newNode;
 }

 // 删除结点 void remove(int data) {
 if (head == nullptr) return;

 if (head->data == data) {
 Node* temp = head;
 head = head->next;
 delete temp;
 return;
 }

 Node* prev = head;
 while (prev->next != nullptr) {
 if (prev->next->data == data) {
 Node* temp = prev->next;
 prev->next = prev->next->next;
 delete temp;
 return;
 }
 prev = prev->next;
 }
 }

 // 打印链表 void print() const {
 Node* temp = head;
 while (temp != nullptr) {
 std::cout << temp->data << " ";
 temp = temp->next;
 }
 std::cout << std::endl;
 }
};

cpp// 定义树结点struct Node {
 int data;
 Node* left;
 Node* right;
};

// 定义树类class Tree {
public:
 Node* root;

 // 构造函数 Tree() : root(nullptr) {}

 // 销毁函数 ~Tree() { clear(); }

 // 清空树 void clear() {
 clear(root);
 root = nullptr;
 }

 // 清空子树 void clear(Node* node) {
 if (node == nullptr) return;

 clear(node->left);
 clear(node->right);

 delete node;
 }

 // 插入结点 void insert(int data) {
 Node* newNode = new Node();
 newNode->data = data;
 newNode->left = newNode->right = nullptr;

 if (root == nullptr) {
 root = newNode;
 return;
 }

 Node* temp = root;
 while (temp != nullptr) {
 if (data < temp->data) {
 if (temp->left == nullptr) {
 temp->left = newNode;
 return;
 }
 temp = temp->left;
 } else {
 if (temp->right == nullptr) {
 temp->right = newNode;
 return;
 }
 temp = temp->right;
 }
 }
 }

 // 删除结点 void remove(int data) {
 root = remove(root, data);
 }

 Node* remove(Node* node, int data) {
 if (node == nullptr) return node;

 if (data < node->data) {
 node->left = remove(node->left, data);
 return node;
 } else if (data > node->data) {
 node->right = remove(node->right, data);
 return node;
 }

 if (node->left == nullptr && node->right == nullptr) {
 delete node;
 return nullptr;
 }

 Node* temp;
 if (node->left == nullptr) {
 temp = node->right;
 delete node;
 return temp;
 } else if (node->right == nullptr) {
 temp = node->left;
 delete node;
 return temp;
 }

 Node* minNode = findMin(node->right);
 node->data = minNode->data;
 node->right = remove(node->right, minNode->data);

 return node;
 }

 // 找到最小结点 Node* findMin(Node* node) {
 while (node->left != nullptr) {
 node = node->left;
 }
 return node;
 }

 // 打印树 void print() const {
 print(root);
 }

 void print(Node* node) const {
 if (node == nullptr) return;

 print(node->left);

 std::cout << node->data << " ";

 print(node->right);
 }
};

cpp// 定义图结点struct Node {
 int data;
 std::vector neighbors;
};

// 定义图类class Graph {
public:
 std::vector nodes;

 // 构造函数 Graph() {}

 // 销毁函数 ~Graph() { clear(); }

 // 清空图 void clear() {
 for (auto& node : nodes) {
 delete[] node.neighbors.data();
 }
 nodes.clear();
 }

 // 添加结点 void addNode(int data) {
 Node newNode;
 newNode.data = data;

 nodes.push_back(newNode);
 }

 // 添加边 void addEdge(int from, int to) {
 for (auto& node : nodes) {
 if (node.data == from) {
 for (auto& neighbor : nodes) {
 if (neighbor.data == to) {
 node.neighbors.push_back(&neighbor);
 return;
 }
 }
 }
 }
 }

 // 删除结点 void removeNode(int data) {
 for (auto it = nodes.begin(); it != nodes.end();) {
 if ((*it).data == data) {
 delete[] (*it).neighbors.data();
 it = nodes.erase(it);
 } else {
 ++it;
 }
 }
 }

 // 删除边 void removeEdge(int from, int to) {
 for (auto& node : nodes) {
 if (node.data == from) {
 for (auto it = node.neighbors.begin(); it != node.neighbors.end();) {
 if ((*it)->data == to) {
 delete *it;
 it = node.neighbors.erase(it);
 } else {
 ++it;
 }
 }
 return;
 }
 }
 }

 // 打印图 void print() const {
 for (auto& node : nodes) {
 std::cout << node.data