【线性表，线性表中的顺序表和链表】

目录

  • 1、线性表的定义和基本操作
    • 1.1、线性表的定义
    • 1.2、线性表的基本操作
  • 2、顺序表和链表的比较
    • 2.1、顺序表
      • 2.1.1、顺序表的定义和特点
      • 2.1.2、顺序表的实现
        • （1）顺序表的静态分配：
        • （2）顺序表的动态分配
      • 2.1.3、顺序表的基本操作：
        • （1）插入操作
        • （2）删除操作
        • （3）按位查找
        • （4）按值查找
    • 2.2、链表
      • 2.2.1、链表的定义及特点
      • 2.2.2、链表的实现方式
        • （1）带头结点
        • （2）不带头结点：
      • 2.2.3、单链表的基本操作
        • （1）单链表的插入
        • （2）指定结点的后插操作
        • （3）指定结点的前插操作
        • （4）单链表的删除
          • 1）按位序删除结点
          • 2）指定结点的删除
        • （5）单链表的查找
          • 1）按位查找
          • 2）按值查找
        • （6）求单链表的长度
        • （7）单链表的建立
          • 1）尾插法建立单链表
          • 2）头插法建立单链表
          • 3）链表的逆置
      • 2.2.4、双链表
        • 2.2.4.1、双链表的初始化（带头结点）
        • 2.2.4.2、双链表的插入（后插）
        • 2.2.4.3、双链表的删除（后删）和销毁
        • 2.2.4.4、双链表的遍历
          • 1）前向遍历
          • 2）后向遍历
      • 2.2.5、循环链表
        • 2.2.5.1、循环单链表
        • 2.2.5.2、循环双链表
        • 2.2.5.3、循环链表的插入
        • 2.2.5.4、循环链表的删除
      • 2.2.6、静态链表
        • 2.2.6.1、静态链表的定义
    • 2.3、顺序表和链表的比较

1、线性表的定义和基本操作

1.1、线性表的定义

线性表是具有相同数据类型的n（n>0）个数据元素的有限序列。
其中n为表长，当n=0时，线性表是一个空表，若用L命名线性表，则其一般表示为：
在这里插入图片描述
特点：

  1. 存在唯一的第一个元素；
  2. 存在唯一的最后一个元素；
  3. 除第一个元素外，每个元素均只有一个直接前驱；
  4. 除最后一个元素外，每个元素均只有一个直接后继；

【直接前驱】：指在该序列中位于其前面且紧邻的元素；
【直接后继】：指在该序列中位于其后面且紧邻的元素。
例如：在一个整数数组[1，5，8，10，49]中，元素8的直接前驱为5，直接后继为10。

1.2、线性表的基本操作

  1. InitList(&L)：初始化表，构造一个空的线性表L，分配内存空间；
  2. DestroyList(&L)：销毁操作，销毁线性表，并释放线性表L所占用的空间；
  3. ListInsert(&L;i,e)：插入操作，在线性表L中的第i个位置上插入指定元素e；
  4. ListDelete(&L;i,&e)：删除操作，删除线性表L中第i个位置处的元素，并用e返回删除的元素；
  5. LocateElem(L,e)：按值查找操作，在表L中查找具有给定关键字值的元素；
  6. GetElem(L,i)：按位查找操作，获取表L中第i个位置上的元素的值；
  7. Length(L)：求表长，返回线性表L的长度，即L中数据元素的个数；
  8. PrintList(L)：输出操作，按照前后顺序输出线性表L中的所有元素值；
  9. Empty(L)：判空操作，若L为空表，则返回为true，否则返回false。
    发现在上述操作中，创销增删时传入的是参数的引用，其余操作传入的是参数，涉及到了传值调用和传址调用，如下：
    1.传值调用
#include<stdio.h>
void test(int x) {x = 1024;printf("test函数内部 x = %d\n",x);
}int main() {int x = 1;printf("调用test前 x = %d\n", x);test(x);printf("调用test后 x = %d\n", x);return 0;
}

程序输出结果为：
在这里插入图片描述
2.传址调用

#include<stdio.h>
void test(int &x) {x = 1024;printf("test函数内部 x = %d\n",x);
}int main() {int x = 1;printf("调用test前 x = %d\n", x);test(x);printf("调用test后 x = %d\n", x);return 0;
}

程序输出结果为：
在这里插入图片描述

2、顺序表和链表的比较

2.1、顺序表

2.1.1、顺序表的定义和特点

顺序表： 用顺序存储的方式实现线性表顺序存储，把逻辑上相邻的元素存储在物理位置上也相邻的存储单元中，元素之间的关系由存储单元的邻接关系来体现。

顺序表的特点：

  1. 随机访问，即可以在O(1)时间内找到第i个元素；
  2. 存储密度高，每个节点只存储数据元素；
  3. 拓展容量不方便，即使使用动态分配的方式实现，拓展长的的时间复杂度也比较高，因为需要把数据复制到新的区域；
  4. 插入删除操作不方便，需要移动大量的元素，时间复杂度为：O(n)。

2.1.2、顺序表的实现

顺序表的实现：顺序表的实现有静态分配和动态分配。

（1）顺序表的静态分配：
  1. 使用静态数组实现；
  2. 顺序表的表长刚开始确定后就无法再更改（存储空间是静态的）。
#include<stdio.h>
#define MaxSize 10 //定义表长最大值为10using namespace std;typedef struct {int data[MaxSize];//用静态数组存放数据元素int length;//顺序表的当前长度
}ArrayList;//顺序表的定义类型（静态分配方式）void initList(ArrayList &L) {for (int i = 0; i < MaxSize;i++) {L.data[i] = 0;//将所有数据元素设置为默认初始值}L.length = 0;
}
void insertList(ArrayList& L,int i,int e) {}int main() {ArrayList L;//声明一个顺序表initList(L);//初始化一个顺序表for (int i =0; i < MaxSize; i++) {printf("data[%d] = %d\n", i, L.data[i]);//顺序表的打印}return 0;
}
（2）顺序表的动态分配
#include<stdio.h>
#include<stdlib.h>//malloc,free的头文件
#define initsize 10 //默认是初始值typedef struct{int* data;int MaxSize;//顺序表的最大容量int length;//顺序表的当前长度
}Seqlist;void initlist(Seqlist& L) {//用malloc函数申请一片连续的存储的空间L.data = (int*)malloc(initsize * sizeof(int));L.length = 0;L.MaxSize = initsize;
}void increaseSize(Seqlist &L,int len) {int* p = L.data;L.data = (int*)malloc((L.MaxSize + len) * sizeof(int));for (int i = 0; i < L.length;i++) {L.data[i] = p[i];//将原有数据复制到新区域}L.MaxSize = L.MaxSize + len;//顺序表的最大长度增加lenfree(p);//释放原来的内存空间}int main() {Seqlist L;initlist(L);increaseSize(L,5);return 0;
}

2.1.3、顺序表的基本操作：

（1）插入操作

ListInsert(&L,i,e)：在第i个位置处插入指定元素e，平均时间复杂度为：O(n)

#define MaxSize 10    //定义最大长度
typedef struct{int data[MaxSize];  //用静态的数组存放数据int length;         //顺序表的当前长度
}SqList;                //顺序表的类型定义  bool ListInsert(SqList &L, int i, int e){ if(i<1||i>L.length+1)    //判断i的范围是否有效return false;if(L.length>=MaxSize) //当前存储空间已满，不能插入  return false;for(int j=L.length; j>=i; j--){    //将第i个元素及其之后的元素后移L.data[j]=L.data[j-1];}L.data[i-1]=e;  //在位置i处放入eL.length++;      //长度加1return true;
}int main(){ SqList L;   //声明一个顺序表InitList(L);//初始化顺序表//...此处省略一些代码；插入几个元素ListInsert(L,3,3);   //再顺序表L的第三行插入3return 0;
}
（2）删除操作

ListDelete(&L,i,&e)：删除表L中第i个位置处的元素，并用e返回删除元素的值，平均时间复杂度为：O(n)

#define MaxSize 10typedef struct {int data[MaxSize];int length;
} SqList;// 删除顺序表i位置的数据并存入e
bool ListDelete(SqList &L, int i, int &e) {if (i < 1 || i > L.length) // 判断i的范围是否有效return false;e = L.data[i-1]; // 将被删除的元素赋值给e for (int j = i; j < L.length; j++) //将第i个位置后的元素前移 L.data[j-1] = L.data[j];L.length--;return true; 
}int main() {SqList L;InitList(L);int e = -1;if (ListDelete(L, 3, e))printf("已删除第3个元素，删除元素值为%d\n", e);elseprintf("位序i不合法，删除失败\n"); return 0; 
}
（3）按位查找

GetElem(L，i)：获取顺序表L中第i个位置上的元素，平均时间复杂度为：O(1)

// 静态分配的按位查找
#define MaxSize 10typedef struct {ElemType data[MaxSize]; int length;
}SqList;ElemType GetElem(SqList L, int i) {return L.data[i-1];
}

// 动态分配的按位查找
#define InitSize 10typedef struct {ElemType *data;int MaxSize;int length;
}SeqList;ElemType GetElem(SeqList L, int i) {return L.data[i-1];
}
（4）按值查找

LocateElem（L，e）：在表L中查找具有给的那个关键字值的元素，平均时间复杂度为：O(n)

#define InitSize 10          //定义最大长度 
typedef struct{ElemTyp *data;           //用静态的“数组”存放数据元素 int Length;              //顺序表的当前长度
}SqList;   //在顺序表L中查找第一个元素值等于e的元素，并返回其位序
int LocateElem(SqList L, ElemType e){for(int i=0; i<L.lengthl i++)if(L.data[i] == e)  return i+1;     //数组下标为i的元素值等于e，返回其位序i+1return 0;               //推出循环，说明查找失败
}
//调用LocateElem(L,9)

2.2、链表

2.2.1、链表的定义及特点

单链表： 用链式存储实现了线性结构，一个结点存储一个数据元素，各结点间的前后关系用一个指针表示。

特点：

  1. 优点：不要求大片连续空间，改变容量方便
  2. 缺点：不可随机存取，要耗费一定空间存放指针
//定义单链表结点类型
typedef struct LNode{ElemType data;//数据域struct LNode *next;//指针域
}LNode, *LinkList;

强调这是一个结点的时候用LNode*;
强调这是一个单链表的时候用LinkList。

2.2.2、链表的实现方式

（1）带头结点

写代码更方便，头结点不存储数据，头结点指向的下一个结点才存放实际数据；

#include<stdlib.h>
#include<stdio.h>typedef int ElemType;typedef struct LNode {ElemType data;struct LNode* next;
}LNode, * LinkList;//初始化一个单链表（带头结点）
bool initList(LinkList& L) {L = (LNode*)malloc(sizeof(LNode));//头指针指向的结点，分配一个头结点（不存储数据）if (L == NULL)return false;//内存不足，分配失败L->next = NULL;//头结点之后暂时还没有结点return true;
}void test() {LinkList L;initList(L);//...
}//判断单链表是否为空（带头结点）
bool Empty(LinkList L) {if (L->next == NULL)return true;else return false;
}
（2）不带头结点：

麻烦，对第一个数据结点与后续数据结点的处理需要用不同的代码逻辑，对空表和非空表的处理需要用到不同的代码逻辑。

typedef struct LNode{ElemType data;struct LNode *next;
}LNode, *LinkList;//初始化一个空的单链表
bool InitList(LinkList &L){L = NULL; //空表，暂时还没有任何结点return true;
}void test(){LinkList L;  //声明一个指向单链表的头指针//初始化一个空表InitList(L);...
}//判断单链表是否为空
bool Empty(LinkList L){return (L==NULL)
}

2.2.3、单链表的基本操作

（1）单链表的插入

ListInsert(&L,i,e)： 在表L中第i个位置处插入一个元素e。找到第i-1个结点（前驱结点），将新结点插入其后，其中头结点可以看做第0个结点，故i=1时也适用。
平均时间复杂度为：O(n)

//带头结点的插入
typedef struct LNode
{ElemType data;struct LNode *next;
}LNode, *LinkList;//在第i个位置插入元素e（带头结点）
bool ListInsert(LinkList &L, int i, ElemType e)
{  //判断i的合法性, i是位序号(从1开始)if(i<1)return False;LNode *p;       //指针p指向当前扫描到的结点 int j=0;        //当前p指向的是第几个结点p = L;          //L指向头结点，头结点是第0个结点（不存数据）//循环找到第i-1个结点while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULLp = p->next;             //p指向下一个结点j++;}if (p==NULL)                 //如果p指针知道最后再往后就是NULLreturn false;//在第i-1个结点后插入新结点LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点s->data = e;s->next = p->next;p->next = s;                 //将结点s连到p后,后两步千万不能颠倒return true;
}

不带头结点插入时，不存在第0个结点，因此！i = 1时，需要特殊处理：（插入删除）第1个元素时，需要更改头指针L；

typedef struct LNode
{ElemType data;struct LNode *next;
}LNode, *LinkList;bool ListInsert(LinkList &L, int i, ElemType e)
{if(i<1)return false;//插入到第1个位置时的操作有所不同！if(i==1){LNode *s = (LNode *)malloc(size of(LNode));s->data =e;s->next =L;L=s;          //头指针指向新结点return true;}//i>1的情况与带头结点一样！唯一区别是j的初始值为1LNode *p;       //指针p指向当前扫描到的结点 int j=1;        //当前p指向的是第几个结点p = L;          //L指向头结点，头结点是第0个结点（不存数据）//循环找到第i-1个结点while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULLp = p->next;             //p指向下一个结点j++;}if (p==NULL)                 //i值不合法return false;//在第i-1个结点后插入新结点LNode *s = (LNode *)malloc(sizeof(LNode)); //申请一个结点s->data = e;s->next = p->next;p->next = s;          return true;}
（2）指定结点的后插操作

InsertNextNode(LNode *p, ElemType e);
给定一个结点p，在其后插入元素e，根据单链表的链表指针只能往后查找的逻辑关系，故给定一个结点p，p之后的结点我们可以知道，之前的就无法得知了。

typedef struct LNode
{ElemType data;struct LNode *next;
}LNode, *LinkList;bool InsertNextNode(LNode *p, ElemType e)
{if(p==NULL){return false;}LNode *s = (LNode *)malloc(sizeof(LNode));//某些情况下分配失败，比如内存不足if(s==NULL)return false;s->data = e;          //用结点s保存数据元素e s->next = p->next;p->next = s;          //将结点s连到p之后return true;
}                         //平均时间复杂度 = O(1)//有了后插操作，那么在第i个位置上插入指定元素e的代码可以改成：
bool ListInsert(LinkList &L, int i, ElemType e)
{  if(i<1)return False;LNode *p;       //指针p指向当前扫描到的结点 int j=0;        //当前p指向的是第几个结点p = L;          //L指向头结点，头结点是第0个结点（不存数据）//循环找到第i-1个结点while(p!=NULL && j<i-1){     //如果i>lengh, p最后4鸟会等于NULLp = p->next;             //p指向下一个结点j++;}return InsertNextNode(p, e)
}
（3）指定结点的前插操作

设待插入结点为s，将s插入到结点p的前面，我们仍然可以将结点s插入到结点p之后，然后将p->data和s->data进行交换，这样既满足了逻辑关系，又能使得时间复杂度为O(n)。

//前插操作：在p结点之前插入元素e
bool InsertPriorNode(LNode *p, ElenType e){if(p==NULL)return false;LNode *s = (LNode *)malloc(sizeof(LNode));if(s==NULL) //内存分配失败return false;//重点来了！s->next = p->next;p->next = s;       //新结点s连到p之后s->data = p->data; //将p中元素复制到sp->data = e;       //p中元素覆盖为ereturn true;
}
（4）单链表的删除
1）按位序删除结点

ListDelete(&L,i,&e)：删除表L中第i个位置上的元素，并用e来返回删除元素的值；头结点视为第0个结点；
思路：找到第i-1个结点，将其指针指向第i+1个结点，并释放第i个结点

typedef struct LNode{ElemType data;struct LNode *next;
}LNode, *LinkList;bool ListDelete(LinkList &L, int i, ElenType &e){if(i<1) return false;LNode *p;       //指针p指向当前扫描到的结点 int j=0;        //当前p指向的是第几个结点p = L;          //L指向头结点，头结点是第0个结点（不存数据）//循环找到第i-1个结点while(p!=NULL && j<i-1){     //如果i>lengh, p最后会等于NULLp = p->next;             //p指向下一个结点j++;}if(p==NULL) return false;if(p->next == NULL) //第i-1个结点之后已无其他结点return false;LNode *q = p->next;         //令q指向被删除的结点e = q->data;                //用e返回被删除元素的值p->next = q->next;          //将*q结点从链中“断开”free(q)                     //释放结点的存储空间return true;
}
2）指定结点的删除
bool DeleteNode(LNode *p){if(p==NULL)return false;LNode *q = p->next;      //令q指向*p的后继结点p->data = p->next->data; //让p和后继结点交换数据域p->next = q->next;       //将*q结点从链中“断开”free(q);return true;
} //时间复杂度 = O(1)
（5）单链表的查找
1）按位查找

GetElem(L,i)：按位查找操作，获取表L中第i个位置上的元素
平均时间复杂度：O(n)

LNode * GetElem(LinkList L, int i){if(i<0) return NULL;LNode *p;               //指针p指向当前扫描到的结点int j=0;                //当前p指向的是第几个结点p = L;                  //L指向头结点,头结点是第0个结点(不存数据)while(p!=NULL && j<i){  //循环找到第i个结点p = p->next;j++;}return p;               //返回p指针指向的值
}
2）按值查找

GetElem(L,e)：按值查找操作，在表L中查找具有关键字值e的元素；
平均时间复杂度：O(n)

LNode * LocateElem(LinkList L, ElemType e){LNode *P = L->next;    //p指向第一个结点//从第一个结点开始查找数据域为e的结点while(p!=NULL && p->data != e){p = p->next;}return p;           //找到后返回该结点指针，否则返回NULL
}
（6）求单链表的长度

Length(LinkList L)：计算单链表中数据结点的个数（不含头结点），需要从第一个结点开始顺序依次访问表中的每个结点；
平均时间复杂度：O(n)

int Length(LinkList L){int len=0;       //统计表长LNode *p = L;while(p->next != NULL){p = p->next;len++;}return len;
}
（7）单链表的建立
  1. 初始化一个单链表
  2. 每次去一个数据元素，插入到表尾或表头
1）尾插法建立单链表

平均时间复杂度：O(n)
思路：每次都将新结点插入到当前链表的末尾，所以必须增加一个尾指针r,使其始终指向当前链表的为结点
优点：生成的链表中结点的次序和输入数据的顺序会一致

// 使用尾插法建立单链表L
LinkList List_TailInsert(LinkList &L){   int x;			//设ElemType为整型int  L = (LinkList)malloc(sizeof(LNode));     //建立头结点(初始化空表)     LNode *s, *r = L;                        //r为表尾指针    scanf("%d", &x);                         //输入要插入的结点的值   while(x!=9999){                          //输入9999表示结束     s = (LNode *)malloc(sizeof(LNode));    s->data = x;           r->next = s;           r = s;                               //r指针指向新的表尾结点     scanf("%d", &x);       }    r->next = NULL;                          //尾结点指针置空      return L;
}
2）头插法建立单链表

平均时间复杂度：O(n)

LinkList List_HeadInsert(LinkList &L){       //逆向建立单链表LNode *s;int x;L = (LinkList)malloc(sizeof(LNode));     //建立头结点L->next = NULL;                          //初始为空链表,这步不能少！scanf("%d", &x);                         //输入要插入的结点的值while(x!=9999){                          //输入9999表结束s = (LNode *)malloc(sizeof(LNode));  //创建新结点s->data = x;s->next = L->next;L->next = s;                         //将新结点插入表中，L为头指针scanf("%d", &x);   }return L;}
3）链表的逆置

算法思想：逆置链表初始为空，原表结点从原链表中依次删除，再逐个插入逆置链表的表头（即“头插”到逆置链表中），使它成为逆置链表的新的第一个结点，如此循环，直至原链表为空；

LNode *Inverse(LNode *L)
{LNode *p, *q;p = L->next;     //p指针指向第一个结点L->next = NULL;  //头结点指向NULLwhile (p != NULL){q = p;p = p->next;q->next = L->next;  L->next = q;}return L;

2.2.4、双链表

对双链表中结点的描述：

//定义双链表结点类型
typedef struct DNode{ElemType data;//定义数据域struct DNode *prior, *next;//前驱指针和后继指针
}DNode,*DLinkList;
2.2.4.1、双链表的初始化（带头结点）
#include<stdlib.h>typedef struct DNode {ElemType data;struct DNode* prior, * next;
}DNode, *DLinkList;bool initlist(DLinkList &DL) {DL = (DNode*)malloc(sizeof(DNode));//分配一个结点if (DL == NULL)//内存不足，分配失败return false;DL->prior = NULL;//头结点的prior永远指向NULLDL->next = NULL;//头结点之后还没有结点return true;
}void testDLinkList() {//初始化双链表DLinkList DL;initlist(DL);}
//判断双链表是否为空
bool Empty(DLinkList DL) {if (DL->next == NULL)//判断头结点的next指针是否为空return false;else return true;
}
2.2.4.2、双链表的插入（后插）
//将结点p插到结点s之后
bool InsertNextDNode(DNode *s, DNode *p){if(p == NULL || s == NULL)return false;p->next = s->next;if(s->next != NULL)//s不是最后一个结点（s有后继结点）s->next->prior = p;p->prior = s;s->next = p;
}
2.2.4.3、双链表的删除（后删）和销毁
bool DeleteNextDNode(DNode *p){if(p == NULL) return false;DNode *q = p->next;if(q == NULL)return false;p->next = q->next;if(q->next != NULL)q->next->prior = p;free(q);return true;
}
//销毁一个双链表
bool DestroyDLinkLIst(DLinkList &DL){//循环释放每一个结点while(DL->next !=NULL){DeleteNextDNode(DL);//删除头结点的后继节点free(DL);//释放头结点DL = NULL;//头结点指向空}
}
2.2.4.4、双链表的遍历
1）前向遍历
while(P != NULL){//对结点p做相应处理，eg.打印p = p->prior;
}
2）后向遍历
while(P != NULL){//对结点p做相应处理，eg.打印p = p->next;
}

注意：双链表不可以随机存取，按位查找和按值查找都只能用遍历的方式实现，时间复杂度为O(n)。

2.2.5、循环链表

2.2.5.1、循环单链表

最后一个结点的指针不是指向NULL而是指向头结点

typedef struct LNode{            ElemType data;               struct LNode *next;  
}DNode, *Linklist;/初始化一个循环单链表
bool InitList(LinkList &L){L = (LNode *)malloc(sizeof(LNode)); //分配一个头结点if(L==NULL)             //内存不足，分配失败return false;L->next = L;            //头结点next指针指向头结点return true;
}//判断循环单链表是否为空（终止条件为p或p->next是否等于头指针）
bool Empty(LinkList L){if(L->next == L)return true;    //为空elsereturn false;
}//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L, LNode *p){if(p->next == L)return true;elsereturn false;
}

单链表和循环单链表的比较：

1. 单链表： 从一个结点出发，只能找到该结点后面的各个结点；对链表的操作大多都在头部或尾部；设立头指针，从头结点找到尾部得到时间复杂度为O(n)，即对表尾操作需要O(n)的时间复杂度。
2. 循环单链表： 从表中任一个结点出发，可以找到该表中所有其他结点；设立尾指针，从尾部找到头部的时间复杂度为O(1)，即对表头和表尾操作的时间复杂度都只需要O(1)的时间复杂度。
3. 循环单链表的优点： 从表中任一个结点出发，可以找到该表中所有其他结点；

2.2.5.2、循环双链表

表头结点的前驱结点prior指向表尾结点，表尾结点的后继结点next指向表头结点。

typedef struct DNode{          ElemType data;               struct DNode *prior, *next;  
}DNode, *DLinklist;//初始化空的循环双链表
bool InitDLinkList(DLinklist &L){L = (DNode *) malloc(sizeof(DNode));    //分配一个头结点if(L==NULL)            //内存不足，分配失败return false;  L->prior = L;          //头结点的prior指向头结点L->next = L;           //头结点的next指向头结点
}void testDLinkList(){//初始化循环单链表DLinklist L;InitDLinkList(L);//...
}//判断循环双链表是否为空
bool Empty(DLinklist L){if(L->next == L)return true;elsereturn false;
}//判断结点p是否为循环双链表的表尾结点
bool isTail(DLinklist L, DNode *p){if(p->next == L)return true;elsereturn false;
}
2.2.5.3、循环链表的插入
bool InsertNextDNode(DNode *p, DNode *s){ s->next = p->next;p->next->prior = s;s->prior = p;p->next = s;
2.2.5.4、循环链表的删除
//删除p的后继结点q
p->next = q->next;
q->next->prior = p;
free(q);

2.2.6、静态链表

2.2.6.1、静态链表的定义

用数组的方式来描述线性表的链式存储结构：分配一整片连续的内存空间，各个结点集中安置，包括了数据元素和下一个结点的数组下标（游标）。

#define MaxSize 10        //静态链表的最大长度struct Node{              //静态链表结构类型的定义ElemType data;        //存储数据元素int next;             //下一个元素的数组下标(游标)
};//用数组定义多个连续存放的结点
//相当于typedef struct Node SLinkList[MaxSize]; 重命名struct Node，用SLinkList定义“一个长度为MaxSize的Node型数组;
void testSLinkList(){struct Node a[MaxSize];  //数组a作为静态链表, 每一个数组元素的类型都是struct Node//...
}

或者是

#define MaxSize 10        //静态链表的最大长度typedef struct{           //静态链表结构类型的定义ELemType data;        //存储数据元素int next;             //下一个元素的数组下标
}SLinkList[MaxSize];void testSLinkList(){SLinkList a;
}

2.3、顺序表和链表的比较

逻辑结构存储结构创建销毁增/删查
顺序表线性表顺序存储 优点：支持随机存取，存储密度高 缺点：大片连续空间分配不方便，改变容量不方便静态分配：需要预分配大片连续空间，若空间太小，拓展容量不方便，若太大又浪费内存资源；动态分配：可以改变容量，但是需要移动大量元素，时间代价高对于静态数组，系统会自动回收；对于动态分配，需要手动进行free()插入/删除元素需要将后续元素进行后移/前移，时间复杂度为O(n)，时间开销主要来自移动元素按位查找：O(1)；按值查找：O(n)，若表内元素有序，则可以在O(log2n)时间内找到
链表线性表链式存储 优点：离散的小空间分配方便，改变容量方便 缺点：不可随机存取，存储密度低只需要分配一个头结点或者声明一个头指针利用后删从头结点依次删除后续结点，最后释放头结点插入/删除元素只需要修改指针，时间复杂度为O(n)，时间开销主要来自查找目标元素按位查找：O(n)；按值查找：O(n)
顺序表链表
弹性（可扩容）不嘻嘻嘻嘻
增/删不嘻嘻嘻嘻
查嘻嘻不嘻嘻

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.mzph.cn/news/870125.shtml

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

昇思25天学习打卡营第17天|基于MobileNetv2的垃圾分类

昇思25天学习打卡营第17天|基于MobileNetv2的垃圾分类

今天学习的内容是利用视觉图像技术&#xff0c;来实现垃圾分类代码开发的方法。通过读取本地图像数据作为输入&#xff0c;对图像中的垃圾物体进行检测&#xff0c;并且将检测结果图片保存到文件中。 本章节主要包括8部分内容&#xff1a; 1、实验目的 1、了解熟悉垃圾分类应用…
阅读更多...
气膜滑雪馆如何实现恒温—轻空间

气膜滑雪馆如何实现恒温—轻空间

随着滑雪运动的普及和爱好者数量的增加&#xff0c;滑雪馆的建设需求也不断提升。然而&#xff0c;如何在滑雪馆内保持恒温&#xff0c;提供一个稳定舒适的滑雪环境&#xff0c;成为了建设过程中需要解决的关键问题。气膜滑雪馆凭借其独特的结构和技术优势&#xff0c;成功地实…
阅读更多...
MQTT是什么，物联网

MQTT是什么，物联网

写文思路&#xff1a; 以下从几个方面介绍MQTT&#xff0c;包括&#xff1a;MQTT是什么&#xff0c;MQTT和webSocket的结合&#xff0c;以及使用场景&#xff0c; 一、MQTT是什么 MQTT&#xff08;Message Queuing Telemetry Transport&#xff09;是一种轻量级的发布/订阅消息…
阅读更多...
如何分辨AI生成的内容？AI生成内容检测工具对比实验

如何分辨AI生成的内容？AI生成内容检测工具对比实验

检测人工智能生成的文本对各个领域的组织都提出了挑战&#xff0c;包括学术界和新闻界等。生成式AI与大语言模型根据短描述来进行内容生成的能力&#xff0c;产生了一个问题&#xff1a;这篇文章/内容/作业/图像到底是由人类创作的&#xff0c;还是AI创作的&#xff1f;虽然 LL…
阅读更多...
LabVIEW实现LED显示屏视觉检测

LabVIEW实现LED显示屏视觉检测

为了满足LED显示屏在生产过程中的严格质量检测需求&#xff0c;引入自动化检测系统是十分必要的。传统人工检测方式存在检测强度高、效率低、准确性差等问题&#xff0c;自动化检测系统则能显著提高检测效率和准确性。视觉检测系统的构建主要包含硬件和软件两个部分。 视觉系统…
阅读更多...
昇思25天学习打卡营第23天 | Pix2Pix实现图像转换

昇思25天学习打卡营第23天 | Pix2Pix实现图像转换

内容介绍&#xff1a; Pix2Pix是基于条件生成对抗网络&#xff08;cGAN, Condition Generative Adversarial Networks &#xff09;实现的一种深度学习图像转换模型&#xff0c;该模型是由Phillip Isola等作者在2017年CVPR上提出的&#xff0c;可以实现语义/标签到真实图片、灰…
阅读更多...
Python酷库之旅-第三方库Pandas(016)

Python酷库之旅-第三方库Pandas(016)

目录 一、用法精讲 39、pandas.DataFrame.to_stata函数 39-1、语法 39-2、参数 39-3、功能 39-4、返回值 39-5、说明 39-6、用法 39-6-1、数据准备 39-6-2、代码示例 39-6-3、结果输出 40、pandas.read_stata函数 40-1、语法 40-2、参数 40-3、功能 40-4、返回…
阅读更多...
nssm的下载和使用

nssm的下载和使用

nssm&#xff08;Non-Sucking Service Manager&#xff09;是一个用于在Windows系统上管理服务的工具。它允许你将.exe文件和.bat文件转换为Windows服务&#xff0c;并提供了一些功能来管理这些服务。 下载和安装 首先&#xff0c;你需要从nssm官方网站&#xff08;https://n…
阅读更多...
【ARM】MDK安装ARM_compiler5无法打开安装程序

【ARM】MDK安装ARM_compiler5无法打开安装程序

【更多软件使用问题请点击亿道电子官方网站】 1、 文档目标 在客户安装了最新版本的MDK5.37及后续更新版本&#xff0c;但原工程使用ARM_Compiler_5.06进行编译和调试&#xff0c;需安装ARM_Compiler_5.06的编译器版本&#xff0c;但在解压缩的过程中后续无法打开ARM_Compiler…
阅读更多...
解释 C 语言中的递归函数

解释 C 语言中的递归函数

&#x1f345;关注博主&#x1f397;️ 带你畅游技术世界&#xff0c;不错过每一次成长机会&#xff01; &#x1f4d9;C 语言百万年薪修炼课程 通俗易懂&#xff0c;深入浅出&#xff0c;匠心打磨&#xff0c;死磕细节&#xff0c;6年迭代&#xff0c;看过的人都说好。 文章目…
阅读更多...
操作系统——分区存储管理

操作系统——分区存储管理

阅读更多...
AcWing 3381：手机键盘

AcWing 3381：手机键盘

【题目来源】https://www.acwing.com/problem/content/3384/【题目描述】 请你计算按照手机键盘&#xff08;9键输入法&#xff09;输入字母的方式&#xff0c;键入给定字符串&#xff08;由小写字母构成&#xff09;所花费的时间。 具体键入规则和花费时间如下描述&#xff1a…
阅读更多...
确保智慧校园安全，充分利用操作日志功能

确保智慧校园安全，充分利用操作日志功能

智慧校园基础平台系统的操作日志功能是确保整个平台运行透明、安全及可追溯的核心组件。它自动且详尽地记录下系统内的每一次关键操作细节&#xff0c;涵盖操作的具体时间、执行操作的用户账号、涉及的数据对象&#xff08;例如学生信息更新、课程调度变动等&#xff09;、操作…
阅读更多...
十、函数栈帧的创建和销毁

十、函数栈帧的创建和销毁

前期学习的时候我们可能会有很多困惑&#xff0c;如&#xff1a; &#xff08;1&#xff09;局部变量的值是随机值&#xff1f; &#xff08;2&#xff09;为什么局部变量的值是随机值&#xff1f; &#xff08;3&#xff09;函数是怎么传参的&#xff1f;传参的顺序是怎样的…
阅读更多...
Burp Suite Professional 2024.6 for macOS x64 ARM64 - 领先的 Web 渗透测试软件

Burp Suite Professional 2024.6 for macOS x64 ARM64 - 领先的 Web 渗透测试软件

Burp Suite Professional 2024.6 for macOS x64 & ARM64 - 领先的 Web 渗透测试软件 世界排名第一的 Web 渗透测试工具包 请访问原文链接&#xff1a;https://sysin.org/blog/burp-suite-pro-mac/&#xff0c;查看最新版。原创作品&#xff0c;转载请保留出处。 作者主页…
阅读更多...
万字学习——DCU编程实战补充

万字学习——DCU编程实战补充

参考资料 2.1 详解DCU架构 DCU 开发与使用文档 (hpccube.com) DCU架构是什么样的 计算单元阵列&#xff0c;如图CU0、CU1等缓存系统&#xff08;L1一级缓存&#xff0c;L2二级缓存&#xff09;全局内存(global memory)CPU和DCU数据通路&#xff08;DMA&#xff09; 我的理解…
阅读更多...
通过图像高频信息保留图像细节，能保留多少细节-Comfyui

通过图像高频信息保留图像细节，能保留多少细节-Comfyui

&#x1f9e8;前情提要 如果还不了解comfyui中图像高频信息保留细节的内容&#xff0c;可以参考上一篇文章&#xff1a; 图像中高频信息、低频信息与ComfyUI中图像细节保留的简单研究-CSDN博客 这次主要是简单测试下保留图像细节&#xff0c;能保留到什么程度&#xff1b; …
阅读更多...
江波龙 128G msata量产

江波龙 128G msata量产

一小主机不断重启&#xff0c;用DG格式化 无法完成&#xff0c;应该是有坏块了 找一个usb转msata转换板 查了一下是2246en aa主控 颗粒应该是三星的 缓存是现代的 找到量产工具sm22XMPToolP0219B 打开量产工具 用镊子先短接一下jp1 插入usb口&#xff0c;再拿走镊子 scan …
阅读更多...
每天五分钟计算机视觉：目标检测算法之R-CNN

每天五分钟计算机视觉：目标检测算法之R-CNN

本文重点 在计算机视觉领域，目标检测一直是一个核心问题，旨在识别图像中的物体并定位其位置。随着深度学习技术的发展，基于卷积神经网络（CNN）的目标检测算法取得了显著的进步。其中，R-CNN（Regions with CNN features）是一种开创性的目标检测框架，为后续的研究提供了重…
阅读更多...
微积分-导数6（隐式导数）

微积分-导数6（隐式导数）

隐式导数 前面我们学了如何求这些方程的导数&#xff1a; y x 3 1 or y x sin ⁡ x y \sqrt{x^31} \quad \text{or} \quad y x\sin x yx31 ​oryxsinx 但是如果是下面的方程&#xff0c;又该如何求导呢&#xff1f; x 3 y 3 6 x y x^3 y^3 6xy x3y36xy 这个方程的图…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023