数据结构学习日记二：线性结构

最新推荐文章于 2024-05-22 10:59:33 发布
最新推荐文章于 2024-05-22 10:59:33 发布
阅读量38 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_63494746/article/details/132135531
版权

二、线性表

1、线性表的顺序存储实现

#define MAXSIZE 10

typedef int ElementType;
typedef struct LNode* List;

struct LNode{
    ElementType Data[MAXSIZE];
    int Last;//最后一位数据的下标索引
};

//初始化
List MakeEmpty(){
    List PtrL;
    PtrL = (List)malloc(sizeof(struct LNode));
    PtrL->Last = -1;
    return PtrL;
}

//查找
int Find(ElementType x, List PtrL){
    int i = 0;
    while(i <= PtrL->Last && PtrL->Data[i] != x)
        i++;
    if(i > PtrL->Last) return -1;	//没有找到返回-1
    else return i;	//找到返回下标
}

//插入(这里的i是从1开始的)(实际是Data[i-1]插入x)
void Insert(ElementType x, int i, List PtrL){
    int j;
    if(PtrL->Last == MAXSIZE-1){//表空间满了，无法插入
        printf("表满");
        return;
    }
    if(i < 1 || i > PtrL->Last+2){
        printf("位置不合法");
        return;
    }
    for(j = PtrL->Last; j >= i-1; j--)//原数组的a[i-1]..a[last]后移1位
        PtrL->Data[j+1] = PtrL->Data[j];
    PtrL->Data[i-1] = x;	//插入x
    PtrL->Last++;			//更新长度
    return;
}

//删除(i从1开始)(想要删除的元素，可以在此基础上改)
void Delete(int i, List PtrL){
    int j;
    if(i < 1 || PtrL->Last+1){
        printf("删除位置非法");
        return;
    }
    for(j = i; j <= PtrL->Last; j++)//a[i]..a[last]前移
        PtrL->Data[j-1] = PtrL->Data[j];
    PtrL->Last--;	//更新长度
    return;
}

2、线性表的链式存储实现

typedef int ElementType;
typedef struct LNode* List;

struct LNode{
    ElementType Data;
    List Next;
};

//求表长
int Length(List PtrL){
    List p = PtrL;
    int j = 0;
    while(p){
        p = p->Next;
        j++;
    }
    return j;
}

//按序号查找
List FindKth(int k, List PtrL){
    List p = PtrL;
    int i = 1;
    while(p != NULL && i < k){
        p = p -> Next;
        i++;
    }
    if(i == k) return p;//找到，返回结点指针
    else return NULL;	//否则返回空
}
//按值查找
List Find(ElementType x, List PtrL){
    List p = PtrL;
    while(p != NULL && p->Data != x)
        p = p->Next;
    return p;
}

//插入
List Insert(ElementType x, int i, List PtrL){
    List p, s;
    if(i == 1){	//新结点在表头插入
        s = (List)malloc(sizeof(struct LNode));
        s->Data = x;
        s->Next = PtrL;
        return s;
    }
    p = FindKth(i-1, PtrL);	//查找第i-1个结点
    if(p == NULL){	//第i-1个结点不存在，不能插入
        printf("插入位置错误");
        return NULL;
    } else{
        s = (List)malloc(sizeof(struct LNode));
        s->Data = x;
        s->Next = p->Next;
        p->Next = s;
        return PtrL;
    }
}

//删除
List Delete(int i, List PtrL){
    List p, s;
    if(i == 1){	//删除首结点
        s = PtrL;
        if(PtrL ！= NULL) PtrL = PtrL->Next;//修改指向
        else return NULL;
        free(s);	//清空首结点的空间
        return PtrL;
    }
    p = FindKth(i-1, PtrL);	//查找i-1结点
    if(p == NULL){
        printf("结点不存在");
        return NULL;
    } else if(p->Next == NULL){
        printf("想要删除的结点不存在");
        return NULL;
    } else {
        s = p->Next;	//s指向i结点
        p=Next = s->Next;	//从链表中摘除
        free(s);	//释放被删除结点
        return PtrL;
    }
}

3、广义表结构

引入：

假设有个二元多项式：P(x,y) = 9x12y2 + 4x12 + 15x8y3 - x8y + 3x2

然后可以看成以x为变量的一元多项式：

​ P(x,y) = (9y2 + 4)x12 + (15y3 - y)x8 + 3x2

接着就可以统一成图中的结点结构，在普通线性表的基础上，用 tag 区分是常数系数，还是多项式。然后 union 把这两种统一起来。

结构图：

广义表结点结构

typedef int ElementType;
typedef struct GNode* GList;
struct GNode{
    int Tag;	//标志：0表示结点是单元素，1表示结点是广义表
    union {		//联合体，单元素Data 和子表指针SubList 共用空间
        ElementType Data;
        GList SubList;
    }URegion;
    GList Next;	//指向后继节点
}

4、多重链表

链表中的结点可能同时隶属多个链。

4.1 稀疏矩阵（十字链表）

只存储矩阵中的非0项：结点数据包含（row, col, Value)

同时结点有两个指针：行指针Right, 列指针 Down。
稀疏矩阵(十字链表)

蓝色框里的是稀疏矩阵入口，记录的数据是行数、列数、非零项个数。

然后总共有两种结点，一种Head头结点，一种Term存数据的，都能down和Right。

两种结点很像，所以可以使用union来设计。

  • 用一个标志 tag 来区分头结点和数据结点；
  • 头结点的标识值为”Head“，非0元素结点的标识值为“Term”。

稀疏矩阵结点结构图

三、栈

1、栈的顺序存储实现

#define MAXSIZE 100
typedef int ElementType;
typedef struct SNode* Stack;

struct SNode{
    ElementType Data[MAXSIZE];
    int Top;
};

//入栈
void Push(Stack PtrS, ElementType item){
    if(PtrS->Top == MAXSIZE-1){
        printf("栈满"); return;
    } else{
        PtrS->Data[++(PtrS->Top)] = item;
        return;
    }
}

//出栈
ElementType Pop(Stack PtrS){
    if(PtrS->Top == -1){
        printf("栈空");
        return ERROR;	//ERROR是ElementType的错误值
    } else
        return (PtrS->Data[(PtrS->Top)--]);
}

2、栈的链式存储实现

typedef int ElementType;
typedef struct SNode* Stack;
struct SNode{
    ElementType Data;
    struct SNode* Next;
};

//初始化头结点
Stack CreateStack(){
    Stack S;
    S = (Stack)malloc(sizeof(struct SNode));
    S->Next = NULL;
    return S;
}

//判断是否为空
int IsEmpty(Stack S){
    return (S->Next == NULL);
}

//入栈(头插法)
void Push(ElementType item, Stack S){
    struct SNode* newNode;
    newNode = (struct SNode*)malloc(sizeof(struct SNode));
    newNode->Data = item;
    newNode->Next = S->Next;
    S->Next = newNode;
}

//出栈
ElementType Pop(Stack S){
    struct SNode* FirstNode;
    ElementType TopElem;
    if(IsEmpty(S)){
        printf("栈空");
        return NULL;
    } else{
        FirstNode = S->Next;
        S->Next = FirstNode->Next;
        TopElem = FirstNode->Data;
        free(FirstNode);
        return TopElem;
    }
}

3、栈的应用：表达式求值

3.1 中缀表达式转换成后缀表达式

a * ( b + c ) / d 转换成后缀表达式为： a b c + * d /

  • 碰到数字就输出
  • 碰到运算符就比较优先级，高压栈，低出栈。如果是右括号，一直出栈，直到左括号出栈。

3.2 求后缀表达式

直接从左到右扫描，遇到运算符，弹两个数出来，结果重新压栈。

3.3 栈的其他应用

  • 函数调用及递归实现
  • 深度优先搜索
  • 回溯算法
  • 。。。

四、队列

1、队列的顺序存储实现

循环队列。空一格。入队处理rear，出队修改front。

#define MAXSIZE 100
typedef int ElementType;
struct QNode{
    ElementType Data[MAXSIZE];
    int rear;
    int front;
};
typedef struct QNode* Queue;

//入队
void AddQ(Queue PtrQ, ElementType item){
    if((PtrQ->rear+1) % MAXSIZE == PtrQ->front){
        printf("队列满");
        return;
    }
    PtrQ->rear = (PtrQ->rear+1) % MAXSIZE;
    PtrQ->Data[PtrQ->rear] = item;
}

//出队
ElementType DeleteQ(Queue PtrQ){
    if(PtrQ->front == PtrQ->rear){
        printf("队列空");
        return ERROR;
    } else {
        PtrQ->front = (PtrQ->front+1) % MAXSIZE;
        return PtrQ->Data[PtrQ->front];
    }
}

2、队列的链式存储实现

typedef int ElementType;

struct Node{	//链表
    ElementType Data;
    struct Node* Next;
};
struct QNode{	//队列结构
    struct Node* rear;//队尾结点
    struct Node* front;//队头结点
};
typedef struct QNode* Queue;

//不带头结点的出队
ElementType DeleteQ(Queue PtrQ){
    struct Node* FrontNode;
    ElementType FrontElem;
    
    if(PtrQ->front == NULL){
        printf("队列为空"); return ERROR;
    }
    FrontNode = PtrQ->front;
    if(PtrQ->front == PtrQ->rear)//如果只有一个元素
        PtrQ->front = PtrQ->rear = NULL;//删除队列
    else
        PtrQ->front = PtrQ->front->Next;
    FrontElem = FrontNode->Data;
    free(FrontNode);//释放结点
    return FrontElem;
}

//入队
void AddQ(ElementType elem, Queue PtrQ){
    struct Node* newNode;//初始化新结点
    newNode->Data = elem;
    newNode->Next = NULL;
    
    if(PtrQ->front == NULL)	//队列还是空的，新增第一个结点
        PtrQ->front = PtrQ->rear = newNode;
    else
        PtrQ->rear->next = newNode;
}
明々天
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
数据结构学习日记（一）
weixin_46600208的博客
02-13 372
一， 1，数据元素是数据的基本单位，一个数据元素由若干数据项组成 2，数据结构：相互之间有关系的数据元素集合 ， 数据对象：相同性质的数据数据元素的集合 二， 1，逻辑结构 集合：各元素同属一个集合，无其他关系 线性结构：一对一关系，除了第一和最后，唯一前驱，唯一后继 树形结构：一对多关系 图状结构：多对多关系 2,物理结构 顺序存储：逻辑上相邻的元素存储在物理位置上也相邻的存储单元中。 链式存储：可以不相邻，用指针表示下一个数据元素的存储地址。 索引存储：建立附加的索引...
数据结构学习日记（五）
weixin_46600208的博客
02-17 125
一，静态链表 1）概念对比：单链表：包含数据元素和指向下一个节点的指针 静态链表：包含数据元素和下一个节点的数组下标（游标充当指针），用数组的方式实现链表，不能随机存取，只能从头结点开始依次往后查找，容量固定不可变。 2）基本操作：初始化，查找，插入，删除 二，顺序表格链表的对比： （1）逻辑结构：线性结构 （2）存储结构：顺序存储和链式存储 （3）基本操作： 创：（预分配一个空间，只需分配一个头结点） 销：（静态数组【lengeth=0】和动态数组【malloc和free】，free）
数据结构学习日记三：树
qq_63494746的博客
08-10 62
树、二叉树的遍历、二叉搜索树、二叉平衡树、堆、堆排序、哈夫曼、集合、合查集、按秩归并、路径压缩
数据结构学习日记六：查找
qq_63494746的博客
09-06 61
顺序查找 O(N)二分查找（静态查找） O(logN)二叉搜索树 O(h) h 为二叉查找树的高度平衡二叉树 O(logN)散列查找 几乎是O(1)，以空间换时间。
数据结构学习日记五：排序
qq_63494746的博客
09-01 58
冒泡排序、插入排序、希尔排序、选择排序、堆排序、归并排序、快速排序、表排序、桶排序、基数排序、排序算法的比较。
数据结构学习日记--线性结构（3月20日）
qq_51870528的博客
03-20 122
线性结构 线性表 堆栈 线性表 定义：由同类型数据元素构成有序序列的线性结构 表中元素个数称为线性表的长度 线性表没有元素时称为空表 表起始位置称表头，表结束位置称表尾 线性表的顺序储存实现 核心用一维数组储存数据，另一个变量储存表长 typedef int Position; typedef struct LNode *List; struct LNode { ElementType Data[MAXSIZE]; Position Last; }; 主要操作 创建顺序线性表 List
数据结构学习Day 1
m0_67720096的博客
04-19 139
数据结构的基本概念以及c语言的return和void
数据结构（java）——学习日记（树）
weixin_64836042的博客
05-19 73
树是一种非线性数据结构：每一个结点可以有零个或多个后继结点，但是有且仅有一个前驱结点（根节点除外）。数据元素之间存在的关系的一对多的关系。n>0时，有且仅有一个根节点（root），其余结点可分为m个互不相交的有限集，其中每个子集本身又是一棵符合本定义的树，称为根节点的子树。树是由n个结点组成的有限集合。（n=0时，是一棵空树），
DAY 7 学习日记 and CSP-J初赛知识2：逻辑运算与位运算&线性数据结构&冒泡排序
taoyiwei17_QFOI的博客
08-25 103
队列（queue）是一种特殊的线性表，特殊之处在于它只允许在表的前端（front）进行删除操作，而在表的后端（rear）进行插入操作，和栈一样，队列是一种操作受限制的线性表。进行插入操作的端称为队尾，进行删除操作的端称为队头。队列中没有元素时，称为空队列。队列的数据元素又称为队列元素。在队列中插入一个队列元素称为入队，从队列中删除一个队列元素称为出队。
数据结构学习笔记1
01-07
数据结构数据结构 数据结构 基本概念和术语 数据：是客观事物的符号表示，能够输入到计算机中并能被计算机程序处理的符号的总称 数据元素：是数据的基本单位，用于完整地描述一个对象 数据对象：是性质相同的数据...
数据结构与算法：数据结构.ppt
05-11
* * * 数据结构 逻辑结构和存储结构 线性结构和非线性结构 1 逻辑结构和存储结构 数据结构：有关联的数据元素的集合 1.逻辑结构 数据元素之间的逻辑关系，它可以是用一个数据元素的集合和定义在此集合中的若干关系来...
前面我们学习的线性数据结构完美版资料.ppt
11-30
前面我们学习的线性数据结构完美版资料.ppt
用C#学习数据结构之线性表
12-22
线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（1）除第一个位置的数据元素外，其它数据元素位置的前面都...
C#数据结构与算法揭秘二 线性结构
09-05
本文中，我们讨论了什么是线性结构，线性结构有哪些特点，并且详细介绍了一个最简单线性结构顺序表，并且通过源代码对她进行一些列的分析，最后还举了两个例子，让我们更好的理解顺序表
数据结构初阶 链表详解
Zbldx的博客
05-16 1206
数据结构初阶 单链表详解
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 378
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
P0【知识点】【数据结构】【数组Array】讲解C++版
qq_50891451的博客
05-16 208
大O表示法 O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)at() 这个方法返回的是一个引用，可以吧一个常量 int 赋值给它。数组索引（Access）：是通过数组的下标去找这个元素。大O表示法 O(1) < O(N) < O(N^2)数组搜索（Search）：是找这个元素的位置（索引）3.插入 Insert O(N)4.删除 Delete O(N)1.访问access O(1)2.搜索search O(N)【485】最大连续1的个数。
数据结构（链表）
wan__cheng的博客
05-19 429
存储空间上 物理上一定连续 逻辑上连续，但物理上不一定连续。插入 动态顺序表，空间不够时需要扩容 没有容量的概念。概念：链表是一种物理上不连续，非顺序的存储结构，数据元素的逻辑顺序上是通过指针来连接的线性表。任意位置插入或者删除元素 可能需要搬移元素，效率低O(N) 只需修改指针指向。
数据结构第二章线性表头哥
10-10
线性表是一种常见的数据结构，它是由一组具有相同数据类型的元素组成的数据集合，这些元素之间存在着一对一的关系。线性表中的元素按照一定的顺序排列，可以插入和删除元素。 在线性表中，头节点是指链表中第一个节点之前的一个节点，它不存储任何数据，只是用来标识链表的起始位置。头节点的存在可以简化链表操作的实现。 在线性表的头部进行插入或删除操作是比较方便的，因为头节点的存在可以减少对链表结构的修改。当需要在链表头部插入一个新节点时，只需要将新节点的指针指向原来的头节点，然后将头节点指向新节点即可。同样地，删除头部节点时只需要修改头节点的指针即可。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值