数据结构-单链表的系列操作

最新推荐文章于 2024-05-15 16:25:03 发布
最新推荐文章于 2024-05-15 16:25:03 发布
阅读量660 收藏 2
点赞数
分类专栏： 学习笔记 文章标签： 链表 数据结构 c++ c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Chaim998/article/details/121366034
版权

数据结构-单链表的系列操作

1、头文件

#ifndef LINKLISTHEAD_H_INCLUDED
#define LINKLISTHEAD_H_INCLUDED

#include<stdio.h>
#include<malloc.h>

//0、单链表的数据结构
typedef struct LNode
{
    int data;
    struct LNode *next;
}LNode,*LinkList;

/*
在对链表的操作过程中，LinkList型列表经常作为参数，因为LinkList是指针，所以用不用引用传递（&）都一样，
但为了保险，可以在对链表进行修改时使用引用传递（&），而在查找时使用值传递。初始化链表必须引用传递
*/

//1、带头节点的链表
//1.1初始化带头节点的单链表
bool InitList1(LinkList &L);
//为什么必须使用引用传递，不使用引用传递，调试的结果发现两次L->next指向地址相同，没有指向新声明的节点



//1.2判断带头节点的单链表是否为空
bool Empty1(LinkList L);

//1.3头插法-带头节点的单链表
LinkList list_HeadInsert(LinkList &L,int x);

//1.4头插法输入数据-带头节点的单链表
LinkList list_HeadInsertS(LinkList &L);

//1.3.2按位序插入-带头节点的单链表
bool ListInsert(LinkList &L,int i,int x);

//1.3.3后插法-指定节点的后插
bool InsertNextNode(LNode *p,int x);

//1.3.4前插法-指定节点前插操作
bool InsertPriorNode(LNode *p,int x);

//1.3.5尾插法-带头节点的单链表
bool ListInsertTail(LinkList &L,int x);

//1.4.1按位序删除
bool ListDelete(LinkList &L,int i);

//1.4.2按节点删除
bool DeleteNode(LNode *p);

//1.5遍历带头节点的列表
void PrintList(LinkList L);

//1.6获取指定节点
LNode* GetNode(LinkList L);

//1.7.1按位查找-带头节点的单链表
LNode *GetElem(LinkList L,int i);

//1.7.2按值查找-带头节点的单链表
LNode *LocateElem(LinkList L,int x);



//---------------------------带头节点和不带头节点分界线------------------------

//2、不带头节点的链表
//2.1初始化不带头节点的单链表
bool InitList2(LinkList &L);

//2.2判断不带头节点的单链表是否为空
bool Empty2(LinkList L);

//2.3按序插入-不带头节点的链表
bool ListInsert2(LinkList &L,int i,int x);

//2.5遍历不带头节点的列表
void PrintList2(LinkList L);


#endif // LINKLISTHEAD_H_INCLUDED

2、main方法

#include"LinkListHead.h"

int main()
{

//1、带头节点
LinkList L;
InitList1(L);//初始化单链表

if(Empty1(L))//判断链表是否为空
    printf("\n链表为空\n");
else
    printf("\n链表不为空\n");

printf("\n头插法插入数据：");
L=list_HeadInsertS(L);
PrintList(L);

printf("\n按序号插入：\n");
ListInsert(L,4,11);
PrintList(L);

printf("\n尾插法插入：\n");
ListInsertTail(L,33);
PrintList(L);

printf("\n在第5个节点前和后插入节点\n");
LNode *p0=GetNode(L);
InsertNextNode(p0,50);
InsertPriorNode(p0,49);
PrintList(L);

//---------------
printf("\n按位序删除节点\n");
ListDelete(L,5);
PrintList(L);

printf("\n按节点删除\n");
LNode *p1 = GetNode(L);//获取节点
DeleteNode(p1);//删除获取的节点
PrintList(L);

printf("-------%d-------",p0->data);//这里的p0虽然有数据，但是它已经脱离链表了，不可再使用
//-----------------

printf("\n按位查找第五个元素:\n");
LNode *p3 = GetElem(L,5);
printf("-----%d-----",p3->data);

printf("\n按值查找第五个元素:\n");
LNode *p4 = LocateElem(L,50);
printf("-----%d-----",p4->data);


//---------------------------------------带头节点和不带头节点分界线-------------------------------------------------
//2、不带头节点
LinkList L2 = L->next;//去掉带头节点的链表就是不带头节点的链表
printf("\n按序号插入：\n");
ListInsert2(L2,8,22);
PrintList2(L2);


    return 0;
}

3、单链表的相关操作

#include"LinkListHead.h"


//0、带头节点的单链表的数据结构


//1、带头节点的单链表

//1.1初始化带头节点的单链表
bool InitList1(LinkList &L)//注意：这里是引用传递
{
    L=(LNode *)malloc(sizeof(LNode));
    if(L==NULL)//分配失败（一般没有必要，只是出严谨考虑）
        return false;
    L->next = NULL;
    return true;
}

//1.2判断带头节点的单链表是否为空
bool Empty1(LinkList L)
{
    if(L->next==NULL)
        return true;
    else
        return false;
}

//---------五种插入法-----------始
//1.3.1头插法-带头节点的单链表
LinkList list_HeadInsert(LinkList &L,int x)
{
    LNode *s;
    s = (LNode*)malloc(sizeof(LNode));//创建新的节点
    s->data=x;
    s->next=L->next;
    L->next=s;
    return L;
}

//1.3.1头插法输入数据-带头节点的单链表
LinkList list_HeadInsertS(LinkList &L)
{
    int x;
    printf("\n请输入你希望的数，输入9999表示结束：\n");
    scanf("%d",&x);
    while(x!=9999)
    {
        list_HeadInsert(L,x);//调用头插法，也可以调用尾插法
        scanf("%d",&x);
    }
    return L;

}


//1.3.2尾插法-带头节点的单链表
bool ListInsertTail(LinkList &L,int x)
{
    LNode *p=L;
    if(p==NULL)//判断链表是否为空
        return false;
    while(p->next!=NULL)//找到最后一个节点
        p=p->next;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next = s;
    return true;
}

//1.3.2按位序插入-带头节点的单链表
bool ListInsert(LinkList &L,int i,int x)
{
    if(i<1)//防止输入不合法
        return false;
    LNode *p;
    int j=0;//当前s指向的点
    p = L;
    while(p!=NULL && j<i-1)//找到需要插入位置节点的前一个节点
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data = x;
    s->next = p->next;
    p->next=s;
    return true;
}

//1.3.3后插法-指定节点的后插
bool InsertNextNode(LNode *p,int x)
{
    if(p==NULL)
        return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    if(s==NULL)//内存分配失败
        return false;

    s->data = x;
    s->next = p->next;
    p->next = s;
    return true;
}

//1.3.4前插法-指定节点前插操作
/*
该方法于后插法一致，只是将数据进行交换
*/
bool InsertPriorNode(LNode *p,int x)
{
    if(p==NULL)
        return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));

    s->next = p->next;
    p->next = s;
    s->data = p->data;//新节点数据等于旧节点数据
    p->data = x;     //旧节点等于新值
    return true;
}
//---------五种插入法-----------完


//---------两种删除法-----------始
//1.4.1按位序删除
bool ListDelete(LinkList &L,int i)
{
    if(i<1)
        return false;
    LNode *p = L;
    int j=0;//当前p指向第几个节点
    while(p!=NULL && j<i-1)//找到需要删除节点的前一个节点
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *q = p->next;
    p->next = q->next;
    free(q);
    return true;
}

//1.4.2按节点删除
/*
让被删除节点的值为后一个节点的值，再删除后节点就可以了
*/
bool DeleteNode(LNode *p)
{
    if(p==NULL)
        return false;
    LNode *q = p->next;
    p->data = p->next->data;
    p->next = q->next;
    free(q);
    return true;
}
//---------两种删除法-----------完


//1.5遍历带头节点的列表
void PrintList(LinkList L)
{
    int i = 1;
    LNode *temp = L->next;
    while(temp != NULL)
    {
        printf("打印第%d个数： %d\n",i++,temp->data);//下移操作必须到后面，否则发生没有data的错误
        temp = temp->next;
    }
    return;
}

//1.6获取指定节点
LNode* GetNode(LinkList L)
{
    //获取第五个节点
    LNode *p = L;
    for(int i=0;i<5;i++)
        p=p->next;
    return p;
}

//----------查找----------
//1.7.1按位查找-带头节点的单链表
LNode *GetElem(LinkList L,int i)
{
    if(i<0)
        return NULL;
    LNode *p=L;
    int j=0;//当前p指向第几个节点
    while(p!=NULL && j<i)
    {
        p = p->next;
        j++;
    }
    return p;
}

//1.7.2按值查找-带头节点的单链表
LNode *LocateElem(LinkList L,int x)
{
    LNode *p = L->next;
    while(p!=NULL&&p->data!=x)
        p=p->next;
    return p;
}
//-------------------




//--------------------带头不带头分界线-------------------------------

//2、不带头节点的单链表

//2.1初始化不带头节点的单链表
bool InitList2(LinkList &L)
{
    L=NULL;
    return true;
}

//2.2判断不带头节点的单链表是否为空
bool Empty2(LinkList L)
{
    return (L==NULL);
}

//2.3按序插入-不带头节点的链表
bool ListInsert2(LinkList &L,int i,int x)
{
    if(i<1)
        return false;
    if(i==1)//第一个节点的操作和其他节点的操作有些不同
    {
        LNode *s = (LNode*)malloc(sizeof(LNode));
        s->data=x;
        s->next=L;
        L=s;
        return true;
    }
    LNode *p;
    int j=1;
    p=L;//p是第几个节点，插入的位置i最终比p的位序大1
    while(p!=NULL && j<i-1)
    {
        p=p->next;
        j++;
    }
    if(p==NULL)
        return false;
    LNode *s = (LNode*)malloc(sizeof(LNode));
    s->data=x;
    s->next=p->next;
    p->next=s;
    return true;
}

//2.5遍历不带头节点的列表
void PrintList2(LinkList L)
{
    int i = 1;
    LNode *temp = L;
    while(temp != NULL)
    {
        printf("打印第%d个数： %d\n",i++,temp->data);//下移操作必须到后面，否则发生没有data的错误
        temp = temp->next;
    }
    return;
}
Chaim998
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java算法篇-单链表反转详解.pptx.pptx
12-21
单链表的定义 单链表是一种线性数据结构，它包含一系列的节点，每个节点都含有一个值和指向下一个节点的引用。 单链表的特性 单链表具有动态性，可以灵活地插入和删除元素，但访问元素时需要从头节点开始顺序查找。 单链表的应用 单链表广泛应用于各种编程问题中，如实现栈、队列、双向队列等，以及在解决实际问题如浏览器历史记录、操作系统调度等方面。
python算法与数据结构之单链表的实现代码
12-31
=一、链表 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。 使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分
（图解）解析链表中的LinkList *L, LinkList L和LinkList &L，结构体指针和指向结构体指针的指针的区别
在夜里行走的博客
10-13 6612
解析LinkList L和LinkList *L，结构体指针和指向结构体指针的指针
Java中LinkList类的使用
running__camel的博客
02-22 1310
public class LinkListTest { public static void main(String[] args) { LinkedList linkedlist = new LinkedList(); //使用队列的方式添加队列的元素 linkedlist.offer("java"); linkedlist.
单链表基本操作
duanduan_l的博客
10-12 229
       为解决顺序表在插入，删除元素效率低的情况，引入单链表。单链表：使用引用将存储数据单元一次串联起来，避免了数组中用连续的内存存储元素的特点。在每个单元中有两个域，一个用于存储数据，一个用于指向下一个单元的引用。将这种具有一个数据域和多个指针域的存储单元成为节点。 public class MyLinkList&lt;T&gt; { class Entry{ ...
使用链表引出对引用传递的思考
CSDN1187178055的博客
02-09 916
使用链表引出对引用传递的思考
数据结构之链表（递归时函数引用调用对节点的作用）
zzzqs的博客
01-16 545
我们都知道c++中函数有&引用，今天学数据结构的链表时发现一个问题。链表是有数据域和指针域的，如果一个函数的参数包含链表节点，并且是引用调用的时候，对链表节点的修改会改变链表本身，这是肯定的，这是引用调用的作用。但是有一个问题我之前没有弄清楚，就是某一个链表节点lnode，肯定是有前驱节点的，前驱节点的next指针是指向当前这个lnode的首地址的，但是将lnode修改时，比如lnode = lnode->next，此时看似只是改变了lnode，其前驱节点的next指针好像还是指向原来的地址，
关于数据结构单链表的方法中的参数（LinkList L）和（LinkList &L）的区别
m0_57741101的博客
07-17 2451
数据结构
LinkList L 与LinkList &L（LNode* L ， LNode* &L）的区别
weixin_68540347的博客
01-16 505
LinkList L 与LinkList &L（LNode* L ， LNode* &L）的区别
关于链表中为什么函数参数是LinkList &L
qq_53348314的博客
05-17 268
如以上代码，包含三个函数，初始化链表InitList(LinkList &L)，头插法添加元素CreateListHead(LinkList &L)，和顺序输出元素coutList(LinkList L)，那为什么有的参数是LinkList &L，有的参数是LinkList L呢？，即使用malloc()函数，在内存开辟一块空间，并将地址也就是1002H给L，然后在这块空间里，存放结构体，而L本身是一个指针，也需要存放在内存里，而他的地址是1001H。可见，&(*L)=L。
数据结构单链表的基本操作
03-27
比较不错的一个实现单链表 基本操作 其中有初始化 输出 插入 删除 测长等一系列
单链表基本操作.pdf
04-01
单链表是线性数据结构的一种，由一系列的节点组成，每个节点至少包含两部分信息：元素的数据域和指向下一个节点的指针域。单链表的操作主要包括创建链表、插入节点、删除节点以及遍历链表等。下面我们将对单链表的...
单链表操作
06-15
我的基本数据结构系列讲解之单链表的源代码，讲解部分在我的技术博客http://blog.csdn.net/u011421608，谢谢支持！
LinkList
qq_43535213的博客
07-25 658
1
C++建立单向链表链表头指针需要使用指针类型的引用参数？
fashiontong的专栏
04-26 3423
 struct Node {int date; Node *next;}; void CreateList(Node *&head) //引用参数是表头指针 { s=new Node; cin>>s->data; while(s->data!=0) {if(head==NULL)head=s; else p->next=s; p=s; s=new Node; cin>>s->data;} p->next-NULL; delete s; return; }函数需要修改指针的内
数据结构-线性表
weixin_43761642的博客
10-08 533
线性表 1.顺序表 首先要明确顺序表并不是数组但可以用数组表示 我们用结构体来表示一个顺序表 typedef struct { int data[MaxSize]; int length; }sqList; 注意： 1.为什么要用引用类型？ 是因为在函数中都是对局部变量进行操作，如果不用引用的话只是对L的复制进行操作，函数体运行结束，形参也将被释放，在函数里对顺序表的操作则毫无意义。而用引用...
2021-07-05 倒置链表（Cpp/C）
qq_43515555的博客
07-05 1071
倒置链表 以下题目节选自educoder #include "linklist.h" // 引用库函数文件 namespace exa { //请在命名空间内编写代码，否则后果自负 link l; // 定义指针型变量 void Print(link l) // 算法Print，依次访问每个元素结点 { link P; // 定义指针型变量 ____________
7链表：如何轻松写出正确的链表代码
qq_35270493的博客
10-18 226
1、理解指针或引用的含义 1）含义：将某个变量（对象）赋值给指针（引用），实际上就是将这个变量（对象）的地址赋值给指针（引用）。 2）示例： p—>next = q; 表示p节点的后继指针存储了q节点的内存地址。 p—>next = p—>next—>next; 表示p节点的后继指针存储了p节点的下下个节点的内存地址。 2、警惕指针丢失和内存泄漏（单链表） 1）插入节点 在...
【初阶数据结构】带头双向循环链表讲解
最新发布
s1mplewo的博客
05-15 1228
本文详细讲解了带头双向循环链表的概念及具体实现源码
数据结构c语言单链表基本操作
10-20
单链表是一种常见的数据结构，它由一系列节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。C语言中实现单链表的基本操作包括：创建链表、插入节点、删除节点、查找节点、遍历链表等。其中，插入节点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值