网上学习资料一大堆,但如果学到的知识不成体系,遇到问题时只是浅尝辄止,不再深入研究,那么很难做到真正的技术提升。
一个人可以走的很快,但一群人才能走的更远!不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人,都欢迎加入我们的的圈子(技术交流、学习资源、职场吐槽、大厂内推、面试辅导),让我们一起学习成长!
ai+1
ai+1之间的逻辑关系,对数据元素
a
i
ai
ai来说,除存储其本身的信息之外,还需要存储一个指示它直接后继的信息(即直接后继的存储位置),这两部分信息组成数据元素
a
i
ai
ai的存储映像,称为结点(node)。
它包括两个域:其中存储数据元素信息的域称为数据域
,存储直接后继存储位置的域称为指针域
,指针域中存储的信息称为指针或链,
n
n
n个结点(
a
i
ai
ai(1<=i<=n)的存储映像)链结成一个链表,即为线性表的链式存储结构
由于链表的每个结点中只包含一个指针域,所以又称这种链表为线性链表或单链表,整个链表的存取必须从头指针开始进行,头指针指示链表中的第一个结点(即第一个数据元素的存储映像)的存储位置,同时,由于最后一个数据元素没有直接后继,则线性链表中最后一个结点的指针为空(NULL)
单链表的定义:
//方式一
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//方式二
struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
};
typedef struct LNode LNode;
typedef struct LNode \*LinkList;
用线性链表表示线性表时,数据元素之间的逻辑关系是由结点中的指针指示的,换句话说,指针为数据元素之间的逻辑关系的映像,则逻辑上相邻的两个数据元素其存储的物理位置不要求紧邻,由此可得出,这种存储结构为非顺序映像或链式映像。
通常我们把链表画成用箭头相连接的结点的序列,结点之间的箭头表示链域中的指针,它所表是的线性表中数据元素之间的逻辑顺序,而不是每个数据元素在存储器中的实际位置
一般在一个单链表中,L
表示为单链表的头指针,它指向表中的第一个结点,若L为‘空’(L=NULL)
,则所表示的线性表为‘空表’,其长度n为‘零’。
带头结点的单链表初始化:
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);
.....
}
在单链表的第一个结点之前附设一个结点,称之为头结点。头结点的数据域可以不存储任何信息,也可以存储如线性表的长度等类的附加信息,头结点的指针域存储指向第一个结点的指针(即第一个元素结点的存储位置),单链表的头指针指向头结点。若线性表为空表,则头结点的指针域为‘空’。头结点的作用在于便于边缘化处理(好写程序),头结点也可以不写。
不带头结点的单链表初始化:
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){
if(L == NULL){
return true;
}else{
return false;
}
}
在线性表的顺序存储结构中,由于逻辑上相邻的两个元素在物理位置上也相邻,则每个元素的存储位置都可以从线性表的起始位置计算得到,而在单链表中,任何两个元素的存储位置之间没有固定的联系,要想取得第
i
i
i个数据元素必须从头指针出发寻找,因此,单链表是非随机存储结构。
单链表的局限性:无法逆向检索,有时候不方便
🚢基本操作
👻插入操作
⛅按位序插入
插入操作
,在表L中的第
i
i
i个位置上插入指定元素
想要在第i个位置上插入元素,那么就要找到第
i
−
1
i-1
i−1个结点,然后将新结点插入其后面
带头结点情况:
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1){
return false;
}
LNode \*p; //指针p指向当前扫描的结点
int j=0; //当前p指针的是第几个结点
while (p != NULL && j<i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL){ //i值不合法
return false;
}
LNode \*t = (LNode \*)malloc(sizeof(LNode));
t->data = e;
t->next = p->next;
p->next = t; //将结点t连接到p之后
return true; //插入成功
}
不带头结点情况:
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//在第i个位置插入元素e(带头结点)
bool ListInsert(LinkList &L, int i, ElemType e){
if(i<1){
return false;
}
if(i==1){
LNode \*t = (LNode \*)malloc(sizeof(LNode));
t->data = e;
t->next = L;
L = t: //头指针指向新结点
return true;
}
LNode \*p; //指针p指向当前扫描的结点
int j = 1; //当前p指向的是第几个结点
p = L; //p指向第一个结点(注意:不是头结点)
while(p != NULL && j<i-1){ //循环找到第i-1个结点
p = p->next;
j++;
}
if(p == NULL){ //i值不合法
return false;
}
LNode \*t = (LNode \*)malloc(sizeof(LNode));
t->data = e;
t->next = p->next;
p->next = t;
return true; //插入成功
}
当i=1时
,执行插入操作所需要的时间复杂度为
T
(
n
)
=
O
(
1
)
T(n) = O(1)
T(n)=O(1)
当i>1 && i<=n时
,时间复杂度为
T
(
n
)
=
O
(
n
)
T(n)=O(n)
T(n)=O(n)
但是,值得注意的是,实际上插入这个操作真正时间复杂度为
T
(
n
)
=
O
(
1
)
T(n)=O(1)
T(n)=O(1),而程序运行所耗费的时间都在找到要插入的元素位置的前一个位置,所以综合考究:
**📌平均时间复杂为
T
(
n
)
=
O
(
n
)
T(n) = O(n)
T(n)=O(n)**
⛅指定结点的后插操作
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//后插操作:在p结点之后插入元素e
bool InsertNextNode(LNode \*p, ElemType e){
if(p == NULL){
return false;
}
LNode \*t = (LNode \*)malloc(sizeof(LNode));
if(s==NULL){ //内存分配失败
return false;
}
t->data = e; //用结点t保存数据元素e
t->next = p->next;
p->next = t //将结点t连接到p之后
return true;
}
**📌平均时间复杂度为
T
(
o
)
=
N
(
1
)
T(o) = N(1)
T(o)=N(1)**
⛅指定节点的前插操作
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//后插操作:在p结点之前插入元素e
bool InsertNextNode(LNode \*p, ElemType e){
if(p == NULL){
return false;
}
LNode \*t = (LNode \*)malloc(sizeof(LNode));
if(s==NULL){ //内存分配失败
return false;
}
t->next = p->next;
p->next = t; //新结点t连接到p之后
t->data = p->data; //将p中元素复制到t中
p->data = e; //p中元素覆盖为e
}
**📌平均时间复杂度为
T
(
o
)
=
n
(
1
)
T(o) = n(1)
T(o)=n(1)**
👻删除操作
删除操作
。删除表L中第
i
i
i个位置的元素,并用
e
e
e返回删除元素的值
⛅按位序删除
带头结点情况:
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//带头结点的删除操作
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; //删除成功
}
**📌在删除操作中,最坏和平均时间复杂度为
T
(
o
)
=
o
(
n
)
T(o) = o(n)
T(o)=o(n)**
最好时间复杂度:
T
(
n
)
=
O
(
1
)
T(n) = O(1)
T(n)=O(1)
⛅指定节点的删除
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//删除指定结点p
bool DeleteNode(LNode \*p){
if(p == NULL){
return false;
}
LNode \*q = p->next; //令q指向\*p的后继结点
p->data = p->next->data //和后继结点交换数据域
p->next = q->next; //将\*q结点从链中断开
free(q); //释放后继结点的存储空间
return true;
}
但是,使用这个算法有个问题,如果p是最后一个结点,那么当程序执行到p->data = p->next->data
这一句时,会出现空指针的错误,所以只能从表头开始依次寻找p的前驱
**📌时间复杂度为
T
(
n
)
=
O
(
n
)
T(n) = O(n)
T(n)=O(n)**
👻查找操作(带头结点)
⛅按位查找操作
按位查找操作
。获取表L中第i个位置的元素的值
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//按位查找,返回第i个元素(带头结点)
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;
}
**📌平均时间复杂度为
T
(
n
)
=
O
(
n
)
T(n) = O(n)
T(n)=O(n)**
⛅按值查找操作
按值查找操作
。根据给定的值在表L中查找与之相同的指定元素
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//按值查找操作(带头结点)
LNode \* LocateElem(LinkList L, ElemType e){
LNode \*p = L->next;
// 从第1个结点开始查找数据域为e的结点
while(p != NULL && p->data != e){
p = p->next;
}
return p; //找到后返回该结点指针,否则返回NULL
}
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新
O
(
n
)
T(n) = O(n)
T(n)=O(n)**
⛅按值查找操作
按值查找操作
。根据给定的值在表L中查找与之相同的指定元素
typedef struct LNode{ //定义单链表节点类型
ElemType data; //每个节点存放一个数据元素
struct LNode \*next; //指针指向下一个节点
}LNode, \*LinkList
//按值查找操作(带头结点)
LNode \* LocateElem(LinkList L, ElemType e){
LNode \*p = L->next;
// 从第1个结点开始查找数据域为e的结点
while(p != NULL && p->data != e){
p = p->next;
}
return p; //找到后返回该结点指针,否则返回NULL
}
[外链图片转存中…(img-8ZBRqKbB-1715310313351)]
[外链图片转存中…(img-q34BtlEZ-1715310313351)]
[外链图片转存中…(img-Zb3x3MaS-1715310313351)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,涵盖了95%以上大数据知识点,真正体系化!
由于文件比较多,这里只是将部分目录截图出来,全套包含大厂面经、学习笔记、源码讲义、实战项目、大纲路线、讲解视频,并且后续会持续更新