基础数据结构c代码

#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;
}