算法与数据结构01（基础篇）——逻辑结构与存储结构

没有剑的叶孤城
990 阅读6分钟

思维导图

一、什么是数据结构

官方定义：数据结构（英语：data structure）是计算机中存储、组织数据的方式。

数据的组织形式，数据元素之间存在的一种或多种特定关系的数据元素集合

通俗地讲，数据结构 = 存储结构 + 逻辑结构。

1.1 基本概念

数据对象：

性质相同的数据元素的集合，是数据的一个子集

数据元素：

数据的基本单位

数据项

组成数据元素的最小单位

结构体Student就是一种数据结构，定义的name、age是数据项，Student 创建的 s1、s2... 是具体的 数据元素，由多个s1、s2...构成的数组studentArr[10] 即是数据对象

1.2 由此，我们总结出下方的关系图

二、逻辑结构

大家耳熟能详的：线性表（顺序表、链表）、栈、队列、字符串、各种图结构、集合结构、各种树结构、二维数组、多维数组等

逻辑结构又分为 线性结构 和 非线性结构

2.1 线性结构

一个有序数据元素的集合

2.1.1 特点

1．集合中必存在唯一的一个"第一个元素";<br>
2．集合中必存在唯一的一个"最后的元素"；<br>
3．除最后元素之外，其它数据元素均有唯一的"后继"；<br>
4．除第一元素之外，其它数据元素均有唯一的"前驱"。<br>

2.1.2 举例：

线性表（顺序表、链表）、栈、队列、字符串

2.2 非线性结构

各个数据元素不再保持在一个线性序列中，每个数据元素可能与零个或者多个其他数据元素发生联系

2.2.1 举例

各种图结构、集合结构、树结构、二维数组、多维数组等

2.3 逻辑结构总结

三、存储结构

数据元素之间的关系有两种不同的表示方法：顺序映象 和 非顺序映象，并由此得到两种不同的存储结构：顺序存储结构 和 链式存储结构。 数据的存储结构是指数据的逻辑结构在计算机中的表示。

下面分别讲顺序存储结构和链式存储结构

3.1 顺序存储结构

需要在内存中先开辟一块 连续的 存储空间

注意：一定是先开辟空间，而且是连续的。

顺序存储因为需要开辟一块连续的空间，所以在内存的利用率上不如链式结构，当处理增、删、改的操作时，需要处理后续的每一个数据元素，但是在执行查找操作时，按索引找到对应数据元素即可。

3.1.1 顺序表的操作

用为伪代码或文字演示

// 定义
typedef int ElemType;

typedef struct {
    ElemType *data;
    int length;
} List;

创建

// 创建顺序表
List L;
L->data =  malloc(sizeof(ElemType) * MAXSIZE);
L->length = 0;

清空

L->length = 0;

销毁

free(L)

插入

插入位置i 插入元素e 
1、在L中找到插入位置i，
2、从i到L为元素依次向后移动一位，此时，L中i的位置空出，
3、将e放入i的位置中，L长度+1，完成插入操作。

删除

1、根据删除位置i找到i+1至表尾的所有元素
2、i+1到表尾的元素依次向前移动一位
3、L长度-1 ，完成删除操作

3.2 链式存储结构

链式存储结构，又叫链接存储结构。在计算机中用一组任意的存储单元存储线性表的数据元素(这组存储单元可以是连续的,也可以是不连续的).

它不要求逻辑上相邻的元素在物理位置上也相邻.因此它没有顺序存储结构所具有的弱点,但也同时失去了顺序表可随机存取的优点.

3.2.1 链式存储的操作 （以双链表为例）

只写出核心步骤

// 定义节点等数据结构
typedef struct Node{
    ElemType data;  // 数据
    struct Node *next;  // 后继指针 指向下一个节点
    struct Node *pre;   // 前驱指针 指向前一个节点
}Node;

typedef struct Node * List;

3.2.1.1 创建

List L = (List)malloc(sizeof(Node));
L->next = NULL;
L->pre = NULL;

3.2.1.2 插入

问题描述：向p和q节点之间插入s
算法描述：

1、新元素s的后继指针指向后面的q;
2、q的前驱指针指向s；
3、s的前驱动指针指向前面的p；
4、p的后继指针指向s；

代码描述：

s->next = q;
q->pre = s;
s->pre = p;
p->next = s;

或者只用节点p和s

s->next = p->next;
p->next>-pre = s;
s->pre = p;
p->next = s

3.2.1.3 删除

问题描述：删除p、s、q顺序中的s
算法描述：

1、p的后继指针指向q;
2、q的前驱指针指向p；
3、销毁s

代码描述：

p-next = p->next->next;
p->next->pre = p;
free(s);

3.2.1.4 前插法创建链表

算法描述：

核心思想：根据持有的头节点，新节点始终插入在头节点之后，成为新的首元节点
步骤：
1、根据头节点后找到首元节点，即头节点之后的节点；
2、创建新节点，新节点的后继指针指向首元节点；
3、首元节点的前驱指针指向新节点；
4、头节点的后继指针指向新节点；
5、新节点的前驱指针指向头节点；

/* 随机产生n个元素值,建立带表头结点的双链线性表L(前插法)*/
void CreateListHead(LinkList *L, int n)
{
    LinkList p;
    LinkList list;
    
    //建立1个带头结点的双链表
    *L = (LinkList)malloc(sizeof(Node));
    list = *L;
    
    list->next = NULL;
    list->pre = NULL;
    
    //循环前插入随机数据
    for(int i = 0; i < n;i++)
    {
        //生成新结点
        p = (LinkList)malloc(sizeof(Node));
       
        //i赋值给新结点的data
        p->data = i;
        
        // 将原先list的后继节点和p建立双指向
        p->next = list->next;
        if (list->next != NULL) list->next->pre = p;
        
        //将结点P插入到头结点
        list->next = p;
        p->pre = list;
    }
}

3.2.1.5 尾插法创建链表

算法描述

核心思想：根据持有的尾节点，每次新插入的节点均插入到链表的尾节点之后，成为新的尾节点。
步骤：
1、将尾节点p的后继指针指向新节点q；
2、新节点q的前驱指针指向原尾节点p；q已经成了尾节点；
3、尾节点q的next置为NULL。

/* 随机产生n个元素值,建立带表头结点的单链线性表L(后插法)*/
void CreateListTail(LinkList *L, int n)
{
    // p 每次新产生的节点， r 当前的尾节点，每次尾插入后，及时更新r
    LinkList p,r;
 
    //建立一个带头结点的双链表
    *L = (LinkList)malloc(sizeof(Node));
    //r指向尾部的结点
    r = *L;
    
    for (int i=0; i<n; i++) {
        
        //生成新结点
        p = (Node *)malloc(sizeof(Node));
        p->data = i;
        
        // 将表尾终端结点的指针指向新结点
        r->next = p;
        // 新尾节点p的前驱指针指向前面的r
        p->pre = r;
        
        //将当前的新结点定义为表尾终端结点
        r = p;
    }
    
    //将尾指针的next = null
    r->next = NULL;
    
}

3.4 存储结构总结

avatar
文章
阅读
粉丝