简单链表

最新推荐文章于 2024-07-18 15:04:10 发布
最新推荐文章于 2024-07-18 15:04:10 发布
阅读量362 收藏 1
点赞数
分类专栏： C语言知识 文章标签： 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45815991/article/details/109038768
版权

简单链表介绍

抽象数据类型 (Abstract Data Type,ADT)

ADT就是一个抽象的数据类型，类型包括两类信息：属性和操作。 现在要定义一个新的类型

  1. 是要提供储存结构的方法。
  2. 是要提供操作数据的法。
    简单来说，就是 要自己去定义一个新的类型，而且要对这个类型写一些可以操作的函数。

表ADT

整表创建

随机产生n个元素
void CreateListHead(LinkList *L,int n)
{
    LinkList p;
    int i;
    srand(time(0));
    *L=(LinkList)malloc(sizeof(Node));
    (*L)->next=NULL;
    for(i=0;i<n;i++)
    {
        p=(ListList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        p->next=(*L)->next;
        (*L)->next=p;
    }
}

这里是头插法

顺序插入结点的步骤

随机产生n个元素
void CreateListHead(LinkList *L,int n)
{
    LinkList p,r;
    int i;
    srand(time(0));
    *L=(LinkList)malloc(sizeof(Node));
    r=*L;
    for(i=0;i<n;i++)
    {
        p = (ListList)malloc(sizeof(Node));
        p->data=rand()%100+1;
        r->next=p;
        r=p;
    }
    r->next=NULL;
}

删除链表中 data 为 m 的元素。

struct ListNode *deletem( struct ListNode *L, int m )
{
    struct ListNode* record,*a;
    a=L;
    while(a)
    {   
        if(a->data==m)
        {
            if(a==L)
                L=a->next;
            else
                record->next=a->next;
        }
        else
        {
            record=a;
        }
        a=a->next;
    }
    return L;
}

删除整表

void Clear(LinkList *L)
{
    LinkList p,q;
    p=(*L)->next;
    while(p)
    {
        q=p->next;
        free(p);
        p=q;
    }
    (*L)->next=NULL;
}

链表的接口函数

无头结点

结构定义：

typedef struct LNode *PtrToLNode;
struct LNode 
{
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

接口函数：

Position Find( List L, ElementType X ) ：返回线性表中首次出现X的位置。若找不到则返回ERROR；

List Insert( List L, ElementType X, Position P ) ：将X插入在位置P指向的结点之前，返回链表的表头。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回ERROR；

List Delete( List L, Position P ) ：将位置P的元素删除并返回链表的表头。若参数P指向非法位置，则打印“ Wrong Position for Deletion ”并返回ERROR。

Position Find( List L, ElementType X )
{
    List p=L;
    while(p&&p->Data!=X)
    {
        p=p->Next;
    }
    if(p!=NULL)
        return p;
    else
        return ERROR;
}
List Insert(List L,ElementType X,Position P)
{
   List temp,p;
   if(P==L)//如果要插向第一个结点之前
   {
      temp=(List)malloc(sizeof(struct LNode));
      temp->Data=X;
      temp->Next=L;//新结点的next指向现在的第一个结点，所以第一个结点现在变成了temp
      L=temp;
      return L;//返回第一个
   }
   temp=L;
   while(temp)
   {
      if(temp->Next==P)//如果下一个为P，即 要将新结点插入temp与P之间
      {
         p=(List)malloc(sizeof(struct LNode));
         p->Data=X;
         p->Next=temp->Next;//要插入的结点的next指向P
         temp->Next=p;//要插入的结点的前一个结点的next指向插入的结点
         return L;
      }
      temp=temp->Next;
   }
   printf("Wrong Position for Insertion\n");
   return ERROR;
}
List Delete(List L,Position P)
{
   List p=L;
   if(P==L)
   {
      L=L->Next;
      return L;
   }
   while(p)
   {
      if(p->Next==P)
      {
         p->Next=P->Next;
         free(P);
         return L;
      }
      p=p->Next;
   }
   printf("Wrong Position for Deletion\n");
   return ERROR;
}

有头结点

结构定义：

typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

接口函数

List MakeEmpty() ：创建并返回一个空的线性表；

Position Find( List L, ElementType X ) ：返回线性表中X的位置。若找不到则返回ERROR；

bool Insert( List L, ElementType X, Position P ) ：将X插入在位置P指向的结点之前，返回true。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回false；

bool Delete( List L, Position P ) ：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“ Wrong Position for Deletion ”并返回false。

List MakeEmpty()
{
    List head=(List)malloc(sizeof(struct LNode));
    head->Data=0;
    head->Next=NULL;//头指针指向空
    return head;
}
Position Find( List L, ElementType X )
{
    List F=L;
    while(F)//每个头结点判断，直到其为空
    {
        if(F->Data==X)
        {
            return F;//如果找到返回F的位置
        }
        F=F->Next;
    }
    return ERROR;//F为空也没有找到，就返回ERROR
}
bool Insert( List L, ElementType X, Position P )
{
    List F=L;
    while(F)
    {
        if(F->Next==P)//这时F是P的前一个结点
        {
            List p=(List)malloc(sizeof(struct LNode));
            p->Data=X;
            p->Next=P;//P的Next指向P
            F->Next=p;//F的Next指向p
            return true;
        }
        F=F->Next;
    }
    printf("Wrong Position for Insertion\n");
    return false;//如果没有找到就返回
}
bool Delete( List L, Position P )
{
    List F=L;
    if(!P)//要删的如果是空
    {
        printf("Wrong Position for Deletion\n");
        return false;
    }
    while(F)
    {
        if(F->Next==P)找到P，F为其前一个结点
        {
            F->Next=P->Next;//F的Next指针指向P的Next
            free(P);//释放P
            return true;
        }
        F=F->Next;
    }
    printf("Wrong Position for Deletion\n");
    return false;//没找到返回
}

可以看到每一个函数都用到了 while(F) 这样的形式来判断循环，但是要注意的是，如果判断到 NLULL 会跳出，不要在循环体外再用 F->Next 如果 F 已经为空，那么 F->Next 会出现段错误，找不到这个地址。

顺序表

结构定义：

typedef int Position;
typedef struct LNode *List;
struct LNode 
{
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

接口函数：

List MakeEmpty() ：创建并返回一个空的线性表；

Position Find( List L, ElementType X ) ：返回线性表中X的位置。若找不到则返回ERROR；

bool Insert( List L, ElementType X, Position P ) ：将X插入在位置P并返回true。若空间已满，则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ ILLEGAL POSITION ”并返回false；

bool Delete( List L, Position P ) ：将位置P的元素删除并返回true。若参数P指向非法位置，则打印“ POSITION P EMPTY ”（其中P是参数值）并返回false。

bool Insert( List L, ElementType X, Position P )                               
{   
    if(L->Last+1==MAXSIZE)                                                     
    {   
        printf("FULL");                                                        
        return false;                                                          
    }
    if(P>L->Last+1||P<0)                                                       
    {   
        printf("ILLEGAL POSITION");                                            
        return false;                                                          
    }
    for(int i=L->Last;i>=P;i--)                                                
    {   
        L->Data[i+1]=L->Data[i];                                               
    }
    L->Data[P]=X;                                                              
    L->Last++;
    return true;                                                               
}
bool Delete( List L, Position P )                                              
{   
    if(P>L->Last||P<0)                                                         
    {   
        printf("POSITION %d EMPTY",P);                                         
        return false;                                                          
    }
    for(int i=P;i<=L->Last;i++)                                                
    {   
        L->Data[i]=L->Data[i+1];                                               
    }
    L->Last--;
    return true;                                                               
}                            
List MakeEmpty()
{
    List head=(List)malloc(sizeof(struct LNode));
    head->Last=-1;
    return head;
}
Position Find( List L, ElementType X )
{
    for(int i=0;i<=L->Last;i++)
    {
        if(L->Data[i]==X)                                                      
            return i;
    }
    return ERROR;
}

静态链表

原理

因为不是所有语言都有指针，所以 可以用数组的形式来模拟指针。叫游标实现。

  1. 数组下标为0，也就是第一个元素。这其中有一个值来记录一个空位。
  2. 数组的最后一个元素中的一个值记录最初的那个插入元素的位置。它就相当于头指针。

所以初始是这样

结构定义

#define MAXSIZE 1000
typedef struct 
{
    ElemType data;
    int cur;
}Component,StaticLinkList[MAXSIZE];

接口定义

//初始化
Status InitList(StaticLinkList space)
{
    int i;
    for(i=0;i<MAXSIZE-1;i++)
    {
        space[i].cur=i+1;
    }
    space[i].cur=0;
    reutrn OK;
}
//找到空闲区
int Malloc_SLL(StaticLinkList space)
{
    int i=space[0].cur;//找到原先的空闲位置
    if(space[0].cur)
        space[0].cur=space[i].cur;//这个空闲要被用了，请把这个空闲的下一个给 的第0个元素的cur，以标志着它成为了第一个空闲。

    return i;//返回这个空闲的位置
}
//在L中第i个元素之前插入元素e
Status ListInsert(StaticLinkList L,int i,Elemtype e)
{
    int j,k,l;
    k=MAXSZIE-1;
    if(i<L||i>ListLength(L)+1)
        return ERROR;
    j=MALLOC_SLL(L);//获得空闲下标
    if(j)
    {
        L[j].data=e;
        for(l=1;l<=i-1;i++)/*找到第i个元素之前的位置，第一个元素就是0，第二个元素就是1。k本身记录1的位置。循环一次得到第二个元素，循环两次是第三个元素，以此类推。*/
            k=L[k].cur;//遍历
        L[j].cur=L[k].cur;//新元素的下一个是第i个元素
        L[k].cur=j;//第i个元素之前的元素的下一个是新元素
        return OK;
    }
    return ERROR;
}

将丙插入后就是这样


用上面的代码解释就是，要将丙插入第三个位置之前，先找到空闲位置赋值丙，循环两次找到乙，把乙的下一个位置给空闲的下一个位置，空闲位置给乙的下一个位置。

删除

Status ListDelete(StaticLinkList L,int i)
{
    int j,k;
    if(i<1||i>ListLength(L))
        return ERROR;
    k=MAXSIZE-1;
    for(j=1;j<=i-1;j++>)
        k=L[k].cur;//找到前一个
    j=L[k].cur;//找到要删的
    L[k].cur=L[j].cur;//将要删的下一个给前一个的下一个
    Free_SSL(L,j);
    return OK:
}
void Free_SSL(StaticLinkList space,int k)
{
    space[k].cur=space[0].cur;//k的下一个为空闲位置
    space[0].cur=k;//k作为新的空闲位置
}
CCPigSnail
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
习题11-8 单链表结点删除 （20 分）
Fhever的博客
04-13 669
和习题11-7一样的思路，不过这样做的话被删掉的结点还存在内存里。。。 与其说是删除，更确切地说是跳过(捂脸) struct ListNode *deletem( struct ListNode *L, int m ) { struct ListNode *p=NULL, *q=NULL,*head=L; for(q,p=L;p;q=p,p=p->next){ ...
链表简单操作
Yanpr919的博客
02-26 188
面试题 02.06. 回文链表 难度简单50 编写一个函数，检查输入的链表是否是回文的。 示例 1： 输入： 1->2 输出： false 示例 2： 输入： 1->2->2->1 输出： true 进阶： 你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？ 这里关键难点在于O（1）的空间复杂度，为此采用将原链表的后半部分反转，并依次比较的操作实现。首先通过快慢指针的方法找到链表的中间节点half_node，对于链表长度N为偶数时，...
链表基础1（超简单）--创建一个长度为n的单链表
玫瑰花店的博客
10-30 9622
首先我们来了解一下什么是链表？ 通俗的来说链表就是一种链式存储结构，大家可以抽象理解一下把他想象成一个铁链，铁链不是由一个个铁环，环环相扣组成的嘛！那么每个铁环就可以叫做一个节点，如果我们再在每个铁环上面系上两个个小盒子，那么这两个小盒子一个叫做数据域就是存放每个节点数据的地方一个叫做指针域这个就是存放下一个节点（铁环）地址的地方。可能这样说还有点抽象，直接上图。 这就是链表里面一个节点的样子，下面我们给多个节点串起来形成链表！ 我给每个节点的地址设为A,B,C。注意看第一个节点的指针域存放的是第二个节
从零开始的CPP（20）——创建链表，输出链表，删除链表
最新发布
m0_69248655的博客
07-18 144
在C++中，如果两个指针指向同一个对象（在此上下文中，是链表中的节点），改变通过一个指针所进行的操作会影响到另一个指针看到的内容，因为它们实际上是共享同一块内存的。prev=prev->next/prev=curr只对指针移位，不改变链表。通过影响指针的指向（prev->next)，就可以改变链表的内容。prev->next=curr改变了指针指向，所以会改变链表。，请你删除链表中所有满足。给出了创建节点的两种方法。给你一个链表的头节点。
数据结构之线性表（1-3）——单链表（不带头节点）的基本操作
kunkunTalk
07-08 713
1 结构定义 typedef struct LNode *PtrToLNode; struct LNode { ElementType Data; PtrToLNode Next; }; typedef PtrToLNode Position; typedef PtrToLNode List; 2 函数接口 Position Find( List L, ElementType X ); List Insert( List L, ElementType X, Position P ); List Delete
链式表操作集 (20分)
weixin_44044816的博客
12-21 1834
链式表操作集 (20分) 本题要求实现链式表的操作集。 函数接口定义： Position Find( List L, ElementType X ); List Insert( List L, ElementType X, Position P ); List Delete( List L, Position P ); 其中List结构定义如下： typedef struct LNode *Pt...
不懂你打我，超简单的单链表的创建
李洙赫的博客
05-12 4770
不懂你打我！！！超简单的单链表的创建
链表简单实现
u013967394的博客
02-08 330
链表简单实现 ```java class Node<T>{ T name; public Node(T name, Node next, Node previdous) { this.name = name; this.next = next; this.previdous = previdous; } ...
C#实现的简单链表类实例
09-03
总结来说，这个C#实现的简单链表类`MyLinkedList`通过`Node`类模拟链式存储，并提供了基本的增删操作。虽然它只覆盖了链表操作的基础部分，但它展示了C#如何使用对象和引用来构建和管理链表数据结构。对于理解和实践...
使用C语言实现简单链表.docx
12-20
下面是使用C语言实现简单链表的知识点： 一、链表的定义 链表是一种动态的数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表的优点是可以动态地增加或删除节点，且可以实现插入、删除和...
简单链表类
06-30
"简单链表类"是一个为编程初学者设计的示例，帮助他们理解和运用链表的基本操作。这个例子在Visual Studio 2012环境下编译通过，同时也兼容较老版本的VC6.0。 链表的核心概念是由节点组成的序列，每个节点包含数据...
FindPosition 特征码定位工具
03-30
FindPosition 特征码定位工具F
CPP实现单链表
Bananas_3的博客
01-09 565
使用CPP实现单链表,这是我的简单复习与实践
数据结构与算法学习cpp（一）：链表
TFY9297的博客
08-05 1574
数据结构与算法之美学习笔记（一）1、链表1.1 哨兵节点不带头链表操作：带头链表操作：欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 1、链表 1.1 哨兵节点 带头链表中，不存储任何数据的头
数据结构之树（二）
qq_39220334的博客
07-21 124
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Markdown编辑器 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Mar
链式表操作集
海马有力量的博客
04-06 383
本题要求实现链式表的操作集。 函数接口定义： Position Find( List L, ElementType X ); List Insert( List L, ElementType X, Position P ); List Delete( List L, Position P ); 其中List结构定义如下： typedef struct LNode *PtrToLNode; stru...
mysql position,find_in_set ,location,instr 区别
muzizhuben的专栏
11-05 4757
表A   字段b 查询表
谈一谈MySQL的LOCATE、FIND_IN_SET、INSTR、POSITION的差别
热门推荐
森森
06-23 1万+
1、LOCATE(substr,str) , LOCATE(substr,str,pos)  第一个语法返回字符串 str中子字符串substr的第一个出现位置。第二个语法返回字符串 str中子字符串substr的第一个出现位置, 起始位置在pos。如若substr 不在str中，则返回值为0。 SELECT LOCATE("a","A") locate;-- 注意:该函数不区分大小写
mysql locate in_MySQL高效模糊搜索之内置函数locate instr position find_in_set使用详解
weixin_42505252的博客
01-26 449
MySQL高效模糊搜索之内置函数locate instr position find_in_set使用详解发布时间：2020-09-10 09:07:56来源：脚本之家阅读：152作者：wdc常用的一共有4个方法，如下：1.使用locate()方法普通用法：SELECT`column`from`table`wherelocate('keyword',`condition`)>0类似于java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CCPigSnail

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值