第8篇：动态内存管理与高级数据结构

于 2024-09-14 23:13:27 发布
阅读量763 收藏 8
点赞数 21
CC 4.0 BY-SA版权
分类专栏： C语言教程 文章标签： 开发语言 c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/HYP_Coder/article/details/142267783

动态内存管理与高级数据结构

8.1 动态内存管理基础

在C语言中，动态内存管理允许程序在运行时动态地分配和释放内存。这对于处理大小不确定的数据结构尤为重要。C语言提供了几个标准库函数来进行动态内存管理，这些函数定义在<stdlib.h>头文件中。

8.1.1 malloc 函数

malloc（memory allocation）函数用于分配指定字节数的内存块。它的基本语法如下：

c

void *malloc(size_t size);
  • size：要分配的内存块的字节数。
  • 返回值：成功时返回指向分配内存的指针，失败时返回NULL。

例如，分配一个存储int类型数据的内存块：

c

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    *ptr = 10;
    printf("分配的内存中存储的值是: %d\n", *ptr);

    free(ptr);
    return 0;
}

c

8.1.2 calloc 函数

calloc（contiguous allocation）函数用于分配一块连续的内存，并初始化为零。它的基本语法如下：

c

void *calloc(size_t num, size_t size);
  • num：要分配的元素个数。
  • size：每个元素的大小（以字节为单位）。
  • 返回值：成功时返回指向分配内存的指针，失败时返回NULL。

例如，分配一个包含10个int类型元素的数组：

c

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int *)calloc(10, sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    for (int i = 0; i < 10; i++) {
        printf("arr[%d] = %d\n", i, arr[i]);
    }

    free(arr);
    return 0;
}

c

8.1.3 realloc 函数

realloc（reallocation）函数用于重新调整已经分配的内存块的大小。它的基本语法如下：

c

void *realloc(void *ptr, size_t size);
  • ptr：指向原内存块的指针。
  • size：新的内存块大小（以字节为单位）。
  • 返回值：成功时返回指向重新分配内存的指针，失败时返回NULL。如果重新分配失败，原内存块仍然有效。

例如，将一个动态数组的大小增加到20：

c

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *arr = (int *)malloc(10 * sizeof(int));
    if (arr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    for (int i = 0; i < 10; i++) {
        arr[i] = i;
    }

    int *newArr = (int *)realloc(arr, 20 * sizeof(int));
    if (newArr == NULL) {
        printf("内存重新分配失败\n");
        free(arr);
        return 1;
    }

    for (int i = 10; i < 20; i++) {
        newArr[i] = i;
    }

    for (int i = 0; i < 20; i++) {
        printf("newArr[%d] = %d\n", i, newArr[i]);
    }

    free(newArr);
    return 0;
}

c

8.1.4 free 函数

free函数用于释放之前分配的内存块，以便系统可以重新使用这块内存。它的基本语法如下：

c

void free(void *ptr);
  • ptr：指向要释放的内存块的指针。

释放内存的示例：

c

#include <stdio.h>
#include <stdlib.h>

int main() {
    int *ptr = (int *)malloc(sizeof(int));
    if (ptr == NULL) {
        printf("内存分配失败\n");
        return 1;
    }

    *ptr = 10;
    printf("分配的内存中存储的值是: %d\n", *ptr);

    free(ptr);
    return 0;
}

c

8.2 动态内存管理的注意事项

8.2.1 内存泄漏

内存泄漏是指分配了内存但没有正确释放，导致程序运行时内存占用不断增加。避免内存泄漏的办法包括：

  • 确保每个malloc、calloc或realloc的调用都有相应的free。
  • 使用工具如Valgrind检测内存泄漏。

8.2.2 野指针

野指针是指指向已经释放或未初始化内存的指针。使用野指针可能导致程序崩溃或未定义行为。避免野指针的方法包括：

  • 在释放内存后将指针设置为NULL。
  • 初始化所有指针变量。

8.2.3 双重释放

双重释放是指对同一块内存进行多次释放，这会导致程序崩溃。避免双重释放的方法包括：

  • 在释放内存后将指针设置为NULL，防止再次释放。

8.2.4 适当的内存分配

根据需求合理分配内存，不要分配过多或过少的内存。动态分配内存时应根据实际需要调整大小。

8.3 高级数据结构

在动态内存管理的基础上，可以实现许多高级数据结构，如链表、栈、队列和哈希表。这些数据结构可以帮助更高效地组织和管理数据。

8.3.1 链表

链表是一种动态数据结构，由一系列节点组成，每个节点包含数据和一个指向下一个节点的指针。链表的基本操作包括插入、删除和遍历。

  • 节点定义：

    c

    struct Node {
    int data;
    struct Node *next;
};

  • 插入节点：

    c

    void insertHead(struct Node **head, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

  • 删除节点：

    c

    void deleteHead(struct Node **head) {
    if (*head == NULL) return;

    struct Node *temp = *head;
    *head = (*head)->next;
    free(temp);
}

  • 遍历链表：

    c

    void printList(struct Node *head) {
    while (head != NULL) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("NULL\n");
}

8.3.2 栈

栈是一种遵循后进先出（LIFO）原则的数据结构。栈可以用链表或数组实现。

  • 链表实现：

    c

    struct Stack {
    struct Node *top;
};

void push(struct Stack *stack, int value) {
    insertHead(&(stack->top), value);
}

int pop(struct Stack *stack) {
    if (stack->top == NULL) return -1;  // 栈空

    int value = stack->top->data;
    deleteHead(&(stack->top));
    return value;
}

    c

8.3.3 队列

队列是一种遵循先进先出（FIFO）原则的数据结构。队列也可以用链表或数组实现。

8.4 动态内存管理与数据结构的实践

8.4.1 动态数组的实现

动态数组是基于malloc和realloc的数组实现。它可以自动调整大小以适应增加的元素。动态数组的实现示例如下：

c

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    size_t size;
    size_t capacity;
} DynamicArray;

void initArray(DynamicArray *arr, size_t initialCapacity) {
    arr->data = (int *)malloc(initialCapacity * sizeof(int));
    arr->size = 0;
    arr->capacity = initialCapacity;
}

void append(DynamicArray *arr, int value) {
    if (arr->size >= arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int *)realloc(arr->data, arr->capacity * sizeof(int));
    }
    arr->data[arr->size++] = value;
}

void freeArray(DynamicArray *arr) {
    free(arr->data);
}

int main() {
    DynamicArray arr;
    initArray(&arr, 2);

    append(&arr, 1);
    append(&arr, 2);
    append(&arr, 3);

    for (size_t i = 0; i < arr.size; i++) {
        printf("%d ", arr.data[i]);
    }
    printf("\n");

    freeArray(&arr);
    return 0;
}

c

8.4.2 链表的实际应用

链表可以用来实现队列、栈等数据结构。以下是一个简单的链表应用实例，实现了链表的基本操作：

c

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

void insertHead(struct Node **head, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

void deleteHead(struct Node **head) {
    if (*head == NULL) return;

    struct Node *temp = *head;
    *head = (*head)->next;
    free(temp);
}

void printList(struct Node *head) {
    while (head != NULL) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("NULL\n");
}

int main() {
    struct Node *head = NULL;

    insertHead(&head, 1);
    insertHead(&head, 2);
    insertHead(&head, 3);

    printList(head);

    deleteHead(&head);
    printList(head);

    // 释放剩余节点
    while (head != NULL) {
        deleteHead(&head);
    }

    return 0;
}

c

8.4.3 栈与队列的实际应用

栈和队列是用于不同场景的数据结构。栈用于后进先出的场景，比如函数调用管理；队列用于先进先出的场景，比如任务调度。

8.5.2 高级数据结构的总结

链表、栈、队列和哈希表是处理不同类型数据问题的基本工具。链表适合于需要动态插入和删除的场景；栈适合于后进先出的操作；队列适合于先进先出的操作；哈希表适合于高效的查找和插入操作。通过动态内存管理和高级数据结构的结合，可以实现高效的数据存储和处理。

8.5.3 实践建议

通过深入学习动态内存管理和高级数据结构，可以在复杂项目中更好地组织和管理数据，提高程序的性能和稳定性。如果有任何问题或需要进一步的帮助，请随时告知！

8.5 总结与实践建议

8.5.1 动态内存管理的总结

动态内存管理使得程序在运行时能够灵活地处理不同大小的数据。掌握malloc、calloc、realloc和free函数，能够有效地管理程序中的内存需求。动态内存管理涉及到内存泄漏、野指针、双重释放等问题，需要仔细处理，以确保程序的稳定性和效率。

8.4 动态内存管理与数据结构的实践

8.4.1 动态数组的实现

动态数组是基于malloc和realloc的数组实现。它可以自动调整大小以适应增加的元素。动态数组的实现示例如下：

c

#include <stdio.h>
#include <stdlib.h>

typedef struct {
    int *data;
    size_t size;
    size_t capacity;
} DynamicArray;

void initArray(DynamicArray *arr, size_t initialCapacity) {
    arr->data = (int *)malloc(initialCapacity * sizeof(int));
    arr->size = 0;
    arr->capacity = initialCapacity;
}

void append(DynamicArray *arr, int value) {
    if (arr->size >= arr->capacity) {
        arr->capacity *= 2;
        arr->data = (int *)realloc(arr->data, arr->capacity * sizeof(int));
    }
    arr->data[arr->size++] = value;
}

void freeArray(DynamicArray *arr) {
    free(arr->data);
}

int main() {
    DynamicArray arr;
    initArray(&arr, 2);

    append(&arr, 1);
    append(&arr, 2);
    append(&arr, 3);

    for (size_t i = 0; i < arr.size; i++) {
        printf("%d ", arr.data[i]);
    }
    printf("\n");

    freeArray(&arr);
    return 0;
}

c

8.4.2 链表的实际应用

链表可以用来实现队列、栈等数据结构。以下是一个简单的链表应用实例，实现了链表的基本操作：

c

#include <stdio.h>
#include <stdlib.h>

struct Node {
    int data;
    struct Node *next;
};

void insertHead(struct Node **head, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = *head;
    *head = newNode;
}

void deleteHead(struct Node **head) {
    if (*head == NULL) return;

    struct Node *temp = *head;
    *head = (*head)->next;
    free(temp);
}

void printList(struct Node *head) {
    while (head != NULL) {
        printf("%d -> ", head->data);
        head = head->next;
    }
    printf("NULL\n");
}

int main() {
    struct Node *head = NULL;

    insertHead(&head, 1);
    insertHead(&head, 2);
    insertHead(&head, 3);

    printList(head);

    deleteHead(&head);
    printList(head);

    // 释放剩余节点
    while (head != NULL) {
        deleteHead(&head);
    }

    return 0;
}

c

8.4.3 栈与队列的实际应用

栈和队列是用于不同场景的数据结构。栈用于后进先出的场景，比如函数调用管理；队列用于先进先出的场景，比如任务调度。

8.5.2 高级数据结构的总结

链表、栈、队列和哈希表是处理不同类型数据问题的基本工具。链表适合于需要动态插入和删除的场景；栈适合于后进先出的操作；队列适合于先进先出的操作；哈希表适合于高效的查找和插入操作。通过动态内存管理和高级数据结构的结合，可以实现高效的数据存储和处理。

8.5.3 实践建议

通过深入学习动态内存管理和高级数据结构，可以在复杂项目中更好地组织和管理数据，提高程序的性能和稳定性。如果有任何问题或需要进一步的帮助，请随时告知！

8.5 总结与实践建议

8.5.1 动态内存管理的总结

动态内存管理使得程序在运行时能够灵活地处理不同大小的数据。掌握malloc、calloc、realloc和free函数，能够有效地管理程序中的内存需求。动态内存管理涉及到内存泄漏、野指针、双重释放等问题，需要仔细处理，以确保程序的稳定性和效率。

  • 链表实现：

    c

    struct Queue {
    struct Node *front;
    struct Node *rear;
};

void enqueue(struct Queue *queue, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = NULL;

    if (queue->rear == NULL) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

int dequeue(struct Queue *queue) {
    if (queue->front == NULL) return -1;  // 队列空

    int value = queue->front->data;
    struct Node *temp = queue->front;
    queue->front = queue->front->next;

    if (queue->front == NULL

    c

          queue->rear = NULL;  // 队列变空时更新rear
      free(temp);
      return value;
  }

    8.3.4 哈希表

    哈希表是一种通过哈希函数将数据映射到表中固定位置的数据结构。哈希表的主要操作包括插入、删除和查找。

  • 哈希函数：将键映射到哈希表中的位置。一个简单的哈希函数示例：

    c

    unsigned int hash(int key, int tableSize) {
    return key % tableSize;
}

  • 哈希表节点：

    c

    struct HashNode {
    int key;
    int value;
    struct HashNode *next;
};

  • 哈希表插入：

    c

    void insertHashTable(struct HashNode **table, int tableSize, int key, int value) {
    unsigned int index = hash(key, tableSize);
    struct HashNode *newNode = (struct HashNode *)malloc(sizeof(struct HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table[index];
    table[index] = newNode;
}

  • 哈希表查找：

    c

    int searchHashTable(struct HashNode **table, int tableSize, int key) {
    unsigned int index = hash(key, tableSize);
    struct HashNode *node = table[index];
    while (node != NULL) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return -1;  // 未找到
}

    c

  • 哈希表删除：

    c

    void deleteHashTable(struct HashNode **table, int tableSize, int key) {
    unsigned int index = hash(key, tableSize);
    struct HashNode *node = table[index];
    struct HashNode *prev = NULL;

    while (node != NULL) {
        if (node->key == key) {
            if (prev != NULL) {
                prev->next = node->next;
            } else {
                table[index] = node->next;
            }
            free(node);
            return;
        }
        prev = node;
        node = node->next;
    }
}

    c

  • 栈的应用：实现表达式求值。

    c

    #include <stdio.h>
#include <stdlib.h>

struct Stack {
    struct Node *top;
};

void push(struct Stack *stack, int value) {
    insertHead(&(stack->top), value);
}

int pop(struct Stack *stack) {
    if (stack->top == NULL) return -1;

    int value = stack->top->data;
    deleteHead(&(stack->top));
    return value;
}

int main() {
    struct Stack stack = {NULL};

    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);

    printf("Popped value: %d\n", pop(&stack));
    printf("Popped value: %d\n", pop(&stack));

    return 0;
}

    c

  • 队列的应用：任务调度模拟。

    c

    #include <stdio.h>
#include <stdlib.h>

struct Queue {
    struct Node *front;
    struct Node *rear;
};

void enqueue(struct Queue *queue, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = NULL;

    if (queue->rear == NULL) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

int dequeue(struct Queue *queue) {
    if (queue->front == NULL) return -1;

    int value = queue->front->data;
    struct Node *temp = queue->front;
    queue->front = queue->front->next;

    if (queue->front == NULL) {
        queue->rear = NULL;
    }

    free(temp);
    return value;
}

int main() {
    struct Queue queue = {NULL, NULL};

    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    printf("Dequeued value: %d\n", dequeue(&queue));
    printf("Dequeued value: %d\n", dequeue(&queue));

    return 0;
}

    c

  • 在实际编程中，合理使用动态内存分配函数，确保内存的有效管理。
  • 学习并应用数据结构的基本操作，以提高程序的性能和效率。
  • 进行内存管理时，使用工具如Valgrind检测内存泄漏和错误。
  •

    8.3.4 哈希表

    哈希表是一种通过哈希函数将数据映射到表中固定位置的数据结构。哈希表的主要操作包括插入、删除和查找。

  • 哈希函数：将键映射到哈希表中的位置。一个简单的哈希函数示例：

    c

    unsigned int hash(int key, int tableSize) {
    return key % tableSize;
}

  • 哈希表节点：

    c

    struct HashNode {
    int key;
    int value;
    struct HashNode *next;
};

  • 哈希表插入：

    c

    void insertHashTable(struct HashNode **table, int tableSize, int key, int value) {
    unsigned int index = hash(key, tableSize);
    struct HashNode *newNode = (struct HashNode *)malloc(sizeof(struct HashNode));
    newNode->key = key;
    newNode->value = value;
    newNode->next = table[index];
    table[index] = newNode;
}

  • 哈希表查找：

    c

    int searchHashTable(struct HashNode **table, int tableSize, int key) {
    unsigned int index = hash(key, tableSize);
    struct HashNode *node = table[index];
    while (node != NULL) {
        if (node->key == key) {
            return node->value;
        }
        node = node->next;
    }
    return -1;  // 未找到
}

    c

  • 哈希表删除：

    c

    void deleteHashTable(struct HashNode **table, int tableSize, int key) {
    unsigned int index = hash(key, tableSize);
    struct HashNode *node = table[index];
    struct HashNode *prev = NULL;

    while (node != NULL) {
        if (node->key == key) {
            if (prev != NULL) {
                prev->next = node->next;
            } else {
                table[index] = node->next;
            }
            free(node);
            return;
        }
        prev = node;
        node = node->next;
    }
}

    c

  • 栈的应用：实现表达式求值。

    c

    #include <stdio.h>
#include <stdlib.h>

struct Stack {
    struct Node *top;
};

void push(struct Stack *stack, int value) {
    insertHead(&(stack->top), value);
}

int pop(struct Stack *stack) {
    if (stack->top == NULL) return -1;

    int value = stack->top->data;
    deleteHead(&(stack->top));
    return value;
}

int main() {
    struct Stack stack = {NULL};

    push(&stack, 10);
    push(&stack, 20);
    push(&stack, 30);

    printf("Popped value: %d\n", pop(&stack));
    printf("Popped value: %d\n", pop(&stack));

    return 0;
}

    c

  • 队列的应用：任务调度模拟。

    c

    #include <stdio.h>
#include <stdlib.h>

struct Queue {
    struct Node *front;
    struct Node *rear;
};

void enqueue(struct Queue *queue, int value) {
    struct Node *newNode = (struct Node *)malloc(sizeof(struct Node));
    newNode->data = value;
    newNode->next = NULL;

    if (queue->rear == NULL) {
        queue->front = newNode;
        queue->rear = newNode;
    } else {
        queue->rear->next = newNode;
        queue->rear = newNode;
    }
}

int dequeue(struct Queue *queue) {
    if (queue->front == NULL) return -1;

    int value = queue->front->data;
    struct Node *temp = queue->front;
    queue->front = queue->front->next;

    if (queue->front == NULL) {
        queue->rear = NULL;
    }

    free(temp);
    return value;
}

int main() {
    struct Queue queue = {NULL, NULL};

    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    printf("Dequeued value: %d\n", dequeue(&queue));
    printf("Dequeued value: %d\n", dequeue(&queue));

    return 0;
}

    c

  • 在实际编程中，合理使用动态内存分配函数，确保内存的有效管理。
  • 学习并应用数据结构的基本操作，以提高程序的性能和效率。
  • 进行内存管理时，使用工具如Valgrind检测内存泄漏和错误。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值