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

思惟导图

1、什么是数据结构

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

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

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

1.1 基本概念

数据对象：

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

数据元素：

数据的基本单位

数据项

组成数据元素的最小单位

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

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

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、存储结构

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

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

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 
一、在L中找到插入位置i，
二、从i到L为元素依次向后移动一位，此时，L中i的位置空出，
三、将e放入i的位置中，L长度+1，完成插入操做。
复制代码

删除

一、根据删除位置i找到i+1至表尾的全部元素
二、i+1到表尾的元素依次向前移动一位
三、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
算法描述：

一、新元素s的后继指针指向后面的q;
二、q的前驱指针指向s；
三、s的前驱动指针指向前面的p；
四、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
算法描述：

一、p的后继指针指向q;
二、q的前驱指针指向p；
三、销毁s
复制代码

代码描述：

p-next = p->next->next;
p->next->pre = p;
free(s);
复制代码

3.2.1.4 前插法建立链表

算法描述：

核心思想：根据持有的头节点，新节点始终插入在头节点以后，成为新的首元节点
步骤：
一、根据头节点后找到首元节点，即头节点以后的节点；
二、建立新节点，新节点的后继指针指向首元节点；
三、首元节点的前驱指针指向新节点；
四、头节点的后继指针指向新节点；
五、新节点的前驱指针指向头节点；
复制代码

/* 随机产生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 尾插法建立链表

算法描述

核心思想：根据持有的尾节点，每次新插入的节点均插入到链表的尾节点以后，成为新的尾节点。
步骤：
一、将尾节点p的后继指针指向新节点q；
二、新节点q的前驱指针指向原尾节点p；q已经成了尾节点；
三、尾节点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 存储结构总结