从零开始的数据结构笔记（一）单链表

最新推荐文章于 2024-04-30 11:22:32 发布

京知秋华

最新推荐文章于 2024-04-30 11:22:32 发布

阅读量141

点赞数 1

文章标签：数据结构链表

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文链接：https://blog.csdn.net/inaner/article/details/119383641

版权

本文详细介绍了单链表的各种基本操作，包括带头结点的按位序插入、不带头结点的按位序插入、指定结点的后插与前插操作、按位序及指定结点的删除以及按位和按值查找。代码实现涵盖了链表创建、插入、删除和查找的常见场景，有助于理解链表数据结构的运用。

摘要由CSDN通过智能技术生成

目录

一、单链表的插入操作:按位序插入（带头结点）

二、单链表的插入操作（不带头结点）(按位序)

三、单链表的后插操作(指定结点)

四、单链表的前插操作(指定结点)

五、按位序删除结点

六、指定结点的删除

七、单链表的查找

八、单链表的创建

一、单链表的插入操作:按位序插入（带头结点）

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
bool Listinsert(LinkList &L,int i,int e)
{
    if(i<1)
    return false;            
    LinkList p             //p指针用来扫描到第几个结点了,故不用分配空间
    p=L;                   //让p指向头指针开始
    int j=0;               //j的作用就是表明我们扫描到第几个结点了
    LinkList s;            //s为我们要插入的结点
    s=(LinkList)malloc(sizeof(LNode));
    for(;p!NULL&&j<(i-1);j++)
    {
    p=p->next;
    }
    if(p==NULL)
    return NULL;           //防止i的值不合法 因为如果插到表尾的话指向(i-1)也不可能是NULL
    s->next=p->next;
    p->next=s;             //交换的这两行不能颠倒
    s->data=e;
    return true;
    
}

二、单链表的插入操作（不带头结点）(按位序)

不带头结点也就意味着没有第“0”个节点

所以我们要对i=1的情况进行讨论则把插入的第一个结点作为头结点 其他情况和带头结点的一样

则代码为:

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=NULL;
    return true;
}
bool Listinsert(LinkList &L,int i,int e)
{
    if(i<1)
    return false;            
    LinkList p             //p指针用来扫描到第几个结点了,故不用分配空间
    p=L;                   //让p指向头指针开始
    int j=0;               //j的作用就是表明我们扫描到第几个结点了
    LinkList s;            //s为我们要插入的结点
    s=(LinkList)malloc(sizeof(LNode));
    if(i==1)
    {
    s->data=e;
    s->next=L;
    L=s;
    return true;
    }
    for(;p!NULL&&j<(i-1);j++)
    {
    p=p->next;
    }
    if(p==NULL)
    return NULL;           //防止i的值不合法 因为如果插到表尾的话指向(i-1)也不可能是NULL
    s->next=p->next;
    p->next=s;             //交换的这两行不能颠倒
    s->data=e;
    return true;
    
}

三、单链表的后插操作(指定结点)

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
bool Listinsert(LNode *s,int e)        //直接修改地址就完事
{
    if(s==NULL)    
    return false;
    LinkList p;
    p=(LinkList)malloc(sizeof(LNode));
    if(p==NULL)                        //这里判断p是否分配完空间
    return false;
    p->next=s->next;
    s->next=p;
    p->data=e;
    return true;
}

四、单链表的前插操作(指定结点)

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
bool Listinsert(LNode *s,int e)
{
    if(s==NULL)
    return false;
    LinkList p;
    p=(LinkList)malloc(sizeof(LNode));
    if(p==NULL)            
    return false;                //这里进行一个交换的操作
    p->data=s->data;             //即新创建一个结点 与要插入的结点进行一个数据域的交换
    s->data=e;
    p->next=s->next;
    s->next=p;
}

五、按位序删除结点

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
bool ListDelete(LinkList &L,int i,int &e)
{
    if(i<1)
    return false;
    LNode *p;
    p=L;
    int j=0;
    while(p!=NULL&&j<(i-1))
    {
    p=p->next;
    j++;
    }
    if(p->next==NULL)
    return false;                //排除(i-1)个结点后再无结点
    LinkList s;
    s=p->next;
    e=s->data;
    p->next=s->next;
    free(s);                    //注意需要释放s结点的空间
    return true;
}

六、指定结点的删除

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
bool DeleteNode(LNode *p)
{
    if(p==NULL)
    return false;
    LNode *s;
    s=p->next;
    p->data=s->data;
    p->next=s->next;     //这里是指一般情况 删除非表尾的结点
    free(s);             //若是删除表尾的结点的话 需要从输入单链表 来寻找删除的结点的前驱结点
}

七、单链表的查找

1.按位查找

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
LNode *GetElem(LinkList &L,int i)
{
    if(i<0)
    return NULL;            //注意这里返回的是NULL而不是false
    LinkList s;
    s=L;
    int j=0;
    while(s!=NULL&&j<i)
    {
    s=s->next;
    j++;
    }
    return s;
    
}

2.按值查找

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int data;
	struct LNode *next;	
}LNode,*LinkList;

bool InitList(LinkList &L)
{
	L=(LinkList)malloc(sizeof(LNode));
	if(L==NULL)
	return false;
	L->next=NULL;
	return true; 
}
LNode * LocateElem(LinkList &L,int e)
{
    LinkList s;
    s=L;   
    while(s!=NULL&&s->data!=e)
    {
    s=s->next;
    }
    return s;
}

八、单链表的创建

1.尾插法

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int 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;
}
LinkList LinkList_TailInsert(LinkList &L)
{
    int x=0;
    LinkList *s,*p;
    *s=L;
    *p=L;
    scanf("%d",&x);
    while(x!=999)
    {
    s=(LNode *)malloc(sizeof(LNode));
    s->data=x;
    p->next=s;
    p=p->next;
    scanf("%d",&x);
    }
}
int main()
{
    LinkList L;
    
}

这里注意需要有一个指向表尾的指针

2.头插法

头插法相当于重复在头指针进行后插操作

#include <stdio.h>
#include <stdlib.h>
typedef struct LNode
{
	int 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;
}
LinkList List_HeadInsert(LinkList &L)
{
    L->next=NULL;
    LinkList s;
    s=(LNode *)malloc(sizeof(LNode));
    int x=0;
    scanf("%d",&x);
    while(x!=999)
    {
    s->data=x;
    s->next=L->next;        //这一步注意不能省
    L->next=s;   
    scanf("%d",&x);+
    }
    
}
int main()
{
    LinkList L;
    InitList(L);
}

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
从零开始的数据结构笔记（一）单链表

一顺序表和单链表的各自优缺点:顺序表:优点:1.随机访问:在O(1)时间内找到第i个元素(无论是静态分配还是动态分配)2.存储密度高3.拓展容量不方便
复制链接

扫一扫

评论

被折叠的条评论为什么被折叠?

到【灌水乐园】发言

查看更多评论

添加红包

成就一亿技术人!

hope_wisdom

发出的红包

实付元

使用余额支付

点击重新获取

扫码支付

钱包余额 0

抵扣说明：

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