数据结构(顺序表)

数据结构概述

什么是数据结构

数据结构: 数据结构就是计算机存储,组织,管理数据的方式方法;

数据结构的类型

① 根据数据的逻辑结构划分 (数据间关系)

  1. 集合:数据结构中的元素之间除了"同属一个组织"之外,别无其他关系;
  2. 线性数据结构: 数据之间 "一对一"的关系,数据具有唯一的前驱和后继, 典型代表是链表
  3. 非线性数据结构:数据之间不具有唯一的前驱和后继。例如: 二维数组,二叉树., 典型代表 是二叉树

② 根据数据在内存中的存储方式划分

  1. 顺序结构:各个元素存储在连续的内存空间 , 典型代表是数组
  2. 链式结构:各个元素存储在不连续的内存空间 , 典型代表是链表
  3. 索引结构:元素在存储时,不仅存储元素数据,还建立元素附加的索引表来标识元素的地址
  4. 哈希(散列)结构:元素在存储时,为元素提供关键字,在元素访问时,可根据关键字来访问数 据。

常见的数据结构

链表 顺序表 树 图 映射 栈 队列.

算法分析

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

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

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

  3. 算法结构性好、易读、易移植和调试

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

2.1 时间复杂度

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

c 复制代码
 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");
 }
 }

在上述代码中,程序执行的语句频度理论是:

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

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

2.2 空间复杂度

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

2.3 时空复杂度互换

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

线性表

概念

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

举例

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

注意:

线性表是一种数据内部的逻辑关系,与存储形式无关

线性表既可以采用连续的顺序存储(顺序表),也可以采用离散的链式存储(链表)

顺序表

基本概念

  1. 顺序表:顺序存储的线性表。
  2. 链式表:链式存储的线性表,简称链表。

顺序存储就是将数据存储到一片连续的内存中,在C语言环境下,可以是 具名的堆数组。 具名的栈数组,或者是匿

存储方式不仅仅只是提供数据的存储空间,而是必须要能体现数据之间的逻辑关系。当采用顺序存 储的方式来存放数据时,唯一能用来表达数据间本身的逻辑关系的就是存储位置。比如队列中的两 个人,小明和小花,如果小明在逻辑上排在相邻的小花的前面,那么在存储位置上也必须把小明存 放在相邻的小花的前面。

基本操作

  • 基本操作

    一般而言,为了方便操作顺序表,需要一个专门管理顺序表的"管理结构体",管理结构体中一般 会包含:

    1. 顺序表总容量
    2. 顺序表当前最末元素下标位置
    3. 顺序表指针

    下面是管理结构体示例代码:

    c 复制代码
     #include <stdio.h>
     #include <stdlib.h>
     #include <unistd.h>
     #include <string.h>
     typedef struct
     {
     int   capacity; // 顺序表容量
    int   last;     // 最末元素下标
    int * data;     
    }sequenceList;
    • 初始化

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

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

    c 复制代码
    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;
     }

    测试

    c 复制代码
     int main()
     {
     sequenceList *list = init_list(10);
     if(list == NULL)
     {
       perror("初始化顺序表失败!");
            exit(0);
        }
        else
        {
            printf("初始化顺序表成功!\n");
        }
     }
     
    • 增删节点

      在顺序表中增加一个数据,可以有多种方式,比如在原数组的末尾增加,或者在原数组的头部 增加,或者在数组中间任意一个位置增加。根据实际需要来定。

    下面以在顺序表头部增删数据为例,示例代码如下:

    c 复制代码
     // 判定顺序表是否为空
    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;
     }
    • 销毁顺序表

      一个顺序表最后不再需要,应当要释放其所占用的内存空间,这被称为顺序表的销毁。

      下面是销毁操作的示例代码:

      c 复制代码
      void destroy(sequenceList *s)
       {
       if(s == NULL)
       return;
       free(s->data);
       free(s);
       }

完整代码

  • seqlist.h
c 复制代码
 #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

    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 = pos; 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);
    }

练习 1

创建一个顺序表,并从键盘接收数字输入,将输入的正整数按从小到大的顺序插入顺序表,并在输 入负整数的时候将其绝对值数据删除。每次输入后,将顺序表的内容打印到屏幕上。

解析 : 此题考查顺序表的基本思路,先要设计好顺序表的逻辑表达,再通过对顺序表的插入和删除操作, 体会顺序存储中对于插入和删除的不便性。

参考代码 :

c 复制代码
#include <stdio.h>
 #include <stdbool.h>
 #include <stdlib.h>
 typedef struct
 {
       int total_size; // 顺序表总容量
    int last;       // 顺序表最末元素的下标
    int *data;      // 顺序表的存储空间
}sqlist;
 // 初始化一个空的顺序表
sqlist * init_list(int total_size)
 {
    sqlist *sq = (sqlist *)malloc(sizeof(sqlist));
    if(sq != NULL)
    {
        sq->total_size = total_size;
        sq->last       = -1; // 用-1表征当前没有元素
        sq->data = (int *)malloc(sizeof(int) * total_size);
        if(sq->data == NULL)
        {
            free(sq);
        }
    }
    return sq;
 }
 // 在递增的顺序表中找到x应插入的合适位置
int get_pos(sqlist *sq, int x)
 {
    int pos = 0;
    while((pos<=sq->last) && (sq->data[pos]<x))
        pos++;
    // 当链表为空(即sq->last为-1时),返回0
    return pos;
 }
 // 判断顺序表是否已满
bool is_full(sqlist *sq)
 {
    return sq->last >= sq->total_size-1;
 }
 // 将元素x插入顺序表sq中
bool insert(sqlist *sq, int x)
 {
    if(is_full(sq))
        return false;
    // 在顺序表中得到即将要插入的元素x的合适的位置
    int pos = get_pos(sq, x);
    // 将顺序表中pos往后的所有元素往后挪一位
        for(int i=sq->last; i>=pos; i--)
        sq->data[i+1] = sq->data[i];
    sq->data[pos] = x;
    sq->last++;
    return true;
 }
 // 在顺序表sq中,定位元素x
 int locate(sqlist *sq, int x)
 {
    int pos;
    for(pos=0; pos<=sq->last; pos++)
    {
        if(sq->data[pos] == x)
        {
            printf("data[%d]=%d\n", pos, x);
            return pos;
        }
    }
    return -1;
 }
 // 从顺序表中将元素x剔除
bool delete(sqlist *sq, int x)
 {
    int pos;
    pos = locate(sq, x);
    // 元素x不存在
    if(pos == -1)
        return false;
    // 将pos后续的元素全部往前挪一位
    for(; pos<=sq->last; pos++)
            sq->data[pos] = sq->data[pos+1];
    sq->last--;
    return true;
 }
 // 展示顺序表元素
void show_data(sqlist *sq)
 {
    for(int i=0; i<=sq->last; i++)
        printf("\tsq->data[%d]=%d\n", i, sq->data[i]);
    printf("=======================\n");
 }
int main(int argc, char *argv[])
 {
    // 初始化一条空的顺序表
    sqlist *sq = init_list(10);
    // 插入元素
    int num;
    while(1)
    {
        scanf("%d", &num);
        if(num > 0)
        {
            if(insert(sq, num))
                show_data(sq);
            else
                fprintf(stderr, "顺序表已满\n");
        }
        else if(num < 0)
        {
            if(delete(sq, -num))
                show_data(sq);
            else
                fprintf(stderr, "元素不存在\n");
        }
        else
        {
            fprintf(stderr, "BYE\n");
            break;
        }
    }
    return 0;
 }

顺序表优缺点总结

顺序存储中,由于逻辑关系是用物理位置来表达的,因此从上述示例代码可以很清楚看到,增删数 据都非常困难,需要成片地移动数据。顺序表对数据节点的增删操作是很不友好的。 总结其特点如下:

  • 优点
  1. 不需要多余的信息来记录数据间的关系,存储密度高
  2. 所有数据顺序存储在一片连续的内存中,支持立即访问任意一个随机数据,比如上述顺序表中 第个节点是 s->data[i]
  • 缺点
  1. 插入、删除时需要保持数据的物理位置反映其逻辑关系,一般需要成片移动数据
  2. 当数据节点数量较多时,需要一整片较大的连续内存空间
  3. 当数据节点数量变化剧烈时,内存的释放和分配不灵活
相关推荐
AC使者1 小时前
5820 丰富的周日生活
数据结构·算法
无 证明2 小时前
new 分配空间;引用
数据结构·c++
别NULL6 小时前
机试题——疯长的草
数据结构·c++·算法
ZSYP-S8 小时前
Day 15:Spring 框架基础
java·开发语言·数据结构·后端·spring
唐叔在学习8 小时前
【唐叔学算法】第21天:超越比较-计数排序、桶排序与基数排序的Java实践及性能剖析
数据结构·算法·排序算法
ALISHENGYA8 小时前
全国青少年信息学奥林匹克竞赛(信奥赛)备考实战之分支结构(switch语句)
数据结构·算法
武昌库里写JAVA11 小时前
浅谈怎样系统的准备前端面试
数据结构·vue.js·spring boot·算法·课程设计
S-X-S11 小时前
代码随想录刷题-数组
数据结构·算法
l1384942745111 小时前
每日一题(4)
java·数据结构·算法
kyrie_sakura11 小时前
c++数据结构算法复习基础--13--基数算法
数据结构·c++·算法