第2章线性表的基本使用及其cpp示例（第二章汇总,线性表都在这里）

2.1线性表的定义和特点

【类型定义：
*是n个元素的有限序列
*除了第一个元素没有直接前驱和最后一个没有直接后驱之外，其余的每个元素只有一个直接前驱和直接后驱；
（a1,a2…an）

【特征：
*有穷性：由有限个元素组成，元素个数表长度 n=0空表
（a1,a2…an），称下标i为线性表的位序

*有序性： 线性表元素之间存在严格次序关系（序偶关系）

*同一性：线性表属于同类数据元素组成，每一个元素都属于同一数据对象
eg：（A，12，b）不是线性表，不遵守同一性

2.1.2线性表抽象数据类型定义

ADT List{

//数据对象
D={ai|ai∈ElemSet,i=1,2…n, n>0}

//数据关系
R1={<ai-1,ai>|ai-1,ai∈D,i=2,…n}

//基本操作
1)InitList(&L)
将：初数化为空表
2）

…

}ADT list

【引用在什么情况下使用】

所用到的元素，哪个元素变化（带入数据或者 ），就在此元素前加 &
【eg】
1)InitList(&L)
将：初数化为空表
//表L初始化带入值，发生变化，故早L前加&

2.1.5 示例 *有序集合的合并

有序表：LA和LB，求合并递减有序LC

基本思路：
{若ai<=bi,则ci=bi
{
{若bi<ai,则ci=ai
//谁小就先吧他赋给c

算法时间复杂度：O（ListLength(LA)）+O（ListLength(LB)）

2.2.1线性表的顺序表示和实现------顺序映像

【顺序存储】在【查找时】的时间复杂度为【O(1)】，因为它的地址是连续的，只要知道首元素的地址，根据下标可以很快找到指定位置的元素
【插入和删除】操作由于可能要在插入前或删除后对元素进行移动，所以顺序存储的时间复杂度为【O(n)】。

1）初始化操作
思想：构造一个空表
设置表起始位置、表长及可用空间

#define LIST_INIT_SIZE 100
#define LISTINCREAMENT 10
typedef struct
{
ElemType *elem;   //定义个地址变量，使其后面能指向线性表占用的数组空间
int length;  // 线性表的长度
int listsize;  // 当前分配的存储容量
}SqList;//初始化操作
Status InitList_Sq(SqList &L)  //初始化
{ //构造一个空表
L.elem=(ElemType)malloc(LIST_INIT_SIZE*size of(ElemType));
if(!L.elem)  exit(OVERFLOW);  //存储分配失败
L.length=0;   //空表长度为0
L.listsize=LIST_INIT_SIZE;  //初始存储容量
return OK;}

2.2.3顺序表的插入

2）顺序插入操作

目的：在线性表L第i个元素前插入一个元素e

【基本思想
1）判断i是否在允许范围
2）存储空间是否已满
3）将第i个元素和后面的所有元素向后移动
4）新元素写在空出的第i个位置
5）线性表长度加1

【注意】
长度为n的顺序表第i个位置插入移动n-i+1个元素


Status ListInsert_Sq(SqList&L,int i,ElemType e){if(i<1||i>1.lenth+1)
return ERROR;   //插入位置不合法if(L.length>=L.listsize)
{
newbase=(ElemType*)realloc(L.elem,(LIST_INIT_SIZE+LISTINCREMENT)*sizeof(ElemType)); If(!newbase) exit（OVERFLOW）;// 当前存储空间已满L.elem=newbase;              //新基址L.listsize+=LISTINCREMENT;  // 增加存储容量 
}     //判断空间足够q=&(L.elem[i-1]);   //q指向插入位置for(p=&(L.elem[L.elem-1]);p>-q;--q)
*(p+1)=*p;
*q=e;
++L.length;
return OK;
}

2.2.4顺序表的删除和插入

【基本思路
1）判断i是否在允许范围
2）将线性表的第i个元素给e
3）将第i个元素和后面的所有元素向前移动一个位置
4）线性表长度减1


Status ListDelete_Sq(SqList&L,int i,ElemType e){//删除第i个元素并用e返回值if(i<1||i>1.lenth+1)
return ERROR;   //删除位置不合法p=&(L.elem[i-1]);   //q指向插入位置
e=*p;
q=L.elem+L.length-1; //表尾元素位置
for(++p;p<=q;++p)
*(p-1)=*p;    //p-1指向p--L.length;
return OK;
}

【图】：平均移动次数

【查找操作】11:42

int LocateElem_Sq(SqList,ElseType e)
{
//查询第一个 满足条件的元素，若存在，返回位序，否则返回0；
int i;
i=1;
while (i<=L.length&&L.elem[i-1]!=e)
++i;
if(i<=L.length)
return i;
else return 0;
}// locateElem_Sqi<=L.length&&L.elem[i-1]!=e
i>L.length

【顺序结构优缺点14:15
【优点：
逻辑相邻，物理相邻
可随机存取一元素
存储空间使用紧凑
【缺点：
插入，删除需要移动大量元素
预先分配空间需按最大空间分配，利用不充分表难以扩充

【】线性表的合并问题
【图：例1】
基本思路：
1）初始化Lc为空表
2）分别从La和Lb取得当前元素ai和bi
3)若ai<bj，则将ai插入到Lc中，否则
bj插入到Lc中

代码：


Viod MergeList(SqList La.SqList ,lb.SqList &Lc)
{
Pa=La.elem;
Pb=Lb.elem;
Lc.listsize=Lc.length=La.elem+Lb.elem;
Pc=Lc.elem=(ElemType*)malloc(Lc.listsize* sizeof(ElemType));
if(!Lc.elem)
exit(overflow);
Pa_last=La.elem+La.length-1;
Pb_last=Lb.elem+Lb.length-1;
while(pa<=pa_last&&pb<=pb_last)
{
if(*pa<= *pb)
*pc++= *pa++;
else
*pc++= *pb++;
}
while(pa<=pa_last)
*pc++= *pa++;
while (pb<=pb_last)
*pc++= *pb++;
}

2.3线性表的链式表现与实现

2.3.1.1单链表
【特点：
*用一组任意的存储单元存储线性表的数据元素
*利用指针实现用不同相邻的存储单元存放逻辑上相邻的元素
*每个元素ai，除存储本身信息外，还存储其直接后继的元素（后一个元素的地址）
*结点：数据元素ai的存储映像
{数据域：数据元素本身
指针域：指示直接后继的存储位置

【头指针、头结点、第一个元素结点
*头指针：以线性表的第一个数据元素a1的存数地址作为线性表的地址，称为线性表的头指针

*头结点：为了操作方便，在第一个结点前虚加一个“头结点”，指向头结点的指针为链表的头指针（相当于第一个呀元素的结点）

代码：

typedef struct LNode{ElemType data;struct LNode*next;
}LNode,*LinkList    //LNode是结构体的别名，LinkList为指针变量
//相当于：typedef LNode *LinkList

2.3.1.2 单链表存储结构实现

格式： data | next

【p指向数据域
(*p).data=10;
或：p->data=10; //表示p指向结点的数据域

（*p）.next=10
或 p->next //表示p指向结点的指针域

*生成一个LNode型新结点：
p=(LinkList)malloc(sizeof(LNode));

*系统回收p的结点
free（p）

*单链表特点：
1）是它是一种动态结构，整个存储空间为多个链表共用
2）不需预先分配空间
3）指针占用额外存储空间
4）不能随机存取，查找速度慢

【基本操作：
1）GetElem（L,i,&e） //第i个元素用e带回结果
2）ListInsert(&L,i,e) //插入
3）ListDelete(&L,i,e) //删除
4）CreateList_L（&L,n） //创建线性表

2.3.1.3单链表的查找

【操作：
1）GetElem（L,i,&e）

【基本思想：
1）令p为指针变量，首先指向第一个结点，变量 j为计数器
2）依次向后查找，循环结束条件：p为空或j>=i；
3）找到用e返回第i个值

【代码：


Status GetElem_L(LinkList L,int i,ElemType&e)
{  //L是链表的头指针（对带头结点的链表），以e返回dii个值
p=L->next;
j=1;while (p&&j<i)
{p=p->next;  ++j;if(!p||j>i)return ERROR;e=p->data;  //取第i个值
return OK;
}

2.3.1.4单链表的插入操作

2）ListInsert(&L,i,e)
在线性表第i个元素之前插入一个元素e，元素e存在结点s中

【思路：在第i项的前加一个接结点，i-1项的地址域和e的数据域连接


int ListInsert_L(LinkList&L,int i,int e)
{
LNode*p,*s;int j;   //或：LinkList p,s;    等同
p=L;j=0; //计数器
while(p&&j<i-1)
{p=p->next;++j;}
if(!p||j>i-1)
return ERROR;
s=LinkList()malloc(sizeof(LNode)); //新结点
s->data=e;
s->next=p->next;
p->next=s;
return OK;
}

2.3.1.5 单链表的删除

【思路：删除第i个元素，并保存到元素e中

【代码：

int ListDelete_L(LinkList&L,int i,ElemType&e)
{
LNode*p,*q;int j;
p=L;j=0;
while(p->next||j<i-1)       //？？？？我觉得应该是(!p||j>i-1)
{p=p->next;++j}
if(p->next==NULL||j>i-1)
return ERROR;    //删除位置不合理
q=p->next;  //q指向被删除结点
p->next=q->next;  //
e=q->data;   //取出第i个结点的数据域
free(q);    // 释放dii个结点的内存
return OK;
}

2.3.1.6单链表的建立

【头插法建立有头结点的单链表
可理解为:每次插一个新的头
【图】
L=(Linklist)malloc(sizeof(LNode)) //sizeof后面跟数据类型（LNode）
L->next=NULL

【图】
p=(LinkList)malloc(sizeof(LNode))
scanf("%f",&(p->data)); //

【整个代码：

void CreateList_L(LinkList &L,int n)
{
LNode*p;int i;
L=(LinkList)malloc(sizeof(Lnode));
L->next=NULL;
for(i=n;i>0;--i)
{ p=(Listlink)malloc(sizeof(LNode));
scanf("%d",&p->data);
p->next=L->next;
l->next=p     //这里的=都可以理解为“给了，到，指向”
}
}

2.3.1.7有序单链表的合并

例：线性表LA和LB中数据元素按照废帝剑有序排列，将LA和LB合并为一个新的LC，且LC中的数据元素仍按照递减有序排列

在这里插入图片描述
【代码：


void MergeList_L(LinkList&La,LinkList&Lb,LinkList&Lc)
{// 归并La和Lb得到Lc，Lc也按照降序排列
LinkList pa,pb,pc;
pa=La->next;pb=Lb->next;
Lc=pc=La;  //用La的头结点作为Lc的头结点
while(pa&&pb)
{
if(pa->data<=pb->data)
{
pc->next=pa; pc=pa;pa=pa->next;
}
else
{
pc->next=pb;pc=pb;pb=pb->next;
}
pc->next=pa?pa:pb;  //若a不为空则指向pa，否则指向pb
free(Lb);
}

2.3.1.8静态链表

定义：用数组描述的链表叫静态链表

目的：为在不设指针类型的高级程序语言中使用链表结构

存储结构：

#define MAXSIZE 100 //静态链表最大长度
typedef struct{
ElemType data;
int cur;  //游标，代替指针的结点，表示数组中的位置
}component,SLinkList[MAXSIZE]

在这里插入图片描述

2.3.2循环链表

循环链表是单链表的变形

循环链表最后一个结点link指针部位NULL，而是指向表的前端

为简化操作，在循环链表往往插入头结点

特点：
只要知道表中一结点的地址，就可以搜索到所有其他结点的地址

操作的时间复杂度：
表尾插入，时间复杂度：O(1)
表尾删除：O(n)
表头插入，同表尾
表头删除：O(1)

2.3.3双向链表 插入、删除

指在前驱和后驱方向都能游历（遍历）的线性链表

双向链表的每个结点有两个指针域
【结构】：prior data next

双链表通常采用带头结点的循环链表形式
在这里插入图片描述

可理解为首位相接的数据“圈”，每个结点都可以向前或向后走

【结点指向】
在这里插入图片描述

【插入操作】：

1.分配空间
2.断开与连接

在这里插入图片描述
【操作算法


status ListInsert_DuL(DuLinkList &L,int i,ElemType e)
{if(!p=GetElem_Dul(L,i))  
return ERROR;  //相当于嵌套第i个结点的指针if(!(s=(DuLinkList)malloc(sizeof(DuLNode))))
return ERROR   //空间分配失败
s-data=e;      //将数据放入新结点的数据图
s-prior=p-prior;  //将p的前驱结点指针放入新结点的前向指针域
s-next=p;      //将p放入新结点的反向指针域
p-prior-next=s;   //修改p的前驱结点的反向指针
p-prior=s;    // 修改p的前驱指针
return OK;
}   ListInsert_DuL
【删除操作】

1.p指向目标结点
2.将目标结点的前一个结点与后一个连接（跳过中间那个）
3释放内存

在这里插入图片描述
【操作算法】
status ListDelete_Dul(DuLinkList &L,int i,ElemType &e)
{ 删除头结点的双向循环链表L中第i个元素返回，1=i=表长
if（!p=GetElem_Dul(L,i)）
return ERROR; 查找第i个指针
e=p-data; 将p指向结点数据域中的值取出
p-prior-next=p-next; p前一个结点的后驱指向p的后一个结点
p-next-prior=p-prior; 后指向前
free§; 释放p
return OK;

} ListDelete_DuL

【 算法评价：T(n)=O(n) 】

！注意：如何选择合适的存储结构
链表只能顺序存取，在单链表的最后一个元素后插入元素，需遍历整个链表

在这里插入图片描述

频繁插入删除用链式存储
偶尔 用顺序存储

2.4一元多项式的表示及相加

  • n阶多项式的表示：
    n阶多项式有n+1项
    指数按升幂排序

【 优点：

  • 多项式的项数可以动态增长，不存在存储溢出的问题
  • 插入，删除方便，不移动元素

【表示：
有两个数据域，一个地址域

在这里插入图片描述
【一元多项式的建立算法：


void polycreate(Polylist &head)
{
polylist rear,s;  int c,e;
head=(Polynode *)malloc(sizeof(POlynode));
rear=head;      //尾插法
scanf("%d,%d",&c,&e);
while(c!=0){ s=(Polynode *)malloc(sizeof(Polynode));s->coef=c; s->exp=e;rear->next=s;  rear=s;scanf("%d,%d",&c,&e);rear->next=NULL;}
}

【一元多项式相加：

  • 扫描两个多项式
    {若当前被检测项指数相等，系数相加。 和不为0，则结果加到结果多项式

    {若检查指数不等，将指数小的加到结果多项式，然后往后移

  • 若一个多项式检测完，将另一个多项式剩余全部复制到结果多项式

【设计思想：

在这里插入图片描述
算法：

void polyadd(Polylist polya,Polylist polyb)
{
Polynode *pa,*pb,*pc,*r;
int sum;
pa=polya->next;
pb=polyb->next;
pc=polyb;   //pre指向和多项式的尾结点while(pa!=NULL&&pb!=NULL)
{
if(pa->exp<pb->exp){pa->next=pa; pc=pa;pa=pa->next;}    //【1.】 pa指数小于pb指数，把pa给了pc
else if(pa->exp==pb->exp){sum=pa->coef+pb->cofe;if(sum!=0)                                            //【3.】指数相等，但系数sum不是0{pa->cofe=sum; pc->next=pa;pc=pa; pa=pa->next;r=pb; pb=pb->next ;  free(r);}else                                                    //【4.】指数相等，系数sum为0{r=pa; pa=pa->next;free(r);r=pb;pb=pb->next;free(r);}}else{pc->next=pb; pc=pb;pb=pb->next;}    // 【2.】pb指数小于pa指数，把pb给了pcif(pa!=NULL)pc->next=pa;
else pc->next=pb;
}}

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

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

相关文章

2.3单链表的基本使用及其cpp示例

2.3单链表的基本使用及其cpp示例

2.3线性表的链式表现与实现 2.3.1.1单链表 【特点&#xff1a; *用一组任意的存储单元存储线性表的数据元素 *利用指针实现用不同相邻的存储单元存放逻辑上相邻的元素 *每个元素ai&#xff0c;除存储本身信息外&#xff0c;还存储其直接后继的元素&#xff08;后一个元素的地址…
阅读更多...
TVM：简介

TVM：简介

TVM&#xff1a;简介概述 Apache TVM 是一个用于 CPU、GPU 和机器学习加速器的开源机器学习编译器框架。它旨在使机器学习工程师能够在任何硬件后端上高效地优化和运行计算。本教程的目的是通过定义和演示关键概念&#xff0c;引导您了解 TVM 的所有主要功能。新用户应该能够从…
阅读更多...
2.3.3单链表的双向链表

2.3.3单链表的双向链表

2.3.3双向链表 插入、删除 指在前驱和后驱方向都能游历&#xff08;遍历&#xff09;的线性链表 双向链表的每个结点有两个指针域 【结构】&#xff1a;prior data next 双链表通常采用带头结点的循环链表形式 可理解为首位相接的数据“圈”&#xff0c;每个结点都可以向前…
阅读更多...
nvidia-smi 命令详解

nvidia-smi 命令详解

nvidia-smi 命令详解 简介 nvidia-smi - NVIDIA System Management Interface program nvidia smi&#xff08;也称为NVSMI&#xff09;为来自 Fermi 和更高体系结构系列的 nvidia Tesla、Quadro、GRID 和 GeForce 设备提供监控和管理功能。GeForce Titan系列设备支持大多数…
阅读更多...
2.4一元多项式的表示及相加，含cpp算法

2.4一元多项式的表示及相加，含cpp算法

2.4一元多项式的表示及相加 n阶多项式的表示&#xff1a; n阶多项式有n1项 指数按升幂排序 【 优点&#xff1a; 多项式的项数可以动态增长&#xff0c;不存在存储溢出的问题插入&#xff0c;删除方便&#xff0c;不移动元素 【表示&#xff1a; 有两个数据域&#xff0c;一…
阅读更多...
TVM：使用Tensor Expression (TE)来处理算子

TVM：使用Tensor Expression (TE)来处理算子

TVM&#xff1a;使用Tensor Expression (TE)来处理算子 在本教程中&#xff0c;我们将聚焦于在 TVM 中使用张量表达式&#xff08;TE&#xff09;来定义张量计算和实现循环优化。TE用纯函数语言描述张量计算&#xff08;即每个表达式都没有副作用&#xff09;。当在 TVM 的整体…
阅读更多...
4-数据结构-串的学习

4-数据结构-串的学习

4.1串类型的定义 1.串&#xff1a;&#xff08;或字符串&#xff09; 串是由多个字符组成的有限序列&#xff0c;记作&#xff1a;S‘c1c2c3…cn’ (n>0) 其中S是串的名字&#xff0c;‘c1c2c3…cn’ 是串值 ci是串中字符 n是串的长度&#xff0c;表示字符的数目 空串&a…
阅读更多...
5-数据结构-数组的学习

5-数据结构-数组的学习

5.1数组的定义 定义&#xff1a; 由一组类型相同的数据元素构成的有序集合&#xff0c;每个数据元素称为一个数据元素&#xff08;简称元素&#xff09;&#xff0c;每个元素受n&#xff08;n>1&#xff09;个线性关系的约束&#xff0c;每个元素在n个线性关系中的序号i1、…
阅读更多...
timm 视觉库中的 create_model 函数详解

timm 视觉库中的 create_model 函数详解

timm 视觉库中的 create_model 函数详解 最近一年 Vision Transformer 及其相关改进的工作层出不穷&#xff0c;在他们开源的代码中&#xff0c;大部分都用到了这样一个库&#xff1a;timm。各位炼丹师应该已经想必已经对其无比熟悉了&#xff0c;本文将介绍其中最关键的函数之…
阅读更多...
C--数据结构--树的学习

C--数据结构--树的学习

6.2.1二叉树的性质 1.二叉树 性质&#xff1a; 1.若二叉树的层次从1开始&#xff0c;则在二叉树的第i层最多有2^(i-1)个结点 2.深度为k的二叉树最多有2^k -1个结点 &#xff08;k>1&#xff09; 3.对任何一颗二叉树&#xff0c;如果其叶结点个数为n0,度为2的非叶结点个数…
阅读更多...
C语言—sort函数比较大小的快捷使用--algorithm头文件下

C语言—sort函数比较大小的快捷使用--algorithm头文件下

sort函数 一般情况下要将一组数从的大到小排序或从小到大排序&#xff0c;要定义一个新的函数排序。 而我们也可以直接使用在函数下的sort函数&#xff0c;只需加上头文件&#xff1a; #include<algorithm> using namespace std;sort格式&#xff1a;sort(首元素地址&…
阅读更多...
AI编译器与传统编译器的联系与区别

AI编译器与传统编译器的联系与区别

AI编译器与传统编译器的区别与联系 总结整理自知乎问题 针对神经网络的编译器和传统编译器的区别和联系是什么&#xff1f;。 文中提到的答主的知乎主页&#xff1a;金雪锋、杨军、蓝色、SunnyCase、贝壳与知了、工藤福尔摩 笔者本人理解 为了不用直接手写机器码&#xff0…
阅读更多...
python学习1：注释\变量类型\转换函数\转义字符\运算符

python学习1：注释\变量类型\转换函数\转义字符\运算符

python基础学习 与大多数语言不同&#xff0c;python最具特色的就是使用缩进来表示代码块&#xff0c;不需要使用大括号 {} 。缩进的空格数是可变的&#xff0c;但是同一个代码块的语句必须包含相同的缩进空格数。 &#xff08;一个tab4个空格&#xff09; Python语言中常见的…
阅读更多...
python 学习2 /输入/ 输出 /列表 /字典

python 学习2 /输入/ 输出 /列表 /字典

python基础学习第二天 输入输出 xinput("输入内容") print(x)input输出&#xff1a; eval :去掉字符串外围的引号&#xff0c;按照python的语法执行内容 aeval(12) print(a)eval输出样式&#xff1a; 列表 建立&#xff0c;添加&#xff0c;插入&#xff0c;删去…
阅读更多...
快速排序 C++

快速排序 C++

快速排序 C 本文图示借鉴自清华大学邓俊辉老师数据结构课程。 快速排序的思想 快速排序是分治思想的典型应用。该排序算法可以原地实现&#xff0c;即空间复杂度为 O(1)O(1)O(1)&#xff0c;而时间复杂度为 O(nlogn)O(nlogn)O(nlogn) 。 算法将待排序的序列 SSS 分为两个子…
阅读更多...
llvm与gcc

llvm与gcc

llvm与gcc llvm 是一个编译器&#xff0c;也是一个编译器架构&#xff0c;是一系列编译工具&#xff0c;也是一个编译器工具链&#xff0c;开源 C11 实现。 gcc 相对于 clang 的优势&#xff1a; gcc 支持更过语言前端&#xff0c;如 Java, Ada, FORTRAN, Go等gcc 支持更多地 …
阅读更多...
攻防世界web新手区解题 view_source / robots / backup

攻防世界web新手区解题 view_source / robots / backup

1**. view_source** 题目描述&#xff1a;X老师让小宁同学查看一个网页的源代码&#xff0c;但小宁同学发现鼠标右键好像不管用了。 f12查看源码即可发现flag 2. robots 题目描述&#xff1a;X老师上课讲了Robots协议&#xff0c;小宁同学却上课打了瞌睡&#xff0c;赶紧来教教…
阅读更多...
听GPT 讲Rust源代码--src/tools(25)

听GPT 讲Rust源代码--src/tools(25)

File: rust/src/tools/clippy/clippy_lints/src/methods/suspicious_command_arg_space.rs 在Rust源代码中&#xff0c;suspicious_command_arg_space.rs文件位于clippy_lints工具包的methods目录下&#xff0c;用于实现Clippy lint SUSPICIOUS_COMMAND_ARG_SPACE。 Clippy是Ru…
阅读更多...
Java一次编译，到处运行是如何实现的

Java一次编译，到处运行是如何实现的

Java一次编译&#xff0c;到处运行是如何实现的 转自&#xff1a;https://cloud.tencent.com/developer/article/1415194 &#xff08;排版微调&#xff09; JAVA编译运行总览 Java是一种高级语言&#xff0c;要让计算机执行你撰写的Java程序&#xff0c;也得通过编译程序的…
阅读更多...
攻防世界web新手区解题 /cookie / disabled_button / weak_auth

攻防世界web新手区解题 /cookie / disabled_button / weak_auth

cookie 题目描述&#xff1a;X老师告诉小宁他在cookie里放了些东西&#xff0c;小宁疑惑地想&#xff1a;‘这是夹心饼干的意思吗&#xff1f;’ 使用burp suite抓包查看 发现提示&#xff1a; look-herecookie.php 于是在url后加上 cookie.php 得到提示查看返回 就得到了f…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023