#include <stdio.h>
#include <stdlib.h>
/* ================== 单向链表实现 ================== */
typedef struct ListNode {
int data;
struct ListNode* next;
} ListNode;
// 插入节点到头部
void list_insert(ListNode** head, int data) {
ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
newNode->data = data;
newNode->next = *head;
*head = newNode;
}
// 删除指定值的节点
void list_delete(ListNode** head, int data) {
ListNode *temp = *head, *prev = NULL;
while (temp != NULL && temp->data != data) {
prev = temp;
temp = temp->next;
}
if (temp == NULL) return;
if (prev == NULL) {
*head = temp->next;
} else {
prev->next = temp->next;
}
free(temp);
}
// 链表迭代打印
void list_print(ListNode* head) {
while (head != NULL) {
printf("%d -> ", head->data);
head = head->next;
}
printf("NULL\n");
}
/* ================== 栈实现(链表实现) ================== */
typedef struct Stack {
ListNode* top;
} Stack;
void stack_push(Stack* s, int data) {
ListNode* newNode = (ListNode*)malloc(sizeof(ListNode));
newNode->data = data;
newNode->next = s->top;
s->top = newNode;
}
int stack_pop(Stack* s) {
if (s->top == NULL) return -1;
ListNode* temp = s->top;
int data = temp->data;
s->top = s->top->next;
free(temp);
return data;
}
/* ================== 队列实现(链表实现) ================== */
typedef struct QueueNode {
int data;
struct QueueNode* next;
} QueueNode;
typedef struct Queue {
QueueNode *front, *rear;
} Queue;
void enqueue(Queue* q, int data) {
QueueNode* newNode = (QueueNode*)malloc(sizeof(QueueNode));
newNode->data = data;
newNode->next = NULL;
if (q->rear == NULL) {
q->front = q->rear = newNode;
} else {
q->rear->next = newNode;
q->rear = newNode;
}
}
int dequeue(Queue* q) {
if (q->front == NULL) return -1;
QueueNode* temp = q->front;
int data = temp->data;
q->front = q->front->next;
if (q->front == NULL) {
q->rear = NULL;
}
free(temp);
return data;
}
/* ================== 二叉树实现 ================== */
typedef struct TreeNode {
int data;
struct TreeNode *left, *right;
} TreeNode;
// 插入节点(二叉搜索树)
TreeNode* tree_insert(TreeNode* root, int data) {
if (root == NULL) {
TreeNode* newNode = (TreeNode*)malloc(sizeof(TreeNode));
newNode->data = data;
newNode->left = newNode->right = NULL;
return newNode;
}
if (data < root->data) {
root->left = tree_insert(root->left, data);
} else {
root->right = tree_insert(root->right, data);
}
return root;
}
// 删除节点
TreeNode* tree_delete(TreeNode* root, int data) {
if (root == NULL) return root;
if (data < root->data) {
root->left = tree_delete(root->left, data);
} else if (data > root->data) {
root->right = tree_delete(root->right, data);
} else {
// 节点有一个子节点或无子节点
if (root->left == NULL) {
TreeNode* temp = root->right;
free(root);
return temp;
} else if (root->right == NULL) {
TreeNode* temp = root->left;
free(root);
return temp;
}
// 节点有两个子节点:找到右子树的最小节点
TreeNode* temp = root->right;
while (temp->left != NULL) {
temp = temp->left;
}
root->data = temp->data;
root->right = tree_delete(root->right, temp->data);
}
return root;
}
// 中序遍历(迭代)
void inorder_iteration(TreeNode* root) {
if (root == NULL) return;
inorder_iteration(root->left);
printf("%d ", root->data);
inorder_iteration(root->right);
}
int main() {
printf("=== 链表测试 ===\n");
ListNode* head = NULL;
list_insert(&head, 3);
list_insert(&head, 2);
list_insert(&head, 1);
list_print(head); // 1 -> 2 -> 3 -> NULL
list_delete(&head, 2);
list_print(head); // 1 -> 3 -> NULL
printf("\n=== 栈测试 ===\n");
Stack s = {NULL};
stack_push(&s, 1);
stack_push(&s, 2);
stack_push(&s, 3);
printf("Pop: %d\n", stack_pop(&s)); // 3
printf("Pop: %d\n", stack_pop(&s)); // 2
printf("\n=== 队列测试 ===\n");
Queue q = {NULL, NULL};
enqueue(&q, 1);
enqueue(&q, 2);
enqueue(&q, 3);
printf("Dequeue: %d\n", dequeue(&q)); // 1
printf("Dequeue: %d\n", dequeue(&q)); // 2
printf("\n=== 二叉树测试 ===\n");
TreeNode* root = NULL;
root = tree_insert(root, 5);
tree_insert(root, 3);
tree_insert(root, 7);
tree_insert(root, 2);
printf("Inorder: ");
inorder_iteration(root); // 2 3 5 7
root = tree_delete(root, 3);
printf("\nAfter delete 3: ");
inorder_iteration(root); // 2 5 7
return 0;
}