xinyin025/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2026-07-16 00:46:06 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Replace 结点 with 节点 (#452)

Browse Source 
* Replace 结点 with 节点
Update the footnotes in the figures

* Update mindmap

* Reduce the size of the mindmap.png
This commit is contained in:
Yudong Jin
2023-04-09 04:32:17 +08:00
committed by GitHub
parent 3f4e32b2b0
commit 1c8b7ef559
395 changed files with 2056 additions and 2056 deletions
Download Patch File Download Diff File Expand all files Collapse all files
codes/c/chapter_array_and_linkedlist/linked_list.c
+13 -13
View File
@@ -6,14 +6,14 @@
#include "../include/include.h"
/* 在链表的结点 n0 之后插入结点 P */
/* 在链表的节点 n0 之后插入节点 P */
void insert(ListNode* n0, ListNode* P) {
ListNode *n1 = n0->next;
P->next = n1;
n0->next = P;
}
/* 删除链表的结点 n0 之后的首个结点 */
/* 删除链表的节点 n0 之后的首个节点 */
// 由于引入了 stdio.h ，此处无法使用 remove 关键词
// 详见 https://github.com/krahets/hello-algo/pull/244#discussion_r1067863888
void removeNode(ListNode* n0) {
@@ -27,7 +27,7 @@ void removeNode(ListNode* n0) {
free(P);
}
/* 访问链表中索引为 index 的结点 */
/* 访问链表中索引为 index 的节点 */
ListNode* access(ListNode* head, int index) {
while (head && head->next && index) {
head = head->next;
@@ -36,7 +36,7 @@ ListNode* access(ListNode* head, int index) {
return head;
}
/* 在链表中查找值为 target 的首个结点 */
/* 在链表中查找值为 target 的首个节点 */
int find(ListNode* head, int target) {
int index = 0;
while (head) {
@@ -52,7 +52,7 @@ int find(ListNode* head, int target) {
/* Driver Code */
int main() {
/* 初始化链表 */
// 初始化各个结点
// 初始化各个节点
ListNode* n0 = newListNode(1);
ListNode* n1 = newListNode(3);
ListNode* n2 = newListNode(2);
@@ -66,23 +66,23 @@ int main() {
printf("初始化的链表为\r\n");
printLinkedList(n0);
/* 插入结点 */
/* 插入节点 */
insert(n0, newListNode(0));
printf("插入结点后的链表为\r\n");
printf("插入节点后的链表为\r\n");
printLinkedList(n0);
/* 删除结点 */
/* 删除节点 */
removeNode(n0);
printf("删除结点后的链表为\r\n");
printf("删除节点后的链表为\r\n");
printLinkedList(n0);
/* 访问结点 */
/* 访问节点 */
ListNode* node = access(n0, 3);
printf("链表中索引 3 处的结点的值 = %d\r\n", node->val);
printf("链表中索引 3 处的节点的值 = %d\r\n", node->val);
/* 查找结点 */
/* 查找节点 */
int index = find(n0, 2);
printf("链表中值为 2 的结点的索引 = %d\r\n", index);
printf("链表中值为 2 的节点的索引 = %d\r\n", index);
return 0;
}
codes/c/chapter_heap/my_heap.c
+16 -16
View File
@@ -27,23 +27,23 @@ maxHeap *newMaxHeap(int nums[], int size) {
h->size = size;
memcpy(h->data, nums, size * sizeof(int));
for (int i = size - 1; i >= 0; i--) {
// 堆化除叶结点以外的其他所有结点
// 堆化除叶节点以外的其他所有节点
siftDown(h, i);
}
return h;
}
/* 获取左子结点索引 */
/* 获取左子节点索引 */
int left(maxHeap *h, int i) {
return 2 * i + 1;
}
/* 获取右子结点索引 */
/* 获取右子节点索引 */
int right(maxHeap *h, int i) {
return 2 * i + 2;
}
/* 获取父结点索引 */
/* 获取父节点索引 */
int parent(maxHeap *h, int i) {
return (i - 1) / 2;
}
@@ -72,12 +72,12 @@ int peek(maxHeap *h) {
/* 元素入堆 */
int push(maxHeap *h, int val) {
// 默认情况下，不应该添加这么多结点
// 默认情况下，不应该添加这么多节点
if (h->size == MAX_SIZE) {
printf("heap is full!");
return NIL;
}
// 添加结点
// 添加节点
h->data[h->size] = val;
h->size++;
@@ -92,9 +92,9 @@ int pop(maxHeap *h) {
printf("heap is empty!");
return NIL;
}
// 交换根结点与最右叶结点（即交换首元素与尾元素）
// 交换根节点与最右叶节点（即交换首元素与尾元素）
swap(h, 0, size(h) - 1);
// 删除结点
// 删除节点
int val = h->data[h->size - 1];
h->size--;
// 从顶至底堆化
@@ -105,10 +105,10 @@ int pop(maxHeap *h) {
}
/* 从结点 i 开始，从顶至底堆化 */
/* 从节点 i 开始，从顶至底堆化 */
void siftDown(maxHeap *h, int i) {
while (true) {
// 判断结点 i, l, r 中值最大的结点，记为 max
// 判断节点 i, l, r 中值最大的节点，记为 max
int l = left(h, i);
int r = right(h, i);
int max = i;
@@ -118,27 +118,27 @@ void siftDown(maxHeap *h, int i) {
if (r < size(h) && h->data[r] > h->data[max]) {
max = r;
}
// 若结点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
// 若节点 i 最大或索引 l, r 越界，则无需继续堆化，跳出
if (max == i) {
break;
}
// 交换两结点
// 交换两节点
swap(h, i, max);
// 循环向下堆化
i = max;
}
}
/* 从结点 i 开始，从底至顶堆化 */
/* 从节点 i 开始，从底至顶堆化 */
void siftUp(maxHeap *h, int i) {
while (true) {
// 获取结点 i 的父结点
// 获取节点 i 的父节点
int p = parent(h, i);
// 当“越过根结点”或“结点无需修复”时，结束堆化
// 当“越过根节点”或“节点无需修复”时，结束堆化
if (p < 0 || h->data[i] <= h->data[p]) {
break;
}
// 交换两结点
// 交换两节点
swap(h, i, p);
// 循环向上堆化
i = p;
codes/c/chapter_searching/linear_search.c
+4 -4
View File
@@ -22,12 +22,12 @@ int linearSearchArray(int *nums, int len, int target) {
ListNode* linearSearchLinkedList(ListNode* head, int target) {
// 遍历链表
while (head != NULL) {
// 找到目标结点，返回之
// 找到目标节点，返回之
if (head->val == target)
return head;
head = head->next;
}
// 未找到目标结点，返回 NULL
// 未找到目标节点，返回 NULL
return NULL;
}
@@ -44,9 +44,9 @@ int main() {
ListNode* head = arrToLinkedList(nums, 10);
ListNode* node = linearSearchLinkedList(head, target);
if(node == NULL) {
printf("目标结点值 3 的对应结点对象为 NULL\n");
printf("目标节点值 3 的对应节点对象为 NULL\n");
} else {
printf("目标结点值 3 的对应结点对象为 addr: %p val: %d\n", node, node->val);
printf("目标节点值 3 的对应节点对象为 addr: %p val: %d\n", node, node->val);
}
return 0;
codes/c/chapter_stack_and_queue/linkedlist_deque.c
+13 -13
View File
@@ -6,16 +6,16 @@
#include "../include/include.h"
/* 双向链表结点 */
/* 双向链表节点 */
struct DoublyListNode {
int val; // 结点值
struct DoublyListNode *next; // 后继结点
struct DoublyListNode *prev; // 前驱结点
int val; // 节点值
struct DoublyListNode *next; // 后继节点
struct DoublyListNode *prev; // 前驱节点
};
typedef struct DoublyListNode DoublyListNode;
/* 双向链表结点构造方法 */
/* 双向链表节点构造方法 */
DoublyListNode *newDoublyListNode(int num) {
DoublyListNode* new = (DoublyListNode *) malloc(sizeof(DoublyListNode));
new->val = num;
@@ -24,14 +24,14 @@ DoublyListNode *newDoublyListNode(int num) {
return new;
}
/* 双向链表结点析构方法 */
/* 双向链表节点析构方法 */
void delDoublyListNode(DoublyListNode *node) {
free(node);
}
/* 基于双向链表实现的双向队列 */
struct LinkedListDeque {
DoublyListNode *front, *rear; // 头结点 front ，尾结点 rear
DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear
int queSize; // 双向队列的长度
};
@@ -47,7 +47,7 @@ LinkedListDeque *newLinkedListDeque() {
/* 析构方法 */
void delLinkedListdeque(LinkedListDeque *deque) {
// 释放所有结点
// 释放所有节点
for (int i=0; i<deque->queSize && deque->front != NULL; i++) {
DoublyListNode *tmp = deque->front;
deque->front = deque->front->next;
@@ -79,7 +79,7 @@ void push(LinkedListDeque *deque, int num, bool isFront) {
// 将 node 添加至链表头部
deque->front->prev = node;
node->next = deque->front;
deque->front = node;// 更新头结点
deque->front = node;// 更新头节点
}
// 对尾入队操作
else {
@@ -120,25 +120,25 @@ int pop(LinkedListDeque *deque, bool isFront) {
int val;
// 队首出队操作
if(isFront) {
val = peekFirst(deque); // 暂存头结点值
val = peekFirst(deque); // 暂存头节点值
DoublyListNode *fNext = deque->front->next;
if (fNext) {
fNext->prev = NULL;
deque->front->next = NULL;
delDoublyListNode(deque->front);
}
deque->front = fNext; // 更新头结点
deque->front = fNext; // 更新头节点
}
// 队尾出队操作
else {
val = peekLast(deque); // 暂存尾结点值
val = peekLast(deque); // 暂存尾节点值
DoublyListNode *rPrev = deque->rear->prev;
if (rPrev) {
rPrev->next = NULL;
deque->rear->prev = NULL;
delDoublyListNode(deque->rear);
}
deque->rear = rPrev; // 更新尾结点
deque->rear = rPrev; // 更新尾节点
}
deque->queSize--; // 更新队列长度
return val;
codes/c/chapter_stack_and_queue/linkedlist_queue.c
+4 -4
View File
@@ -24,7 +24,7 @@ LinkedListQueue *newLinkedListQueue() {
/* 析构方法 */
void delLinkedListQueue(LinkedListQueue *queue) {
// 释放所有结点
// 释放所有节点
for (int i=0; i<queue->queSize && queue->front != NULL; i++) {
ListNode *tmp = queue->front;
queue->front = queue->front->next;
@@ -46,14 +46,14 @@ bool empty(LinkedListQueue *queue) {
/* 入队 */
void push(LinkedListQueue *queue, int num) {
// 尾结点处添加 node
// 尾节点处添加 node
ListNode *node = newListNode(num);
// 如果队列为空，则令头、尾结点都指向该结点
// 如果队列为空，则令头、尾节点都指向该节点
if (queue->front == NULL) {
queue->front = node;
queue->rear = node;
}
// 如果队列不为空，则将该结点添加到尾结点后
// 如果队列不为空，则将该节点添加到尾节点后
else {
queue->rear->next = node;
queue->rear = node;
codes/c/chapter_stack_and_queue/linkedlist_stack.c
+3 -3
View File
@@ -8,7 +8,7 @@
/* 基于链表实现的栈 */
struct linkedListStack {
ListNode *top; // 将头结点作为栈顶
ListNode *top; // 将头节点作为栈顶
int size; // 栈的长度
};
@@ -55,8 +55,8 @@ int peek(linkedListStack *s) {
void push(linkedListStack *s, int num) {
assert(s);
ListNode *node = (ListNode *) malloc(sizeof(ListNode));
node->next = s->top; // 更新新加结点指针域
node->val = num; // 更新新加结点数据域
node->next = s->top; // 更新新加节点指针域
node->val = num; // 更新新加节点数据域
s->top = node; // 更新栈顶
s->size++; // 更新栈大小
}
codes/c/chapter_tree/avl_tree.c
+44 -44
View File
@@ -21,18 +21,18 @@ avlTree *newAVLTree() {
}
int height(TreeNode *node) {
// 空结点高度为 -1 ，叶结点高度为 0
// 空节点高度为 -1 ，叶节点高度为 0
if (node != NULL) {
return node->height;
}
return -1;
}
/* 更新结点高度 */
/* 更新节点高度 */
int updateHeight(TreeNode *node) {
int lh = height(node->left);
int rh = height(node->right);
// 结点高度等于最高子树高度 + 1
// 节点高度等于最高子树高度 + 1
if (lh > rh) {
node->height = lh + 1;
} else {
@@ -42,11 +42,11 @@ int updateHeight(TreeNode *node) {
/* 获取平衡因子 */
int balanceFactor(TreeNode *node) {
// 空结点平衡因子为 0
// 空节点平衡因子为 0
if (node == NULL) {
return 0;
}
// 结点平衡因子 = 左子树高度 - 右子树高度
// 节点平衡因子 = 左子树高度 - 右子树高度
return height(node->left) - height(node->right);
}
@@ -58,10 +58,10 @@ TreeNode *rightRotate(TreeNode *node) {
// 以 child 为原点，将 node 向右旋转
child->right = node;
node->left = grandChild;
// 更新结点高度
// 更新节点高度
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根结点
// 返回旋转后子树的根节点
return child;
}
@@ -73,16 +73,16 @@ TreeNode *leftRotate(TreeNode *node) {
// 以 child 为原点，将 node 向左旋转
child->left = node;
node->right = grandChild;
// 更新结点高度
// 更新节点高度
updateHeight(node);
updateHeight(child);
// 返回旋转后子树的根结点
// 返回旋转后子树的根节点
return child;
}
/* 执行旋转操作，使该子树重新恢复平衡 */
TreeNode *rotate(TreeNode *node) {
// 获取结点 node 的平衡因子
// 获取节点 node 的平衡因子
int bf = balanceFactor(node);
// 左偏树
if (bf > 1) {
@@ -110,54 +110,54 @@ TreeNode *rotate(TreeNode *node) {
return node;
}
/* 递归插入结点（辅助方法） */
/* 递归插入节点（辅助方法） */
TreeNode *insertHelper(TreeNode *node, int val) {
if (node == NULL) {
return newTreeNode(val);
}
/* 1. 查找插入位置，并插入结点 */
/* 1. 查找插入位置，并插入节点 */
if (val < node->val) {
node->left = insertHelper(node->left, val);
} else if (val > node->val) {
node->right = insertHelper(node->right, val);
} else {
// 重复结点不插入，直接返回
// 重复节点不插入，直接返回
return node;
}
// 更新结点高度
// 更新节点高度
updateHeight(node);
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node);
// 返回子树的根结点
// 返回子树的根节点
return node;
}
/* 插入结点 */
/* 插入节点 */
TreeNode *insert(avlTree *tree, int val) {
tree->root = insertHelper(tree->root, val);
return tree->root;
}
/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode *getInOrderNext(TreeNode *node) {
if (node == NULL) {
return node;
}
// 循环访问左子结点，直到叶结点时为最小结点，跳出
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (node->left != NULL) {
node = node->left;
}
return node;
}
/* 递归删除结点（辅助方法） */
/* 递归删除节点（辅助方法） */
TreeNode *removeHelper(TreeNode *node, int val) {
TreeNode *child, *grandChild, *temp;
if (node == NULL) {
return NULL;
}
/* 1. 查找结点，并删除之 */
/* 1. 查找节点，并删除之 */
if (val < node->val) {
node->left = removeHelper(node->left, val);
} else if (val > node->val) {
@@ -168,64 +168,64 @@ TreeNode *removeHelper(TreeNode *node, int val) {
if (node->right != NULL) {
child = node->right;
}
// 子结点数量 = 0 ，直接删除 node 并返回
// 子节点数量 = 0 ，直接删除 node 并返回
if (child == NULL) {
return NULL;
} else {
// 子结点数量 = 1 ，直接删除 node
// 子节点数量 = 1 ，直接删除 node
node = child;
}
} else {
// 子结点数量 = 2 ，则将中序遍历的下个结点删除，并用该结点替换当前结点
// 子节点数量 = 2 ，则将中序遍历的下个节点删除，并用该节点替换当前节点
temp = getInOrderNext(node->right);
node->right = removeHelper(node->right, temp->val);
node->val = temp->val;
}
}
// 更新结点高度
// 更新节点高度
updateHeight(node);
/* 2. 执行旋转操作，使该子树重新恢复平衡 */
node = rotate(node);
// 返回子树的根结点
// 返回子树的根节点
return node;
}
/* 删除结点 */
/* 删除节点 */
// 由于引入了 stdio.h ，此处无法使用 remove 关键词
TreeNode *removeNode(avlTree *tree, int val) {
TreeNode *root = removeHelper(tree->root, val);
return root;
}
/* 查找结点 */
/* 查找节点 */
TreeNode *search(avlTree *tree, int val) {
TreeNode *cur = tree->root;
// 循环查找，越过叶结点后跳出
// 循环查找，越过叶节点后跳出
while (cur != NULL) {
if (cur->val < val) {
// 目标结点在 cur 的右子树中
// 目标节点在 cur 的右子树中
cur = cur->right;
} else if (cur->val > val) {
// 目标结点在 cur 的左子树中
// 目标节点在 cur 的左子树中
cur = cur->left;
} else {
// 找到目标结点，跳出循环
// 找到目标节点，跳出循环
break;
}
}
// 找到目标结点，跳出循环
// 找到目标节点，跳出循环
return cur;
}
void testInsert(avlTree *tree, int val) {
insert(tree, val);
printf("\n插入结点 %d 后，AVL 树为 \n", val);
printf("\n插入节点 %d 后，AVL 树为 \n", val);
printTree(tree->root);
}
void testRemove(avlTree *tree, int val) {
removeNode(tree, val);
printf("\n删除结点 %d 后，AVL 树为 \n", val);
printf("\n删除节点 %d 后，AVL 树为 \n", val);
printTree(tree->root);
}
@@ -233,8 +233,8 @@ void testRemove(avlTree *tree, int val) {
int main() {
/* 初始化空 AVL 树 */
avlTree *tree = (avlTree *) newAVLTree();
/* 插入结点 */
// 请关注插入结点后，AVL 树是如何保持平衡的
/* 插入节点 */
// 请关注插入节点后，AVL 树是如何保持平衡的
testInsert(tree, 1);
testInsert(tree, 2);
testInsert(tree, 3);
@@ -246,16 +246,16 @@ int main() {
testInsert(tree, 10);
testInsert(tree, 6);
/* 插入重复结点 */
/* 插入重复节点 */
testInsert(tree, 7);
/* 删除结点 */
// 请关注删除结点后，AVL 树是如何保持平衡的
testRemove(tree, 8); // 删除度为 0 的结点
testRemove(tree, 5); // 删除度为 1 的结点
testRemove(tree, 4); // 删除度为 2 的结点
/* 删除节点 */
// 请关注删除节点后，AVL 树是如何保持平衡的
testRemove(tree, 8); // 删除度为 0 的节点
testRemove(tree, 5); // 删除度为 1 的节点
testRemove(tree, 4); // 删除度为 2 的节点
/* 查询结点 */
/* 查询节点 */
TreeNode *node = search(tree, 7);
printf("\n查找到的结点对象结点值 = %d \n", node->val);
printf("\n查找到的节点对象节点值 = %d \n", node->val);
}
codes/c/chapter_tree/binary_search_tree.c
+35 -35
View File
@@ -23,7 +23,7 @@ TreeNode *buildTree(int nums[], int i, int j) {
if (i > j) {
return NULL;
}
// 将数组中间结点作为根结点
// 将数组中间节点作为根节点
int mid = (i + j) / 2;
TreeNode *root = newTreeNode(nums[mid]);
// 递归建立左子树和右子树
@@ -43,39 +43,39 @@ binarySearchTree *newBinarySearchTree(int nums[], int size) {
return bst;
}
/* 获取二叉树根结点 */
/* 获取二叉树根节点 */
TreeNode *getRoot(binarySearchTree *bst) {
return bst->root;
}
/* 查找结点 */
/* 查找节点 */
TreeNode *search(binarySearchTree *bst, int num) {
TreeNode *cur = bst->root;
// 循环查找，越过叶结点后跳出
// 循环查找，越过叶节点后跳出
while (cur != NULL) {
if (cur->val < num) {
// 目标结点在 cur 的右子树中
// 目标节点在 cur 的右子树中
cur = cur->right;
} else if (cur->val > num) {
// 目标结点在 cur 的左子树中
// 目标节点在 cur 的左子树中
cur = cur->left;
} else {
// 找到目标结点，跳出循环
// 找到目标节点，跳出循环
break;
}
}
// 返回目标结点
// 返回目标节点
return cur;
}
/* 插入结点 */
/* 插入节点 */
TreeNode *insert(binarySearchTree *bst, int num) {
// 若树为空，直接提前返回
if (bst->root == NULL) return NULL;
TreeNode *cur = bst->root, *pre = NULL;
// 循环查找，越过叶结点后跳出
// 循环查找，越过叶节点后跳出
while (cur != NULL) {
// 找到重复结点，直接返回
// 找到重复节点，直接返回
if (cur->val == num) {
return NULL;
}
@@ -88,7 +88,7 @@ TreeNode *insert(binarySearchTree *bst, int num) {
cur = cur->left;
}
}
// 插入结点 val
// 插入节点 val
TreeNode *node = newTreeNode(num);
if (pre->val < num) {
pre->right = node;
@@ -98,56 +98,56 @@ TreeNode *insert(binarySearchTree *bst, int num) {
return node;
}
/* 获取中序遍历中的下一个结点（仅适用于 root 有左子结点的情况） */
/* 获取中序遍历中的下一个节点（仅适用于 root 有左子节点的情况） */
TreeNode *getInOrderNext(TreeNode *root) {
if (root == NULL) return root;
// 循环访问左子结点，直到叶结点时为最小结点，跳出
// 循环访问左子节点，直到叶节点时为最小节点，跳出
while (root->left != NULL) {
root = root->left;
}
return root;
}
/* 删除结点 */
/* 删除节点 */
// 由于引入了 stdio.h ，此处无法使用 remove 关键词
TreeNode *removeNode(binarySearchTree *bst, int num) {
// 若树为空，直接提前返回
if (bst->root == NULL) return NULL;
TreeNode *cur = bst->root, *pre = NULL;
// 循环查找，越过叶结点后跳出
// 循环查找，越过叶节点后跳出
while (cur != NULL) {
// 找到待删除结点，跳出循环
// 找到待删除节点，跳出循环
if (cur->val == num) break;
pre = cur;
if (cur->val < num) {
// 待删除结点在 root 的右子树中
// 待删除节点在 root 的右子树中
cur = cur->right;
} else {
// 待删除结点在 root 的左子树中
// 待删除节点在 root 的左子树中
cur = cur->left;
}
}
// 若无待删除结点，则直接返回
// 若无待删除节点，则直接返回
if (cur == NULL) {
return NULL;
}
// 判断待删除结点是否存在子结点
// 判断待删除节点是否存在子节点
if (cur->left == NULL || cur->right == NULL) {
/* 子结点数量 = 0 or 1 */
// 当子结点数量 = 0 / 1 时， child = nullptr / 该子结点
/* 子节点数量 = 0 or 1 */
// 当子节点数量 = 0 / 1 时， child = nullptr / 该子节点
TreeNode *child = cur->left != NULL ? cur->left : cur->right;
// 删除结点 cur
// 删除节点 cur
if (pre->left == cur) {
pre->left = child;
} else {
pre->right = child;
}
} else {
/* 子结点数量 = 2 */
// 获取中序遍历中 cur 的下一个结点
/* 子节点数量 = 2 */
// 获取中序遍历中 cur 的下一个节点
TreeNode *nex = getInOrderNext(cur->right);
int tmp = nex->val;
// 递归删除结点 nex
// 递归删除节点 nex
removeNode(bst, nex->val);
// 将 nex 的值复制给 cur
cur->val = tmp;
@@ -163,26 +163,26 @@ int main() {
printf("初始化的二叉树为\n");
printTree(getRoot(bst));
/* 查找结点 */
/* 查找节点 */
TreeNode *node = search(bst, 7);
printf("查找到的结点对象的结点值 = %d\n", node->val);
printf("查找到的节点对象的节点值 = %d\n", node->val);
/* 插入结点 */
/* 插入节点 */
insert(bst, 16);
printf("插入结点 16 后，二叉树为\n");
printf("插入节点 16 后，二叉树为\n");
printTree(getRoot(bst));
/* 删除结点 */
/* 删除节点 */
removeNode(bst, 1);
printf("删除结点 1 后，二叉树为\n");
printf("删除节点 1 后，二叉树为\n");
printTree(getRoot(bst));
removeNode(bst, 2);
printf("删除结点 2 后，二叉树为\n");
printf("删除节点 2 后，二叉树为\n");
printTree(getRoot(bst));
removeNode(bst, 4);
printf("删除结点 4 后，二叉树为\n");
printf("删除节点 4 后，二叉树为\n");
printTree(getRoot(bst));
// 释放内存
codes/c/chapter_tree/binary_tree.c
+6 -6
View File
@@ -9,7 +9,7 @@
/* Driver Code */
int main() {
/* 初始化二叉树 */
// 初始化结点
// 初始化节点
TreeNode* n1 = newTreeNode(1);
TreeNode* n2 = newTreeNode(2);
TreeNode* n3 = newTreeNode(3);
@@ -23,19 +23,19 @@ int main() {
printf("初始化二叉树\n");
printTree(n1);
/* 插入与删除结点 */
/* 插入与删除节点 */
TreeNode* P = newTreeNode(0);
// 在 n1 -> n2 中间插入结点 P
// 在 n1 -> n2 中间插入节点 P
n1->left = P;
P->left = n2;
printf("插入结点 P 后\n");
printf("插入节点 P 后\n");
printTree(n1);
// 删除结点 P
// 删除节点 P
n1->left = n2;
// 释放内存
free(P);
printf("删除结点 P 后\n");
printf("删除节点 P 后\n");
printTree(n1);
return 0;
codes/c/chapter_tree/binary_tree_bfs.c
+5 -5
View File
@@ -18,7 +18,7 @@ int *levelOrder(TreeNode *root, int *size) {
queue = (TreeNode **) malloc(sizeof(TreeNode) * MAX_NODE_SIZE);
// 队列指针
front = 0, rear = 0;
// 加入根结点
// 加入根节点
queue[rear++] = root;
// 初始化一个列表，用于保存遍历序列
/* 辅助数组 */
@@ -28,14 +28,14 @@ int *levelOrder(TreeNode *root, int *size) {
while (front < rear) {
// 队列出队
node = queue[front++];
// 保存结点值
// 保存节点值
arr[index++] = node->val;
if (node->left != NULL) {
// 左子结点入队
// 左子节点入队
queue[rear++] = node->left;
}
if (node->right != NULL) {
// 右子结点入队
// 右子节点入队
queue[rear++] = node->right;
}
}
@@ -59,7 +59,7 @@ int main() {
/* 层序遍历 */
// 需要传入数组的长度
int *arr = levelOrder(root, &size);
printf("层序遍历的结点打印序列 = ");
printf("层序遍历的节点打印序列 = ");
printArray(arr, size);
return 0;
codes/c/chapter_tree/binary_tree_dfs.c
+6 -6
View File
@@ -12,7 +12,7 @@ int *arr;
/* 前序遍历 */
void preOrder(TreeNode *root, int *size) {
if (root == NULL) return;
// 访问优先级：根结点 -> 左子树 -> 右子树
// 访问优先级：根节点 -> 左子树 -> 右子树
arr[(*size)++] = root->val;
preOrder(root->left, size);
preOrder(root->right, size);
@@ -21,7 +21,7 @@ void preOrder(TreeNode *root, int *size) {
/* 中序遍历 */
void inOrder(TreeNode *root, int *size) {
if (root == NULL) return;
// 访问优先级：左子树 -> 根结点 -> 右子树
// 访问优先级：左子树 -> 根节点 -> 右子树
inOrder(root->left, size);
arr[(*size)++] = root->val;
inOrder(root->right, size);
@@ -30,7 +30,7 @@ void inOrder(TreeNode *root, int *size) {
/* 后序遍历 */
void postOrder(TreeNode *root, int *size) {
if (root == NULL) return;
// 访问优先级：左子树 -> 右子树 -> 根结点
// 访问优先级：左子树 -> 右子树 -> 根节点
postOrder(root->left, size);
postOrder(root->right, size);
arr[(*size)++] = root->val;
@@ -52,19 +52,19 @@ int main() {
arr = (int *) malloc(sizeof(int) * MAX_NODE_SIZE);
size = 0;
preOrder(root, &size);
printf("前序遍历的结点打印序列 = ");
printf("前序遍历的节点打印序列 = ");
printArray(arr, size);
/* 中序遍历 */
size = 0;
inOrder(root, &size);
printf("中序遍历的结点打印序列 = ");
printf("中序遍历的节点打印序列 = ");
printArray(arr, size);
/* 后序遍历 */
size = 0;
postOrder(root, &size);
printf("后序遍历的结点打印序列 = ");
printf("后序遍历的节点打印序列 = ");
printArray(arr, size);
return 0;
codes/c/include/list_node.h
+4 -4
View File
@@ -10,16 +10,16 @@
extern "C" {
#endif
/* 链表结点结构体 */
/* 链表节点结构体 */
struct ListNode {
int val; // 结点值
struct ListNode *next; // 指向下一结点的指针（引用）
int val; // 节点值
struct ListNode *next; // 指向下一节点的指针（引用）
};
// typedef 作用是为一种数据类型定义一个新名字
typedef struct ListNode ListNode;
/* 构造函数，初始化一个新结点 */
/* 构造函数，初始化一个新节点 */
ListNode *newListNode(int val) {
ListNode *node, *next;
node = (ListNode *) malloc(sizeof(ListNode));
codes/c/include/tree_node.h
+5 -5
View File
@@ -52,18 +52,18 @@ TreeNode *arrToTree(const int *arr, size_t size) {
TreeNode *root, *node;
TreeNode **queue;
/* 根结点 */
/* 根节点 */
root = newTreeNode(arr[0]);
/* 辅助队列 */
queue = (TreeNode **) malloc(sizeof(TreeNode) * MAX_NODE_SIZE);
// 队列指针
front = 0, rear = 0;
// 将根结点放入队尾
// 将根节点放入队尾
queue[rear++] = root;
// 记录遍历数组的索引
index = 0;
while (front < rear) {
// 取队列中的头结点，并让头结点出队
// 取队列中的头节点，并让头节点出队
node = queue[front++];
index++;
if (index < size) {
@@ -103,14 +103,14 @@ int *treeToArr(TreeNode *root) {
queue = (TreeNode **) malloc(sizeof(TreeNode) * MAX_NODE_SIZE);
// 队列指针
front = 0, rear = 0;
// 将根结点放入队尾
// 将根节点放入队尾
queue[rear++] = root;
/* 辅助数组 */
arr = (int *) malloc(sizeof(int) * MAX_NODE_SIZE);
// 数组指针
index = 0;
while (front < rear) {
// 取队列中的头结点，并让头结点出队
// 取队列中的头节点，并让头节点出队
node = queue[front++];
if (node != NULL) {
arr[index] = node->val;