数据结构A1

第1章 顺序表和单链表

基本概念

==数据结构是一门研究如何有效组织数据，并提高数据处理效率的学科。==通过研究各种数据内部的逻辑

关系，使用某种特定的存储形式，并在此基础上对数据实施各种操作，这些工作被称为称为广义上的

算法。

• 逻辑结构
• 指数据之间的内在关系。通常有集合、线性表、树、图等常见的逻辑结构。
• 逻辑结构是数据之间本身的属性，跟我们怎么处理它们无关。

线性关系：各个元素之间是一种一对一的关系，比如图书馆中的书架的书，除了首尾两本书之外，其
余的任意一本书的编号假设是N，都有且仅有一个直接前驱节点N-1，有且仅有一个直接后继节点
N+1。这种关系就是典型的线性逻辑。

非线性关系：与上述线性关系的表述不同，如果各个元素之间不是严格一对一的关系，则被称为非线
性关系，比如家族中的各个成员、不同城市间的交通道路等，对于它们中间的某个元素，都可能有不
止一个元素与之关联。这种关系是典型的非线性逻辑。

• 存储形式
• 数据的存储方式。比如顺序存储、链式存储等。
• 不同的存储形式对最终数据的处理效率通常有很大的影响。
• 逻辑结构与存储形式并无必然联系。

算法分析

算法分析是指算法在正确的情况下，对其优劣的分析。一个好的算法通常是指：

1. 算法对应的程序所耗时间少

2. 算法对应的程序所耗存储空间少

3. 算法结构性好、易读、易移植和调试
   数据结构与算法的本质任务，是提高程序的时间空间效率，简单讲就是让程序的执行速度越快越好，
   所需内存空间越少越好。虽然在很多情况下，程序的时空特性是相互制约的，就像鱼和熊掌不可兼
   得，但我们可以根据程序实际解决问题的侧重点，去平衡时间和空间的对性能的消耗。

2.1 时间复杂度

一般而言，时间复杂度并不考察一段代码运行所需要的绝对时间，因为不同的计算机的硬件参数不
同，考察绝对时间没有意义。时间复杂度一般指的是代码的语句执行总次数，称为语句频度。比如：

void counting(int n)
{
    for(int i=0; i<n; i++)
    {
        printf("本行语句将会出现n次\n");
        for(int j=0; j<n; j++)
        {
            printf("本行语句将会出现n*n次\n");
        }
    }
}

在上述代码中，程序执行的语句频度理论是：T(n) = n*n+n

但一般情况下，我们只关心多项式的最高次幂，于是上述代码的时间复杂度我们表示为：

T(n) = O(n*n)

这意味着，该程序算法所需要的时间，与传进来的参数n的平方成正比。
不同算法的时间复杂度相差很大，如下图所示，随着所处理的问题规模的增大，不同时间复杂度的程
序所需要的时间有天壤之别。

2.2 空间复杂度

空间复杂度的概念更简单一点，就是一段程序运行时所需的内存字节量。

2.3 时空复杂度互换

一段程序的性能指标，既要运行快速，又要节省内存，而通常这两者又是相互制约的，很难兼得。因
此在实际解决问题时，会根据需要侧重一方，牺牲另一方。

线性表

3.1 概念

对于一组拥有n个数据元素的线性表，其严格数学定义是：其中任何一个数据元素 ，有且仅有一个直
接前驱 ，有且仅有一个直接后继 。首元素 无直接前驱，尾元素 无直接后继。
满足这种数学关系的一组数据，当中的数据是一个挨着一个的，常被称为一对一关系。反之，如果数
据之间的关系不是一对一的，就是非线性的。

3.2 举例

生活中的线性表例子非常多，比如一个班级中的以学号编排的学生，一座图书馆中的以序号编排的图
书、一条正常排队等候的队列、一摞从上到下堆叠的餐盘，这些都是线性表。他们的特点都是：除了
首尾两个元素，其余任何一个元素前后都对应相邻的另一个元素。

注意：
线性表是一种数据内部的逻辑关系，与存储形式无关
线性表既可以采用连续的顺序存储，也可以采用离散的链式存储

顺序表

4.1 基本概念

• 顺序表：顺序存储的线性表。
• 链式表：链式存储的线性表，简称链表。

顺序存储就是将数据存储到一片连续的内存中，在C语言环境下，可以是具名的栈数组，或者是匿名的
堆数组。
存储方式不仅仅只是提供数据的存储空间，而是必须要能体现数据之间的逻辑关系。当采用顺序存储
的方式来存放数据时，唯一能用来表达数据间本身的逻辑关系的就是存储位置。比如队列中的两个
人，小明和小花，如果小明在逻辑上排在相邻的小花的前面，那么在存储位置上也必须把小明存放在
相邻的小花的前面。

4.2 基本操作

顺序表设计
一般而言，为了方便操作顺序表，需要一个专门管理顺序表的”管理结构体“，管理结构体中一般会
包含：

1. 顺序表总容量
2. 顺序表当前最末元素下标位置
3. 顺序表指针
   下面是管理结构体示例代码

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
typedef struct
{
int capacity; // 顺序表容量
int last; // 最末元素下标
int * data; // 顺序表，以整型数据为例
}sequenceList;

初始化
所谓初始化就是建立一个不包含任何元素的顺序表，设置好管理结构体中的表的总容量、末元素下
标，申请好顺序表内存空间等系列准备工作。

下面是初始化顺序表的示例代码：

sequenceList *init_list(int cap)
{
    sequenceList *list = malloc(sizeof(sequenceList));
    if(list != NULL)
    {
        list -> data = malloc(sizeof(int) *cap);
        if(list -> data == NULL)
        {
            free(list);
            return NULL;
        }
        list -> capacity = cap;
        list -> last = -1;
    }
    return list;
}    

测试

int main()
{
    sequenceList *list = init_list(10);
    if(list == NULL)
    {
        perror("初始化顺序表失败!");
        exit(0);
    }
    else
    {
        printf("初始化顺序表成功！\n");
    }
}

• 增删节点

在顺序表中增加一个数据，可以有多种方式，比如在原数组的末尾增加，或者在原数组的头部增
加，或者在数组中间任意一个位置增加。根据实际需要来定。
下面以在顺序表头部增删数据为例，示例代码如下：

// 判定顺序表是否为空
bool isEmpty(sequenceList *s)
{
    return s->last == -1;
}
// 判定顺序表是否已满
bool isFull(sequenceList *s)
{
    return s->last == s->capacity-1;
}
// 在顺序表表头插入一个新数据
bool insert(sequenceList *s, int data)
{
    if(isFull(s))
        return false;
    // 将原有数据全部往后挪一位
    for(int i=s->last; i>=0; i--)
        s->data[i+1] = s->data[i];
    // 将新数据置入表头
    s->data[0] = data;
    s->last++;
    return true;
}
// 将顺序表表头的数据删除掉
bool removeNode(sequenceList *s)
{
    if(isEmpty(s))
        return false;
    // 将所有数据全部往前挪一位
    for(int i=0; i<s->last; i++)
        s->data[i] = s->data[i+1];
    s->last--;
    return true;
}    

• 销毁顺序表

一个顺序表最后不再需要，应当要释放其所占用的内存空间，这被称为顺序表的销毁。
下面是销毁操作的示例代码：

void destroy(sequenceList *s)
{
    if(s == NULL)
        return;
    free(s->data);
    free(s);
}

4.3 完整代码

• seqlist.h

#ifndef __SEQLIST_H
#define __SEQLIST_H
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <stdbool.h>
typedef struct
{
int capacity; // 顺序表容量
int last; // 最末元素下标
int *data; // 顺序表，以整型数据为例
} sequenceList;
// 初始化顺序表
sequenceList *init_list(int cap);
// 判断顺序表是否写满
bool isFull(sequenceList *list);
// 向顺序表插入数据
bool insert(sequenceList *s, int data);
// 非空校验
bool isEmpty(sequenceList *list);
// 遍历顺序表
void show(sequenceList *list);
// 删除顺序表数据
bool removeNode(sequenceList *list, int data);
// 释放内存
void destroy(sequenceList *s);

#endif

• seqlist.c

#include "seqlist.h"
sequenceList *init_list(int cap)
{
    sequenceList *list = malloc(sizeof(sequenceList));
    if (list != NULL)
    {
        list->data = malloc(sizeof(int) * cap);
        if (list->data == NULL)
        {
            free(list);
            return NULL;
        }
        list->capacity = cap;
        list->last = -1;
    }
    return list;
}
bool isFull(sequenceList *list)
{
    return list->last == list->capacity - 1;
}
// 在顺序表表头插入一个新数据
bool insert(sequenceList *s, int data)
{
    if (isFull(s))
        return false;
    // 将原有数据全部往后挪一位
    for (int i = s->last; i >= 0; i--)
        s->data[i + 1] = s->data[i];
    // 将新数据置入表头
    s->data[0] = data;
    s->last++;
    return true;
}
// 判断是否为空
bool isEmpty(sequenceList *list)
{
    return list->last == -1;
}
// 查看当前顺序表的元素
void show(sequenceList *list)
{
    if (isEmpty(list))
    {
        return;
    }
    for (int i = 0; i <= list->last; i++)
        printf("%d\t", list->data[i]);
    printf("\n");
}
// 将顺序表中指定的某个元素删除掉
bool removeNode(sequenceList *list, int data)
{
    if (isEmpty(list))
        return false;
    // 找到要删除的节点的位置
    int i, pos = -1;
    for (i = 0; i <= list->last; i++)
    {
        if (list->data[i == data])
        {
            pos = i;
            break;
        }
    }
    // 找不到要删除的元素
    if (i > list->last)
    {
        return false;
    }
    // 将所有数据全部往前挪一位
    for (int i = 0; i < list->last; i++)
        list->data[i] = list->data[i + 1];
    list->last--;
    return true;
}
// 释放内存
void destroy(sequenceList *s)
{
    if(s == NULL)
        return;
    free(s->data);
    free(s);
}
int main()
{
    // 创建顺序表
    sequenceList *list = init_list(10);
    if (list == NULL)
    {
        perror("初始化顺序表失败!");
        exit(0);
    }
    else
    {
        printf("初始化顺序表成功！\n");
    }
    // 测试向顺序表插入/删除信息
    int n;
    while (true)
    {
        scanf("%d", &n);
        if (n > 0)
        {
            // 插入
            if (!insert(list, n))
            {
                printf("容量已满，插入失败！\n");
                continue;
            }
        }
        else if(n < 0)
        {
            // 删除
            if(!removeNode(list,-n)) 
            {
                printf("查无此数，删除失败！\n");
                continue;
            }
        }
        // 遍历
        show(list);
    }
    // 释放
    destroy(list);
}