华中科技大学数据结构实验详解与实现

本文还有配套的精品资源，点击获取

简介：本资料详细解析了华中科技大学计算机学院数据结构实验的四个关键部分：顺序表、单链表、二叉树和邻接表（无向图）。实验以C语言实现为示例，涵盖了这些基本数据结构的创建、操作和应用，以及在实现中对时间复杂度的理解。顺序表利用数组实现，单链表通过节点和指针动态存储数据，二叉树用递归思想和不同遍历方法处理，邻接表则用于表示无向图的结构。通过这些实验，学生可以加深对数据结构基本概念和算法操作的理解，并提高编程能力，为日后的学习和职业生涯打下基础。

1. 数据结构基础概念

在计算机科学中，数据结构是存储、组织数据的方式，其设计旨在提高数据的处理效率。本章将介绍数据结构的基本概念，为理解后续内容奠定基础。

1.1 数据结构的定义

数据结构是计算机存储、组织数据的一种方式，它包括数据的逻辑结构、物理存储结构以及数据的操作。逻辑结构涉及数据元素之间的关系，比如线性结构或树形结构；物理存储结构则关注数据在内存中的具体表现形式。

1.2 数据结构的分类

数据结构主要分为两大类：线性结构和非线性结构。线性结构如数组和链表，其特点是数据元素之间存在一对一的线性关系；而非线性结构如树、图等，它们的元素间存在着更为复杂的关系。了解这些分类有助于我们根据应用场景选择最合适的结构。

1.3 数据结构的重要性

掌握数据结构对于IT专业人员至关重要，因为它是编写高效算法和进行系统设计的基础。良好的数据结构设计能够优化存储空间，提高数据处理速度，增强系统的性能。随着本章节内容的深入，我们将看到如何应用这些基础概念来解决实际问题。

2. C语言实现数据结构

2.1 C语言基础回顾

2.1.1 C语言基础语法

C语言是实现数据结构的常用语言之一，它提供了丰富的基础语法，使得开发者能够高效地进行数据结构的设计与实现。回顾C语言基础语法，首先要提到的是变量和常量的定义。变量是用于存储数据值的容器，而常量则是在程序执行期间其值不可更改的数据标识。定义变量需要指定数据类型，例如：

int a = 10; // 定义一个整型变量a，并初始化为10
char b = 'A'; // 定义一个字符变量b，并初始化为字符'A'

除了基本的数据类型外，C语言还提供了控制语句如 if 、 else 、 switch 、 for 、 while 和 do-while 循环等，这些控制语句对于实现逻辑判断和数据结构中的迭代操作至关重要。

函数是C语言中的重要组成部分，它们能够封装代码，使得代码更加模块化，易于维护和复用。函数的定义需要指定返回类型、函数名以及参数列表：

int add(int x, int y) {
    return x + y; // 定义一个返回整型的函数add，接收两个整型参数x和y
}

2.1.2 C语言数据类型与运算符

C语言提供了多种数据类型，包括基本类型如整型（ int ）、浮点型（ float 和 double ）、字符型（ char ）以及复杂类型如数组、结构体等。正确地选择和使用这些数据类型对于程序的性能和可读性都有直接的影响。

例如，整型适合存储整数，浮点型用于存储小数。合理地选择数据类型能够提高数据处理的效率：

double large_number = ***.***; // 对于大数或精度要求较高的情况使用double

运算符是用于执行数据运算的符号，如算术运算符（ + , - , * , / , % ），关系运算符（ == , != , > , < , >= , <= ），逻辑运算符（ && , || , ! ），位运算符等。运算符的使用对于控制数据结构操作流程至关重要：

if (a > b && c < d) { // 利用关系运算符和逻辑运算符进行条件判断
    // 执行相应的操作
}

2.2 C语言与数据结构的融合

2.2.1 结构体与联合体的应用

结构体（ struct ）是C语言中一种复杂的数据类型，它允许将不同类型的数据项组合成一个单一的复合类型。在数据结构中，结构体被广泛用于定义节点、记录等。

struct Node {
    int data; // 节点存储的数据
    struct Node* next; // 指向下一个节点的指针
};

结构体的使用使得数据组织更为清晰，也更便于在链表、树、图等数据结构中进行操作。

联合体（ union ）与结构体类似，但联合体的所有成员共享同一块内存空间，这使得联合体在某些特殊情况下非常有用，比如对内存的节约和某些类型的强制类型转换：

union Data {
    int i;
    float f;
};

联合体在数据结构中的应用可能不如结构体频繁，但在需要同时处理多种类型数据而又希望节省空间时，联合体提供了一个有效的解决方案。

2.2.2 指针在数据结构中的使用

指针是C语言中的核心概念之一，它提供了直接访问内存地址的能力。在数据结构中，指针主要被用于动态内存分配、数据结构节点之间的链接以及各种算法中的递归操作。

指针在数据结构中的一个典型应用是链表。通过指针，链表的节点可以彼此链接，形成一个动态的数据结构：

struct Node* head; // 定义一个指向链表头节点的指针
head = (struct Node*)malloc(sizeof(struct Node)); // 动态分配内存
head->data = 10; // 使用指针访问结构体成员
head->next = NULL; // 初始化指针指向的下一节点

通过以上的例子可以看出，指针在数据结构中的使用非常重要且普遍。它们不仅可以用于单个节点的访问，还能连接整个数据结构，实现更复杂的数据组织和操作。

2.3 C语言动态内存管理

2.3.1 动态内存分配

在数据结构的实现过程中，经常需要根据实际情况动态地分配内存空间。C语言通过 malloc 、 calloc 、 realloc 和 free 等函数提供了动态内存分配和管理的功能。

int* array = (int*)malloc(n * sizeof(int)); // 使用malloc为一个整型数组分配内存

动态内存分配是C语言处理复杂数据结构，特别是那些需要根据程序运行时的情况来确定大小的数据结构（如链表、树、图等）的关键技术。

2.3.2 内存泄漏的避免与检测

虽然动态内存分配给程序带来了灵活性，但它也可能导致内存泄漏问题。内存泄漏指的是程序中分配的内存由于某些原因未能释放，导致可用内存逐渐减少，最终可能导致程序异常甚至崩溃。

为了避免内存泄漏，需要注意以下几点：

• 确保每个 malloc 都有一个对应的 free ；
• 在函数退出前释放不再使用的内存；
• 检查指针是否为 NULL ，避免释放未分配的内存。

检测内存泄漏可以使用专门的工具，如 Valgrind ，该工具可以在运行时检测程序中的内存问题。

valgrind --leak-check=full ./a.out

通过这样的工具，我们可以确保程序的健壮性，避免因内存问题带来的稳定性风险。在本章节中，我们深入探讨了C语言基础回顾，尤其是C语言与数据结构的融合和动态内存管理。这些基础知识是理解和应用更复杂数据结构的基石。在下一章节中，我们将继续深入数据结构的世界，探索顺序表的数组实现以及单链表的操作与特点。

3. 顺序表的数组实现

3.1 顺序表的定义与特性

顺序表是一种线性表的数组实现，其所有元素在内存中是连续存放的。这种存储方式使得顺序表的元素可以随机访问，即可以通过元素的索引直接定位到具体的内存位置，从而实现快速的查找、插入和删除操作。顺序表的这种特性使得它在数据元素个数变化不大，且频繁进行查找操作的场合下非常适用。

3.1.1 顺序表的概念与表示

在计算机内存中，顺序表可以看作一个数组，每个数组元素都是表中的一个数据项。顺序表的元素通常要求是同一类型的数据，这样可以简化内存管理。顺序表的表示方式可以通过结构体来定义，包括数组本身以及一个指示当前表中元素个数的整型变量。

#define MAX_SIZE 100 // 定义顺序表的最大容量

typedef struct {
    int data[MAX_SIZE]; // 存储顺序表元素的数组
    int length;         // 顺序表当前长度
} SeqList;

SeqList list; // 创建一个顺序表实例

3.1.2 顺序表的基本操作

顺序表的基本操作包括初始化、添加元素、删除元素、查找元素以及获取元素等。例如，初始化顺序表的操作就是将长度设置为0，数组元素初始化为默认值。

void InitList(SeqList *list) {
    list->length = 0; // 初始化长度为0
}

3.2 数组实现顺序表的细节

3.2.1 数组的静态与动态实现

在C语言中，数组的大小是在编译时确定的，称为静态数组。静态数组的长度必须是常量，且一旦分配就不能改变。但是，顺序表在很多情况下需要动态变化的大小，这就需要动态数组。

动态数组是通过动态内存分配（例如使用 malloc 或 calloc 函数）来实现的。在运行时可以申请和释放内存空间，更加灵活。

void CreateList(SeqList *list, int n) {
    list->data = (int *)malloc(n * sizeof(int)); // 动态分配内存
    if (list->data == NULL) {
        exit(1); // 内存分配失败，退出程序
    }
    list->length = n;
}

3.2.2 顺序表的插入与删除操作

顺序表的插入操作通常需要移动插入点之后的元素以腾出空间。删除操作则是删除指定位置的元素，并将后面所有元素前移一位。

int InsertList(SeqList *list, int index, int value) {
    if (index < 0 || index > list->length || list->length == MAX_SIZE) {
        return 0; // 插入位置不合法或顺序表已满
    }
    for (int i = list->length; i > index; i--) {
        list->data[i] = list->data[i - 1]; // 后移元素
    }
    list->data[index] = value; // 插入元素
    list->length++; // 长度加1
    return 1;
}

int DeleteList(SeqList *list, int index) {
    if (index < 0 || index >= list->length) {
        return 0; // 删除位置不合法
    }
    for (int i = index; i < list->length - 1; i++) {
        list->data[i] = list->data[i + 1]; // 前移元素
    }
    list->length--; // 长度减1
    return 1;
}

通过以上代码，我们不仅实现了顺序表的插入和删除操作，还演示了动态数组在运行时如何处理内存分配和释放，确保顺序表的灵活性。在顺序表的管理中，动态内存管理是非常重要的一部分，稍有不慎就会造成内存泄漏。因此，合理使用 malloc 、 calloc 、 realloc 和 free 函数，对于保障程序的健壮性至关重要。

4. 单链表的操作与特点

4.1 链表的基本概念

4.1.1 单链表的定义

单链表是一种常见的数据结构，它是由一系列节点组成的线性结构，每个节点包含两部分信息：存储数据本身的数据域和存储下一个节点地址的指针域。节点之间通过指针链接，形成一个链状结构。链表的每个节点通常用结构体表示，例如在C语言中定义一个链表节点如下：

typedef struct Node {
    int data;           // 数据域，存储数据
    struct Node *next;  // 指针域，指向下一个节点
} Node;

在上述定义中， data 字段用于存储节点数据， next 是指向链表下一个节点的指针。由于这种数据结构中节点的物理位置可以是不连续的，因此，单链表不需要像数组一样预留固定大小的内存空间，它通过动态分配内存的方式，实现了对数据的动态管理。

4.1.2 链表节点的结构与操作

链表的节点操作包括创建节点、插入节点、删除节点和销毁链表等。下面是一个简单创建链表节点的函数示例：

Node* createNode(int value) {
    Node *newNode = (Node*)malloc(sizeof(Node));
    if (newNode == NULL) {
        exit(-1);
    }
    newNode->data = value;
    newNode->next = NULL;
    return newNode;
}

创建节点时，我们需要为新节点分配内存，并初始化其数据域和指针域。在C语言中， malloc 函数用于动态内存分配，成功则返回指向内存块的指针，失败则返回NULL。通过检查 malloc 返回的指针是否为NULL，我们可以判断内存分配是否成功。

除了创建节点，插入和删除操作也是链表中常见的操作。插入操作需要修改节点间的指针关系，而删除操作则需要释放被删除节点的内存资源，以避免内存泄漏。

4.2 单链表的管理与应用

4.2.1 单链表的创建与遍历

创建一个单链表首先需要创建一个头节点，头节点不存储有效数据，仅作为链表的起始标识。创建头节点和初始化链表的代码如下：

Node* createLinkedList() {
    Node *head = createNode(0);  // 创建头节点，值为0或其他标识符
    head->next = NULL;
    return head;
}

遍历链表是链表操作中最基本的操作之一，其目的是访问链表中的每一个节点。遍历过程中，通常从头节点开始，逐个访问其后继节点，直到链表结束。

void traverseLinkedList(Node *head) {
    Node *current = head->next;  // 从第一个有效节点开始遍历
    while (current != NULL) {
        printf("Node value: %d\n", current->data);
        current = current->next;
    }
}

4.2.2 单链表的插入与删除技术

链表的插入操作分为三种情况：在链表头部、链表尾部或链表中间插入。这里以在链表头部插入节点为例：

void insertAtHead(Node *head, Node *newNode) {
    newNode->next = head->next;  // 新节点指向原头节点的下一个节点
    head->next = newNode;        // 头节点指向新节点
}

在进行插入操作时，我们修改了两个指针的指向：新节点的 next 指针和前一个节点的 next 指针。删除操作则涉及对指针的解引用和内存释放：

void deleteNode(Node *head, int value) {
    Node *current = head;
    Node *previous = NULL;
    while (current != NULL && current->data != value) {
        previous = current;
        current = current->next;
    }
    if (current == NULL) {
        return;  // 未找到值为value的节点
    }
    previous->next = current->next;  // 删除current节点
    free(current);  // 释放current节点的内存
}

在删除节点时，我们需要跟踪两个节点：一个是当前节点 current ，另一个是前一个节点 previous 。当找到要删除的节点时，通过 previous 节点的 next 指针指向 current 节点的下一个节点，从而完成删除。最后，使用 free 函数释放被删除节点的内存资源，防止内存泄漏。

链表的插入与删除操作是数据结构课程和编程实践中的基础，但实现这些操作的代码需要仔细编写，以确保对链表结构的正确管理。理解链表的这些基本操作对于掌握其他更复杂数据结构也有重要帮助。

5. 二叉树的遍历和递归处理

5.1 二叉树的定义与性质

5.1.1 二叉树的概念与分类

二叉树是每个节点最多有两个子树的树结构，通常子树被称作“左子树”和“右子树”。它是数据结构中非常重要的一种形式，被广泛应用在各种算法和数据存储的场景中。

二叉树的分类有很多，其中包括：

• 完全二叉树：除了最后一层外，每一层都被完全填满，且所有节点都尽可能地向左。
• 满二叉树：一个二叉树，如果每一个层的结点数都达到最大值，则这个二叉树就是满二叉树。也就是说，如果一个深度为k的二叉树，其每个节点都有最多2^k-1个子节点。
• 平衡二叉树（AVL树）：任意节点的两个子树的高度最大差别为1，这样可以确保二叉树的平衡，从而保持良好的查询性能。
• 二叉搜索树（BST）：对于树中的每个节点，其左子树中的所有元素都小于该节点，其右子树中的所有元素都大于该节点。
• 红黑树：一种自平衡的二叉搜索树，通过在节点中引入额外的信息位（颜色）来维护树的平衡。

5.1.2 二叉树的遍历算法

二叉树的遍历分为四种基本方式：前序遍历、中序遍历、后序遍历和层序遍历。

• 前序遍历（Preorder Traversal）：先访问根节点，然后递归地做前序遍历左子树，接着递归地做前序遍历右子树。
• 中序遍历（Inorder Traversal）：先递归地做中序遍历左子树，然后访问根节点，最后递归地做中序遍历右子树。
• 后序遍历（Postorder Traversal）：先递归地做后序遍历左子树，然后递归地做后序遍历右子树，最后访问根节点。
• 层序遍历（Level Order Traversal）：按层次从上到下、从左到右访问所有节点。

接下来，我们将以代码的形式展示如何在C语言中实现这些遍历方法。

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

// 定义二叉树节点结构体
typedef struct TreeNode {
    int value;
    struct TreeNode *left;
    struct TreeNode *right;
} TreeNode;

// 前序遍历
void preorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    printf("%d ", root->value);          // 访问根节点
    preorderTraversal(root->left);       // 前序遍历左子树
    preorderTraversal(root->right);      // 前序遍历右子树
}

// 中序遍历
void inorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    inorderTraversal(root->left);        // 中序遍历左子树
    printf("%d ", root->value);          // 访问根节点
    inorderTraversal(root->right);       // 中序遍历右子树
}

// 后序遍历
void postorderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    postorderTraversal(root->left);      // 后序遍历左子树
    postorderTraversal(root->right);     // 后序遍历右子树
    printf("%d ", root->value);          // 访问根节点
}

// 层序遍历
void levelOrderTraversal(TreeNode* root) {
    if (root == NULL) {
        return;
    }
    TreeNode *queue[100];  // 假设树的节点不超过100个
    int front = 0, rear = 0;
    queue[rear++] = root;  // 根节点入队

    while (front != rear) {
        TreeNode *node = queue[front++];  // 节点出队
        printf("%d ", node->value);

        if (node->left != NULL) {
            queue[rear++] = node->left;    // 左子树节点入队
        }
        if (node->right != NULL) {
            queue[rear++] = node->right;   // 右子树节点入队
        }
    }
}

int main() {
    // 示例二叉树构建过程省略...
    printf("前序遍历结果：");
    preorderTraversal(root);
    printf("\n");

    printf("中序遍历结果：");
    inorderTraversal(root);
    printf("\n");

    printf("后序遍历结果：");
    postorderTraversal(root);
    printf("\n");

    printf("层序遍历结果：");
    levelOrderTraversal(root);
    printf("\n");

    return 0;
}

在上述代码中，我们定义了二叉树节点的结构体，并实现了四种遍历方法。每种方法的逻辑都很清晰，先处理根节点，再递归处理左右子树。层序遍历使用了队列来按层次进行节点的访问。

5.2 二叉树的递归操作

5.2.1 递归原理与实现

递归是一种常见的编程技巧，它允许函数调用自身。递归在处理二叉树问题时非常有用，因为树本身就是一种递归的数据结构。

递归的基本原理依赖于两个过程：

• 基准情形（Base Case）：这是递归结束的条件，防止无限递归的发生。
• 递归情形（Recursive Case）：在这种情况下，函数调用自身。

在二叉树中，递归可以用来实现搜索、插入、删除等操作。例如，在二叉搜索树中查找一个值：

int searchBST(TreeNode* root, int key) {
    if (root == NULL || root->value == key) {
        return root != NULL;  // 返回是否存在这个值
    }
    if (key < root->value) {
        return searchBST(root->left, key);  // 在左子树中搜索
    } else {
        return searchBST(root->right, key); // 在右子树中搜索
    }
}

在上述函数中，我们检查当前节点是否为空或者是否是我们要找的值。如果不是，根据值的大小，我们决定是递归搜索左子树还是右子树。

5.2.2 递归在二叉树中的应用

递归在二叉树中的另一个重要应用是树的深度计算。我们可以定义一个递归函数，它返回子树的最大深度：

int maxDepth(TreeNode* root) {
    if (root == NULL) {
        return 0;
    }
    int leftDepth = maxDepth(root->left);   // 计算左子树的最大深度
    int rightDepth = maxDepth(root->right); // 计算右子树的最大深度
    return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1;
}

在这个函数中，我们递归地计算左子树和右子树的深度，然后取最大值加一得到当前子树的深度。递归的基准情形是当节点为空时，此时深度为0。

递归方法虽然代码简洁易懂，但在处理非常深的树时可能会遇到栈溢出的问题。这是因为每次函数调用都会消耗一定的栈空间，而函数的递归调用层数过多，可能会超出栈的大小限制。为了避免这种情况，可以考虑使用迭代的方式代替递归，或者限制递归树的深度。

6. 邻接表表示无向图

6.1 图的定义与表示方法

6.1.1 图的基本概念

图是由顶点（节点）和连接顶点的边组成的非线性数据结构。图可以用来表示多对多关系的数据，例如社交网络中的朋友关系，网页中的链接关系等。在图论中，一个图通常用G(V, E)表示，其中V是顶点集合，E是边的集合。每条边表示顶点之间的关系，可以是无向的（表示为双向边）或有向的（表示为单向箭头）。

无向图中的边没有方向，比如A到B的边与B到A的边是同一条边。有向图中的边则具有方向，例如，如果存在一条从A到B的边，则不一定存在一条从B到A的边。在表示图时，顶点和边是两个重要的组成部分。

6.1.2 邻接矩阵与邻接表的比较

图可以通过多种方式来表示，两种常见的方法是邻接矩阵和邻接表。

• 邻接矩阵是一个二维数组，其中行和列分别表示图中的顶点。矩阵中的元素用来表示顶点之间的关系，通常使用0和1来表示边的不存在和存在。邻接矩阵易于理解和实现，但当图很大时会消耗较多的存储空间。

• 邻接表是一种更节省空间的图表示方法。它使用链表来存储每个顶点的邻接顶点。对于无向图而言，每个顶点都拥有一个链表，包含所有与该顶点直接相连的顶点。对于有向图，每个顶点的链表中包含所有从该顶点出发的边所连接的顶点。

下面是一个邻接表结构的简单实现代码：

#define MAX_VERTICES 100 // 最大顶点数

typedef struct ArcNode {
    int adjvex;             // 邻接点域
    struct ArcNode *nextarc; // 指向下一个邻接点的指针
} ArcNode;

typedef struct VNode {
    int data;               // 顶点信息域
    ArcNode *firstarc;      // 指向第一条依附于该顶点的弧的指针
} VNode, AdjList[MAX_VERTICES];

typedef struct {
    AdjList vertices;
    int vexnum, arcnum; // 图中当前的顶点数和弧数
} ALGraph;

在上述代码中，我们定义了顶点结构和邻接表的结构，其中 ArcNode 代表邻接点，它包含邻接点的索引 adjvex 和指向下一个邻接点的指针 nextarc 。 VNode 代表顶点，它包含顶点信息 data 和指向第一条依附于该顶点的弧的指针 firstarc 。 ALGraph 是邻接表的结构，包含顶点数组 vertices 和图的顶点数 vexnum 、弧数 arcnum 。

6.2 邻接表的实现与应用

6.2.1 邻接表的数据结构设计

邻接表的数据结构设计如上所述，现在我们将详细讨论如何实现邻接表的基本操作。

• 初始化邻接表：分配内存空间，初始化所有顶点和边的状态。
• 添加顶点：向邻接表中添加新的顶点，并初始化该顶点的链表为空。
• 添加边：在邻接表中添加边，通常涉及在两个顶点的链表中相互加入对方。

void initGraph(ALGraph *G, int n) {
    G->vexnum = n;
    for (int i = 0; i < n; ++i) {
        G->vertices[i].data = 0;
        G->vertices[i].firstarc = NULL;
    }
    G->arcnum = 0;
}

void addEdge(ALGraph *G, int start, int end) {
    ArcNode *newNode = (ArcNode *)malloc(sizeof(ArcNode));
    newNode->adjvex = end;
    newNode->nextarc = G->vertices[start].firstarc;
    G->vertices[start].firstarc = newNode;
    // 对于无向图，还需要添加下面的代码
    newNode = (ArcNode *)malloc(sizeof(ArcNode));
    newNode->adjvex = start;
    newNode->nextarc = G->vertices[end].firstarc;
    G->vertices[end].firstarc = newNode;
}

在上述代码中， initGraph 函数用于初始化一个邻接表， addEdge 函数用于添加一条无向边。这里需要注意，对于无向图来说，一条边是两个顶点间的，所以需要添加两次。

6.2.2 邻接表的遍历与路径搜索

邻接表的遍历通常用于搜索图中的所有顶点或边。遍历方法有深度优先搜索（DFS）和广度优先搜索（BFS）。

• 深度优先搜索（DFS）：从一个顶点出发，沿着一条路径深入探索直到尽头，然后回溯到上一个分叉点，再选择另一条路径探索，直到所有顶点都被访问过。
• 广度优先搜索（BFS）：从一个顶点出发，访问所有邻近顶点，然后再访问这些邻近顶点的邻近顶点，以此类推，直到所有顶点都被访问。

下面展示了一个简单的深度优先搜索的实现：

void DFS(ALGraph G, int v, void (*visit)(int)) {
    ArcNode *p;
    visit(v); // 访问顶点v
    G.vertices[v].data = 1; // 标记顶点v已访问
    p = G.vertices[v].firstarc;
    while (p) {
        if (!G.vertices[p->adjvex].data) { // 如果p->adjvex未被访问过
            DFS(G, p->adjvex, visit); // 递归访问
        }
        p = p->nextarc;
    }
}

void traverseGraph(ALGraph G) {
    int i;
    for (i = 0; i < G.vexnum; ++i) {
        G.vertices[i].data = 0; // 初始化所有顶点为未访问
    }
    for (i = 0; i < G.vexnum; ++i) {
        if (!G.vertices[i].data) { // 如果顶点i未被访问过
            DFS(G, i, display); // 从顶点i开始深度优先搜索
        }
    }
}

void display(int v) {
    printf("%d ", v);
}

在上述代码中， DFS 是深度优先搜索的递归实现， traverseGraph 函数遍历图中的所有顶点，并使用DFS进行遍历。 display 函数用于打印顶点值。

通过这些基本操作，我们可以利用邻接表来解决一些图相关的算法问题，比如最短路径、网络流等问题。邻接表是实现图相关算法的基石，它的应用非常广泛。

7. 时间复杂度分析

时间复杂度是衡量算法效率的标尺，它独立于具体机器环境和特定编程语言，主要关注算法运行时间随着输入规模增长的增长趋势。在这一章节中，我们将深入理解时间复杂度的概念，并探索如何进行时间复杂度的分析。

7.1 算法效率与时间复杂度

7.1.1 时间复杂度的概念与表示

时间复杂度是对算法执行时间的抽象描述。它使用大O符号表示，也称为大O记法，用于描述算法运行时间的增长速率。大O记法关注的是最坏情况下的时间复杂度，即在最不利的输入下算法所需要的执行时间。

例如，对于一个简单的for循环，它重复执行n次，那么这个循环的时间复杂度表示为O(n)。如果循环内包含另一个循环，那么时间复杂度将变成O(n^2)。

让我们来看一个简单的代码示例：

for (int i = 0; i < n; ++i) {
    // 单次操作
}

上述代码段的时间复杂度为O(n)，因为随着输入值n的增加，执行的次数线性增加。

7.1.2 常见算法的时间复杂度比较

不同的算法有着不同的时间复杂度。为了更好地理解，我们可以列出一些常见操作的复杂度，按效率从高到低排列： - O(1) - 常数时间复杂度，表示算法执行时间不随输入数据规模变化。 - O(log n) - 对数时间复杂度，常出现在分而治之的算法中。 - O(n) - 线性时间复杂度，算法的执行时间与输入规模成正比。 - O(n log n) - 线性对数时间复杂度，常见于高效的排序算法。 - O(n^2) - 平方时间复杂度，嵌套循环操作通常具有这种复杂度。 - O(2^n) - 指数时间复杂度，分支界限算法和递归算法的深度搜索常出现。 - O(n!) - 阶乘时间复杂度，出现在某些组合优化问题的暴力求解算法中。

理解这些复杂度之间的差别，对于编写高效算法至关重要。

7.2 时间复杂度的深入分析

7.2.1 最坏情况与平均情况分析

在实际应用中，算法可能在不同的输入下表现出不同的时间复杂度。因此，我们不仅要考虑最坏情况，还要考虑平均情况下的时间复杂度。

例如，在排序算法中： - 最坏情况指的是待排序数组已经是完全倒序。 - 平均情况指的是数组是随机顺序排列。

不同的排序算法在不同情况下的性能表现会有所不同，我们可以根据实际需要选择最合适的方法。

7.2.2 时间复杂度的高级分析方法

时间复杂度的高级分析方法包括摊还分析和均摊复杂度，这些方法允许我们对一系列操作的总成本进行评估，而不仅仅是个别操作的成本。

摊还分析是分析算法运行时间的一种方法，它考虑的是算法在其生命周期内的一系列操作。这种方法通常用于理解如动态数组（如C++中的 std::vector ）的底层数据结构操作。

举一个摊还分析的例子，考虑动态数组的扩展机制。当我们向动态数组添加元素时，如果数组已满，则需要扩展数组大小。假设每次扩展数组时，我们将其容量加倍。摊还分析可以证明，尽管单次扩展操作可能是昂贵的，但在一系列插入操作中，每次操作的平均成本仍然是常数时间。

时间复杂度的深入分析有助于我们更精确地预测和优化算法在实际应用中的性能。

在本章中，我们介绍了时间复杂度的基本概念，进行了比较常见的算法复杂度分析，并对如何进行最坏情况和平均情况下的时间复杂度分析做了深入探讨。随着进一步学习，你会发现时间复杂度分析对于优化算法性能，以及在软件工程中设计有效的解决方案至关重要。

本文还有配套的精品资源，点击获取

简介：本资料详细解析了华中科技大学计算机学院数据结构实验的四个关键部分：顺序表、单链表、二叉树和邻接表（无向图）。实验以C语言实现为示例，涵盖了这些基本数据结构的创建、操作和应用，以及在实现中对时间复杂度的理解。顺序表利用数组实现，单链表通过节点和指针动态存储数据，二叉树用递归思想和不同遍历方法处理，邻接表则用于表示无向图的结构。通过这些实验，学生可以加深对数据结构基本概念和算法操作的理解，并提高编程能力，为日后的学习和职业生涯打下基础。

本文还有配套的精品资源，点击获取