数据结构（一）—— *线性表

已于 2022-06-13 21:32:26 修改
阅读量87 收藏 1
点赞数
分类专栏： 数据结构 文章标签： 数据结构 算法 链表
于 2022-06-13 21:31:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46064106/article/details/125267759
版权

文章目录

第1章 线性表

定义

在这里插入图片描述

基本操作

InitList(&L)：初始化表。构造一个空的线性表，分配内存空间。
DestroyList（&L）：销毁操作。销毁线性表，并释放线性表L所占用的内存空间。
ListInsert(&L,i,e)：插入操作。在表L中的第i个位置上插入指定元素e。
ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。
GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。
LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素，并返回其位序。
其他常用操作：
Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数。
PrintList(L)：输出操作。按前后顺序输出线性表L的所有元素值。
Empty(L)：判空操作。若L为空表，则返回true,否则返回false。

Tips：什么时候要传入引用&——对参数的修改结果需要“带回来”。

实例——归并有序线性表

/*题目背景：已知线性表LA和LB中的数据元素按值非递减有序排列，归并LA和LB成为LC，并且LC中的数据元素仍按值非递减有序排列
LA = [3,5,8,10]		LB = [2,6,8,9,11,15]
则 LC = [2,3,5,6,8,8,9,10,11,15]

算法思想：设LC为空表，然后将LA和LB中的元素逐个插入到LC中，为将LC中元素按值非递减有序排列，可设两个指针i和j分别指向LA和LB中某个元素，若设i当前指向的元素为a,j当前所指元素为b，则当前插入到LC中的元素c为小的元素值。
*/
void MergeList(List LA,List LB,List &LC) {
    InitList(&LC);
    int i,j,k = 0;
    i = j = 1;
    Length_A = LA.length;
    Length_B = LB.length;
    while((i < = Length_A) && (j <= Length_B)) {	//LA和LB都非空
		GetElem(LA,i,a);
        GetElem(LB,j,b);
        if(a <= b) {
            ListInsert(&LC,++k,a);
            ++i;
        }
        else{
            ListInsert(&LC,++k,b);
            ++j;
        }
    }
    
    while(i <= Length_A) {		//插入LA的剩余元素
        GetElem(LA,i++,a);
        ListInsert(&LC,++k,a);
    }
    while(j <= Length_B) {		//插入LB的剩余元素
        GetElem(LB,j++,b);
        ListInsert(&LC,++k,b);
    }
}

*顺序表

定义

在这里插入图片描述

特点

  • 随机访问。可以在O(1)时间内找到第i个元素。
  • 存储密度高。每个节点只存储数据元素。
  • 拓展容量不方便。
  • 插入、删除数据元素不方便。

实现方式

静态分配
#define MaxSize 10
typedef struct {
    ElemType data[Maxsize];		//用静态的“数组”存放数据元素
    int length;					//顺序表当前长度
}SqList;

Q：“数组”存满了怎么办？
A：因为存储空间是静态的，顺序表的表长刚开始确定后就无法更改。
Q：如果一开始就声明很大的内存空间呢？
A：浪费内存资源！

动态分配
#define InitSize 10		//顺序表初始长度
typedef struct {
    ElemType *data;		//指示动态分配数组的指针
    int　MaxSize;		//顺序表最大容量
    int length;			//顺序表当前长度
}SqList;

Key：动态申请和释放内存空间——malloc()、free()
L.data = (ElemType* )malloc(sizeof(ElemType) * InitSize);
malloc()返回的存储空间起始地址要转换为与数据元素的数据类型相对应的指针。

基本操作——插入

ListInsert(&L,i,e)：插入操作。在表L的位序 i 处插入指定元素e。

#define MaxSize 10
typedef struct {
    ElemType 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)		
    //判断存储空间是否已满，另一种方法是利用realloc()增加分配地址空间
        return false;
    for(int j = L.length;j >= i; j--)
    	L.data[j] = L.data[j - 1];
	L.data[i - 1] = e;
    L.length ++;
    return true;
}

平均时间复杂度O(n)
###　基本操作——删除
ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

bool ListDelete(SqList &L,int i,int &e) {
    if(i < 1 || i > L.length + 1)	//判断i的范围是否有效
        return false;
    e = L.data[i - 1];		//被删除的元素赋值给e
    for(int j = i;j < L.length; j++)
    	L.data[j - 1] = L.data[j];
    L.length --;
    return true;
}

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

ElemType GetElem(SqList L,int i) {
    return L.data[i - 1];
}

时间复杂度O(1)
###　基本操作——按值查找
LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素，并返回其位序。

int LocateElem(SqList L,int e) {
    for(int i = 0;i < L.length; i++)
        if(L.data[i] == e)	
            return i + 1;
    return 0;
}

平均时间复杂度O(n)

*单链表

定义

在这里插入图片描述
强调单链表——LinkList
强调结点—— LNode *

基本操作——初始化

typedef struct LNode{
    ElemType data;			//每个结点存放的数据元素
    struct LNode *next;		//指针指向下一个结点
}LNode,*LinkList;


//初始化不带头的单链表
bool InitList(LinkList &L) {
    L　= NULL;	//空表，暂时没有任何结点（防止脏数据）
    return true;
}


//初始化带头结点的单链表
bool InitList(LinkList &L) {
    L　= (LNode*)malloc(sizeof(LNode));	//分配一个头结点 ！不存储数据！
    if(L == NULL)		//分配失败
        return false;
    L->next = NULL;		//头结点后暂时没有其他结点
    return true;
}


int main(){
    LinkList L;		//声明一个指向单链表的指针
    InitList(L);
    ……
}

基本操作—— 插入删除

ListInsert(&L,i,e)：插入操作。在表L的位序 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个结点（不存储数据）
    while(p != NULL &&　j <　i - 1) {		//循环找到第 i-1 个结点
        p = p->next;
        j++
    }
    if(p == NULL)	//i值不合法
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}


//不带头结点
bool ListInsert(LinkList &L,int i,ElemType e) {
    if(i < 1)
        return false;
    if(i == 1){ 		//插入第一个结点的操作与其他结点操作不同
    	LNode *s = (LNode*) malloc(sizeof(LNode));
        s->data = e;
        s->next = L;
        L = s;
        return true;
    }
    
    LNode *p;		//指针p指向当前扫描到的结点
    //int j = 0
    int j = 1;		//当前p指向的是第几个结点（p指向第一个结点！！！）
    p = L;			
    while(p != NULL &&　j <　i - 1) {		//循环找到第 i-1 个结点
        p = p->next;
        j++
    }
    if(p == NULL)	//i值不合法
        return false;
    LNode *s = (LNode *)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}

在这里插入图片描述
在这里插入图片描述

/* 指定结点的后插操作 */
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->next = p->next;
    p->next = s;
    return true;
}

在这里插入图片描述

/* 指定结点的前插操作 */
bool InsertPriorNode(LNode *p,ElemType 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中元素复制到s中
    p->data = e;			//p中的元素覆盖为e
    return true;
}

在这里插入图片描述
ListDelete(&L,i,&e)：删除操作。删除表L中第i个位置的元素，并用e返回删除元素的值。

/* 按位删除 */ 

//带头结点
bool ListDelete(LinkList &L, int i, ElemType &e) {
    if(i < 1)
        return false;
    LNode *p;		//指针p指向当前扫描到的结点
    int j = 0;		//当前p指向的是第几个结点
    p = L;			//L指向头结点，头结点是第0个结点（不存储数据）
    while(p != NULL &&　j <　i - 1) {		//循环找到第 i-1 个结点
        p = p->next;
        j++
    }
    if(p == NULL)	//i值不合法
        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;			
}

在这里插入图片描述

/* 指定结点的删除操作 */
bool DeleteNode(LNode *p) {
    if(p == NULL)
        return false;
    LNode *q = p->next;		//q指向p的后继结点
    /*如果此时p已经是最后一个结点，则q为NULL；
    删除结点的方式只能是从表头开始依次寻找p的前驱；
    时间复杂度为O（n）*/
    p->data = q->data;		//和后继结点交换数据域
    p->next = q->next;		//将q结点从链中断开
    free(q);				//释放后继结点存储空间
    return true;
}

在这里插入图片描述
单链表的局限性：无法逆向检索

基本操作——查找

GetElem(L,i)：按位查找操作。获取表L中第i个位置的元素的值。
LocateElem(L,e)：按值查找操作。在表L中查找具有给定关键字值的元素，并返回其位序。

/* 按位查找 */

//带头结点
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;
}

在这里插入图片描述

/* 按值查找 */

//带头结点
LNode* LocateElem(LinkList L,ElemType e) {
    LNode *p = L->next;		//指针p指向当前扫描到的结点(第一个结点)
    while(p != NULL &&　p->data != e) {		
        p = p->next;
    }
    return p;
}

基本操作——计算表的长度

Length(L)：求表长。返回线性表L的长度，即L中数据元素的个数。

int Length(LinkList L) {
    int len = 0;
    LNode *p = L;
    while(p->next != NULL){
        p = p->next;
        len++;
    }
    return len;
}

基本操作——单链表的建立

/* 尾插法建立单链表 */
//在第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个结点（不存储数据）
    while(p != NULL &&　j < i - 1) {		//循环找到第 i - 1个结点
        p = p->next;
        j++
    }
    if(p == NULL)		//i值不合法
        return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = e;
    s->next = p->next;
    p->next = s;
    return true;
}


/* 头插法建立单链表 */ 						//——链表逆置（头插法）
//后插操作：在头结点后插入新的数据元素e
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->next = p->next;
    p->next = s;
    return true;
}

Tips ：头插法、尾插法核心就是初始化操作、指定结点的后插操作。
头插法的重要应用：链表的逆置

双链表

基本操作——初始化

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 = NULL;
    L->next = NULL;
    return true;
}

基本操作——插入

//在p结点后插入s结点
bool InsertNextDode(DNode *p,DNode *s) {
    if(p == NULL || s == NULL)
        return false;
    s-next = p->next;
    if(p->next != NULL)		//如果p有后继结点
    	p->next->proir = s;		
    s->prior = p;
    p->next = s;
    return true;
}

在这里插入图片描述

基本操作——删除和销毁

//删除p结点的后继结点
bool DeleteNextDode(DNode *p) {
    if(p == NULL)
        return false;
    DNode *q = p->next;	
    if(q == NULL)		//如果p没有后继结点
    	return false;	
    p->next = q->next;
    if(q->next != NULL)		//q结点不是最后一个结点
        q->next->prior = p;
    free(q);
    return true;
}


/* 销毁双链表 */
void DestroyList(DLinkList &L) {
    while(L->next != NULL)	//每次删除头结点后的数据
        DeleteNextDNode(L);
    free(L);	//释放头结点
    L = NULL;
}

循环链表

表尾结点的next指针指向头结点

//循环单链表  ！(循环双链表类似) ！
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 = L;	//头结点next指向头结点
    return true;	
}


//判断循环单链表是否为空
bool Empty(LinkList L) {
	if(L->next == L)
        return true;
    return false;
}


//判断结点p是否为循环单链表的表尾结点
bool isTail(LinkList L,LNode* p){
    if(p->next == L)
        return true;
    return false;
}

静态链表

用数组的方式实现。优点：增删操作不需要大量移动元素； 缺点：不能随机存取，只能从头结点开始依次往后查找，容量固定不可变。
在这里插入图片描述
在这里插入图片描述
插入位序为i的结点：
① 找到一个空的结点，存入数据元素（eg:初始化为-2）
② 从头结点出发找到位序为 i-1的结点
③ 修改新结点的 next
④修改 i-1 号结点的 next

删除某个结点：
①从头结点出发找到前驱结点
②修改前驱结点的游标
③被删除结点 next 设为 -2

小结

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

H.???
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单链表的操作
CairBin的博客
09-12 454
单链表代码定义 typedef struct LinkNode { int data; //data存放结点的数据域（以int类型为例） struct LinkNode *next; //结点的指针域 }LinkNode, LinkList; 单链表的操作 初始化单链表 bool initList(LinkList* &L) //L类型为引用类型的指针 { L = new LinkNode; //为L分配一个动态内存 if(!L) return false;
单链表的基本操作
weixin_64084604的博客
11-20 2904
单链表基本操作
含头节点单链表(初始化、插入、删除、查询)
qq_42174306的博客
03-29 3467
一、单链表的创建 结点的定义 typedef struct LNode{ int data; struct LNode *next; }LNode, *LinkList; //声明一个节点可以使用 LNode *node; LinkList L; 初始化一个单链表 //初始化一个单链表(包含头节点) bool InitList(LinkList &L) { L = (LNode *) malloc(sizeof(LNode)); ...
【数据结构】单链表 创建 插入 删除 查找 完整代码
最新发布
m0_61628700的博客
06-24 878
单链表 定义 建立 头插法和尾插法 插入 删除 按序号查找 按值查找
数据结构-链表
qq_43817065的博客
03-11 175
/* 链表与顺序表的区别？ 链表--单链表还是双链表？ 链表是否带头结点？ 常规操作： 注意各个操作都有带头结点和不带头结点的两个类型 InitList（LinkList &L）初始化一个单链表-- ListInsert(LinkList &L,int i,ElemType e)在链表L的第i个位置插入元素e； InsertNextNode(LNode*p,ElemType e)在p结点后面插入元素e InsertPirorNode(LNode*p,ElemType e)在p结点前面插入.
数据结构第二章（单链表部分）学习笔记
qq_62175345的博客
04-05 4063
线性表---单链表部分 1、知识承接 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式来表示。但效率低插入和删除操作需要移动大量的元素。临时扩大存储空间有困难，存储分配只能预先进行必须占用地址连续的内存空间 . 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动大量的元素，只需要修改指针，但也会失去顺序表可以随机存取的优点。 单链表 链表： 通过一组任意的
C语言单链表实现初始化、创建、增、删、查等基本操作（详细）
莫浅子的博客
08-31 2万+
一、单链表的定义及初始化 1、定义 2、初始化 1)不带头结点的单链表 2)带头节的单链表 二、单链表插入和删除 1)插入 1、按位序插入（带头结点） 2、按位插入（不带头结点） 3、指定结点的后插操作 4、指定结点的前插操作 2）删除 1、按位序删除（带头结点） 2、指定结点删除 3、指定最后结点的删除 三、查找 1）按位查找 2）按值查找 四、建立 1）头插法 2）尾插法 六、补充求单链表长度 ...
数据结构--循环单链表
做个假设——坚持两年，我会怎么样
05-03 792
循环链表的存储结构和单链表是相同的。不同的地方是循环单链表的最后一个指针指向了头结点，不是单链表的“NULL”,这样有表尾很容易找到表头，但是由表头到表尾如果链表很长，则会很费时。因而，循环单链表设置尾指针而不是头指针。 存储结构 typedef struct LNode { int data; struct LNode *next; }LNode,*LinkList;基本操作如下
转——链表中LinkList L与LinkList *L的区别
weixin_30457551的博客
12-09 5560
typedef struct Node{ int elem; struct node * next; }node,*LinkList; 　　 对于LinkList L: L是指向定义的node结构体的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem; 对于Link...
数据结构（2）线性表->链式表
佚失的诗篇
11-03 400
整理数据结构学习笔记 基于C++ 一、线性表 见前篇文章：线性表-&gt;顺序表 二、线性表的链式表示和实现 1、定义&amp;分类 线性表的链式表示，是利用一组任意的存储单元依次存储数据元素（这些存储单元可以是连续的，也可以是不连续的），称这种线性表为“链式表” 从实现角度看，链表可分为动态链表和静态链表 从链接方式的角度看，链表可分为单链表、循环链表和双链表。 2、单链表 结点...
线性表初始化int InitList(LinkList *L)和int InitList（LinkList L）问题
热门推荐
zachaxy的专栏
10-25 2万+
在数据结构线性表一章，看到
循环链表的算法实现
m0_46376834的博客
04-11 399
循环链表 循环链表的示意图: 1.循环链表结构体的定义 typedef struct _LinkNode{ int data; //结点的数据域 struct _LinkNode *next;//结点的指针域 }LinkNode,LinkList;//LinkList为指针结构体LNode的指针类型 2.循环链表的初始化 bool InitList(LinkList *&L)//构建一个空的链表L { L=new LinkNode;//生成新节点作为头结点 if(!L)return f
单链表及基本操作与实现
金啊豆嘞的博客
09-09 372
单链表的基本操作及基本实现如下： #include "stdio.h" #include "stdlib.h" typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode *next; }LNode, *LinkList; LinkList InitList(LinkList &L);...
单链表的初始化代码
一个随时准备弃坑的博客
03-24 3210
①无头结点 //初始化一个空的单链表 bool InitList(LinkList &L) { L=NULL; //空表，暂时还没有任何结点（防止脏数据遗留） return true; } ②有头节点 //初始化一个空的单链表（带头结点） bool InitList(LinkList &L) { L=（LNode*)malloc(sizeof(LNode...
数据结构 单链表
weixin_34235135的博客
03-13 138
做一个豁达而努力的自己。单链表的定义:单链表连式存储的数据结构，是用任意的存储位置存储数据。线性表的单链表存储结构：typedef struct Node{ ElemType data; struct Node *next;}Node, *LinkList;无论链表是否为空，头指针均不为空，头指针是链表的必要元素。生成头指针：LinkList head...
数据结构—单链表的实现（c语言版）
南方硅人的博客
06-22 920
1、线性表的单链表表示 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起来数据元素之间的逻辑关系，因此插入和删除操作不需要移动元素，而只需要修改指针，但也会失去顺序表可随机存取的优点。 2、单链表的基本操作 函数 说明 void InitList(LinkList &L); //初始化顺序表 int Length(LinkList &L); //返回当前长度； bool Empty(LinkList &am
大一新生必看，自学必看，里昂详解数据结构之链表
iiLeon的博客
08-23 493
数据结构之链表 核心算法思想 1． 链表建立操作的基本步骤：链表是一个动态的结构，它不需要分配空间，因此建立链表的过程是一个结点“逐个插入” 的过程。先建立一个只含头结点的空单链表，然后依次生成新结点，再不断地将其插入到链表的头部或尾部，分别称其为“头插法”和“尾插法”。 2． 链表查找操作的基本步骤：因链表是一种"顺序存取"的结构，则要在带头结点的链表中查找到第 i个元素，必须从头结点开始沿着后继指针依次"点数"，直到点到第 i 个结点为止,如果查找成功，则用e返回第i个元素值。头结点可看成是第0个结点。
数据结构实验实习报告——基于线性表的图书信息管理
线性表是一种基础且重要的数据结构，它由n（n>=0）个相同类型元素构成的有限序列。在这个实验中，学生需要掌握线性表的两种主要存储方式：顺序存储和链式存储。 1. **线性表的顺序存储**：在顺序存储中，元素在内存...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值