数据结构基础3_带头结点的单链表

最新推荐文章于 2024-01-23 19:45:11 发布
最新推荐文章于 2024-01-23 19:45:11 发布
阅读量506 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/lifestylegoingon/article/details/49097051
本文介绍了一个简单的单链表数据结构及其基本操作的实现方法，包括初始化、插入、删除等，并通过合并两个有序链表来展示这些操作的实际应用。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
typedef int ElemType;
typedef int Status;
#define true 1
#define false 0
typedef struct Lnode{
        ElemType data;
        struct Lnode *next;
        }*link,*Position;
typedef struct{
        link head,tail;
        int len;
        }linklist;
        Status Makenode(link &p,ElemType e)
        {
               p=(link)malloc(sizeof(Lnode));
               if(!p)
               {
                     return false;
                     }
                     p->data=e;
                     return true;
                     }
         void Freenode(link &p)
         {
              free(p);
              p=NULL;
              }
          Status Initlist(linklist &L)
          {
             link p;
             p=(link)malloc(sizeof(Lnode));
             if(!p)
             {
                   return false;
                   }
                   p->next=NULL;
                   L.head=L.tail=p;
                   L.len=0;
                   return true;
                   }
            Status Clearlist(linklist &L)
            {
                   link p,q;
                   p=L.head->next;
                   L.head->next=NULL;
                   while(p!=NULL)
                   {
                                 q=p->next;
                                 free(p);
                                 p=q;
                                 }
                                 L.tail=L.head;
                                 L.len=0;
                                 return true;
                                 }                           
             Status Destorylist(linklist &L)
             {
                Clearlist(L);
                free(L.head);
                L.head=L.tail=NULL;
                L.len=0;
                return true;
                }
                Status Insfirst(linklist &L,link h,link s)
                {
                       h=L.head;
                    s->next=h->next;
                    h->next=s;
                    
                    L.len++;
                    return true;
                    }
                Status Delfirst(linklist &L,link h,link q)
                {
                        h=L.head;
                       if(h->next==NULL)
                       {
                                       return false;
                                       }
                                       q=h->next;
                                       h->next=q->next;
                                       free(q);
                                       L.len--;
                                       return true;
                                       }
                Status Append(linklist &L,link s)
                {
                   int n=1;
                  link p;
                  p=L.head;
               while(p->next!=NULL)
{
                  p=p->next;
}
                   p->next=s;
                   while(s->next!=NULL)
                   {
                       s=s->next;
                       n++;
                       }
                       L.tail=s;
                       L.len+=n;
                       }
                 Status Remove(linklist &L,link &q)
                 {
                        link p;
                        p=L.head;
                        if(L.head==L.tail)
                        {
                                          return false;
                                          }
                         q=L.head;
                         while(q->next!=NULL)
{
                              q=q->next;
}
                         while(p->next!=q)
                         {
                              p=p->next;
                              }
                              p->next=q->next;
                              L.tail=p;
                              L.len--;
                              return true;
                              }
                 Status Insbefore(linklist &L,link &p,link s)
                 {
                     link q=L.head;
                     while(q->next!=p)
                     {
                         q=q->next;
                         }
                         s->next=q->next;
                         q->next=s;
                         p=s;
                         L.len++;
                         return true;
                         }
                 Status Insafter(linklist &L,link &p,link s)
                 {
                        s->next=p->next;
                        p->next=s;
                        if(p==L.tail)
                        {
                                     L.tail=s;
                                     }
                        p=s;
                        L.len++;
                        return true;
                        }
                 Status Setcurelem(link &p,ElemType e)
                 {
                   p->data=e;
                   return true;
                   }
                   ElemType Getcurelem(link p)
                   {
                            return p->data;
                            return true;
                            }
                   Status Listempty(linklist L)
                   {
                          if(L.head->next==NULL)
                          {
                                                return true;
                                                }
                                                else
                                                {
                                                    return false;
                                                    }
                                                    }
                  int Listlength(linklist &L)
                  {
                    return L.len;
                    }
                  Position Gethead(linklist L)
                  {
                    return L.head;
                    }
                    Position Getlast(linklist L)
                    {
                             return L.tail;
                             }
                   Position priorpos(linklist L,link p)
                   {
                            link pre=L.head;
                            while(pre->next!=p)
                            {
                                   pre=pre->next;
                                   }
                            if(L.head==pre)
                            {
                               return NULL;
                               }
                               return pre;
                               }
                   Position Nextpos(linklist L,link p)
                   {
                         /*
                           if(L.tail==p)
                           {
                                       return NULL;
                                       }*/
                                       return p->next;
                                       }
                  Status Locatepos(linklist L,int i,link &p)
                  {
                         if(i<0||i>L.len)
                         {
                                         return false;
                                         }
                       p=L.head;
                       while(i!=0)
                       {
                                  i--;
                                  p=p->next;
                                  }
                                  
                                  return 1;
                                  }
                     int compare(ElemType e1,ElemType e2)
                     {
                         if(e1>e2)
                         {
                                  return 1;
                                  }
                                  if(e1==e2)
                                  {
                                            return 0;
                                            }
                                            else
                                            {
                                                return -1;
                                                }
                                                }
                                  
                  Position Locateelem(linklist L,ElemType e,Status compare(ElemType,ElemType))
                  {
                           int j;
                           link p;
                           p=L.head->next;
                           for(int i=0;i<L.len;i++)
                           {
                                   if(compare(e,p->data)==0)
                                   {
                                       return p;
                                       }
                                       p=p->next;
                                       }
                                       return NULL;
                                       }
                                       Status visit(link p)
                                       {
                                            printf("%d",p->data);
                                            }
                 Status Listtraverse(linklist &L,Status visit(link p))
                 {
                     link p=L.head->next;
                     while(p!=NULL)
                     {
                                         visit(p);
                                         p=p->next;
                                         }
                                         return true;
                                         }
                 Status Listinsert(linklist &L,int i,ElemType e)
                 {
                        link h,s;
                        if(!Locatepos(L,i-1,h))
                        {
                                               return false;
                                               }
                        if(!Makenode(s,e))
                        {
                           return false;
                           }
                        if(h==L.tail)
{
L.tail=s;
}
                        Insfirst(L,h,s);
                        return true;
                        }
                        
                  void mergelist(linklist &La,linklist &Lb,linklist &Lc)
                  {
                         link pa,pb,pc;
                               pa=La.head->next;
     pb=Lb.head->next;
     Lc.head=pc=La.head;
     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;
                        }
                        }
                        if(pa==NULL)
                      {
                         pc->next=pb;
                       }
                        else
                         {
                        pc->next=pa;
                           }
                        
                        }                                          
                                                                             
                       
                    
             
#include<stdio.h>
#include<stdlib.h>
int main()
{
    linklist La;
	Initlist(La);
	Listinsert(La,1,7);
	Listinsert(La, 2, 5);
	Listinsert(La, 3, 2);
	Listinsert(La, 4, 1);
	
	linklist lb;
    Initlist(lb);
	Listinsert(lb,1,39);
	Listinsert(lb,2,19);
	Listinsert(lb,3,9);
	Listinsert(lb,4,3);
	/*
	link h,q,k;
	 
	Delfirst(La,h,q); 
	
	Remove(La,k);*/
	linklist lc;
	mergelist(La,lb,lc);
	Listtraverse(lc,visit);
	printf("\n");
	system("pause");
}


数据结构————倒置带头结点单链表操作讲解
m0_64985004的博客
04-03 2824
我们先来实现带头单链表的基本操作： 头文件： #include<stdio.h> #include<assert.h> #include<stdlib.h> typedef int ElemType; typedef struct LNode{ ElemType data; struct LNode*next; }LT,*link; void InitList(Link phead);//初始化 void InsertListfront(Link p
复习之数据结构_带头结点的单链表
YY_Song 's blogs
02-03 692
带头结点的单链表带头结点的单链表插入图解头文件(.h)代码文件(.cpp)简单测试参考资料 带头结点的单链表 如果说，顺序表是逻辑相邻，物理也相邻的话，那么链表就是逻辑相邻，物理不一定相邻了。对应在计算机中，顺序表，是开创了一块连续的内存空间，用于存放一定的数据。那么链表开辟的内存空间就不一定是连续的、同一块空间了。 顺序表（不定长）示意图： 单链表（带头结点）示意图： 插入图解 对于插入来说，假定：要插入位置的结点为p；插入新的结点为n。那么到底是先p->next = n->next呢
数据结构 带头结点的单链表 操作大全 最全的链表操作（c++实现）
09-27
1800多行代码 22个功能 最全的链表操作 如需转载请注明出处 我的博文：http://blog.youkuaiyun.com/u012350104 欢迎交流 讲解代码中函数的ppt：http://download.youkuaiyun.com/detail/u012350104/9143181 Made By Fred韩
【C语言】数据结构C语言版 实验3 带头结点的单链表
点滴记忆
12-09 5213
slnklist.h #include <stdio.h> #include <stdlib.h> /**************************************/ /* 链表实现的头文件，文件名slnklist.h */ /**************************************/ typedef int datatype...
数据结构实验报告（三）——带头结点的单链表
future_dreaming的博客
01-10 959
带头结点的单链表打印输出、删除奇数、有序表的插入，两降序表合并成升序表等系列操作
实验三 带头节点的单链表
逝不等琴生的博客
12-06 3026
前言 熟练掌握带头节点的单链表的相关操作， 头文件 #include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; /**************************************/ /* 链表实现的头文件，文件名slnklist2.h */ /**************************************/ typedef int...
数据结构实验三之单链表.
TJYYYM的博客
05-01 552
2..建立一个由n个学生成绩的顺序表，实现对数据的插入，删除，查找等操作。源代码：#ifndef Student_H#define Student_Htemplate&lt;class DataType&gt;struct Node{ DataType data; Node&lt;DataType&gt;*next;};template&lt;class DataType&gt;class Stu...
数据结构-单链表-实验报告.rar_C++_tripk8z_单链表_单链表实验_实验报告
09-21
1.实验目的及要求 1.1实验目的： （1）掌握线性表的顺序存储结构； （2）验证单链表及其基本操作的实现；...（1）用头插法（或尾插法）建立带头结点的单链表； （2）对已建立的单链表实现插入、删除、查找等基本操作。
带头结点单链表 和 不带头结点单链表的区别
热门推荐
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
11-12 1万+
文章目录不带头结点的操作代码①代码②代码③代码④带头结点的操作代码⑤ 下面的代码中，传递链表时，传的是头指针。如果是带头结点的链表，传递链表时，可以传头结点，具体可以看看 C语言实现-线性表的链式存储(单链表) 带头结点单链表 和 不带头结点单链表的区别： 带头结点单链表，在进行插入、删除操作时，不需要改变链表头指针。 不带头结点的单链表，在进行插入、删除操作时，可能会涉及到链表头指针的修改（所以链表作为参数传递时，传递的是头指针的引用，具体可看代码④中head_insert方法中的指针变量带了
数据结构三：线性表之单链表(带头结点单链表设计)的设计
最新发布
weixin_47040031的博客
01-23 1784
线性表的链式存储结构正是所谓的单链表，何谓单链表？通过地址将每一个数据元素串起来，进行使用，这可以弥补顺序表在进行任意位置的插入和删除需要进行大量的数据元素移动的缺点，只需要修改指针的指向即可；单链表的种类又可划分为很多种，本篇博客详细介绍带头结点单链表的设计与实现，掌握单链表的关键是要进行画图分析；单链表同时也是笔试和面试的必考点，因此，掌握好该章节非常重要！
带头结点的单向链表的基本操作的实验代码和实验报告
04-14
使用给定数据结构，实现带头结点的单向链表的创建、删除链表、插入结点等操作，每个学生的学号互不相同，学号不同而姓名相同则为不同的学生，每个学生的学号在合并后的链表中不重复，如果出现重复，则删除年龄较小结点。最后打印输出合并后的链表元素，验证结果的正确性。
《数据结构》实验三：单链表
Wayne_Xiaowei的博客
05-05 1160
《数据结构》实验三：                 线性表综合实验 一．实验目的      巩固线性表的数据结构的存储方法和相关操作，学会针对具体应用，使用线性表的相 关知识来解决具体问题。 二．实验时间    准备时间为第 7 周到第 8 周，具体集中实验时间为第 4 周第 2 次课。2 个学时。 三．实验内容 1.建立一个由 n 个学生成绩的顺序表，n 的大小由自己确定，每一个学生的成绩信息...
数据结构基础篇-------2. 单链表的创建及运算
LFQ_516的博客
10-23 548
/* * 单链表的创建及其运算 * 2018.10.23 * @L.F * * */ #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; typedef int DataType_t;//结点的数据类型为DataType_t,这里是Int型 typedef struct Node ...
实验3-带头结点的单链表
weixin_30502157的博客
11-03 2901
实验1： 1 /*编写函数void delx(linklist head, datatype x)，删除带头结点单链表head中第一个值为x 的结点。 2 并构造测试用例进行测试。 3 */ 4 /**********************************/ 5 /*文件名称：lab3_01.c */ 6 /**********...
菜鸟之路--线性表__链表实现
weixin_34270606的博客
07-10 121
//好久没发博客了。今天来水上一发。以后要勤劳耕作！！！！！。！！！！！！ //在使用指针的时候。要注意指针的维护。。。。。  /* 文件link.h 链表的头文件,定义了链表的存储结构。以及操作方法 */ #ifndef LINK_L #define LINk_L 0 #define OK 1 #define FALSE 0 #define ERROR -1 typed...
5.数据结构 线性表_增加指向头结点和最后一个结点的指针的结构的单链表
打工人的博客
10-21 685
typedef struct LNode { ElemType data; LNode *next; }*Link,*Position; struct LinkList { Link head, tail;//分别指向线性链表中的头结点和最后一个结点 int len;//指示线性链表中数据元素的个数 }; void MakeNode(Link &p, ElemType &e) { //分配由p指向的值为e的结点。若分配失败，则退出 p = (Link)malloc(sizeo.
C语言实现常用数据结构：带头结点的单链表（第3篇）
qq_43351159的博客
08-06 2752
单链表 单链表使用指针来保存线性表数据元素的关系。 实现要点： 1.使用指针来指向下一个数据元素。 2.单链表分为带头结点的单链表、不带头结点的单链表。 3.使用带头结点的单链表不需要对空表进行特殊处理，简化操作。 优缺点和适用场景： 适用于进行大量插入、删除操作的场景，不具备随机存取的特性，访问数据必须循环遍历。 使用示例 功能：输入数据个数和数据，逆序保存到顺序表，并逆序输出显示到屏幕。 运行结果如下： 请输入数据总个数:10 请依次输入10个整数:0 1 2 3 4 5 6 7 8 9 单链表输出结果
数据结构实验3、单链表的基本操作实现
Scarlett的博客
11-06 5921
实验三： 作者说： 写的如果有不太好的地方，欢迎大佬指点！ 一、运行效果截图 二、实验要求 实验3、单链表的基本操作实现 （1）实验目的 通过该实验，深入理解链表的逻辑结构、物理结构等概念，掌握链表基本操作的编程实现，熟练掌握C语言中指针的操作。和实验3对比，掌握线性结构两种不同存储方式的区别。 （2）实验内容 编程实现链表下教材第二章定义的线性表的基本操作，最好用菜单形式对应各个操作，使其编程一个完整的小软件。注意，每个功能模块一定要考虑非法的情况，并作出相应的提示，例如：求前驱，要
详解带头结点单链表的数据结构实现
资源摘要信息:"带头结点单链表.zip" 在计算机科学与技术领域，数据结构是用于存储和组织数据的一种方式，它提供了高效访问和修改数据的手段。单链表是一种常见的线性数据结构，它由一系列节点组成，每个节点包含...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值