带头结点的线性链表的实现

最新推荐文章于 2022-04-20 23:15:32 发布
最新推荐文章于 2022-04-20 23:15:32 发布
阅读量1.1k 收藏 3
点赞数
分类专栏： C语言编程
/*========带头节点的线性链表类型=========*/
typedef  char  ElemType
 
//结点类型
typedef  struct  LNode
{
     char  data;
     struct  LNode *next;
}*Link,*Position;
 
//链表类型
typedef  struct
{
     Link head,tail;
     int  len;
}LinkList;
 
 
/*======================================================*/
/*=======一些在其他函数定义中会调用的函数===============*/
/*======================================================*/
 
/*---compare---比较两个元素的大小关系*/
int  Compare( char  a, char  b)
{ 
     return  a-b;
}
 
/*---visit---*/
int  Visit(Link p)
{
     if (...)
         return  1;
     else
         return  0;
     
}
 
/*---length---求链的长度*/
int  Length(Link s)
{
     int  i=0;
     Link p=NULL;
     p=s;
     while (p->next!=NULL)
     {
         p=p->next;
         i++;
     }
     return  i;
}
 
/*---print---在屏幕上输出链表的所有元素*/
void  Print(LinkList L)
{    
     Link p=NULL;
     p=L.head;
     if (!p->next)
     {
         printf ( "\nThe LinkList is empty.\n\n" );
         return  ;
     }
     printf ( "The List:" );
     while (p)
     {
         printf ( "%c-" ,p->data);
         p=p->next;
     }
}
 
/*======================================================*/
/*==========对带头结点的单链线性表进行操作的函数的定义==*/
/*======================================================*/
 
/*---分配由p指向的结点并赋值为e---*/
Position MakeNode(ElemType e)
{      
     Link p=NULL;
     p=(Link) malloc ( sizeof ( struct  LNode));
     if (p)
     {
         p->data=e;
         p->next=NULL;
     }
     else  return ;
     return  p;
}
 
/*---释放p所指向的结点-*/
void  FreeNode(Link p)
{         
     free (p);
}
 
 
带头结点的线性链表的实现
/*---构造一个由L指向的空的线性表-*/
void  InitList(LinkList *L)
{     
     L->head=MakeNode( 'L' ); //生成头结点
     L->head->next=NULL; /*不是l->head=NULL*/
     L->tail=L->head;
     L->len=0;
}
 
/*----------销毁由L指向的线性表---------*/
void  DestroyList(LinkList *L)
{  
     Link p;
     p=(*L).tail;
     while (p!=(*L).head)
     {
         p=PriorPos(*L,p);
         FreeNode(p->next);
     }
     FreeNode((*L).head);
}
 
/*将线性表L置为空表，并释放原链表的头结点*/
void  ClearList(LinkList *L)
{    
     Link p;
     p=(*L).tail;
     while (p!=(*L).head)
     {
         p=PriorPos(*L,p);
         FreeNode(p->next);
     }
     FreeNode((*L).head);
}
 
/*---将s指向的结点插入线性链表的第一个结点之前-*/
void  InsFirst(LinkList *L,Link s)
{   
     s->next=L->head->next;
     if (!L->head->next)
         L->tail=s;       /*当向一个空的线性表执行该操作时*/
     L->head->next=s;
     L->len++;
}
 
/*---删除表中第一个结点并以q返回-*/
void  DelFirst(LinkList *L,Link q)
{   
     if (!L->head->next)
     {
         printf ( "\nThe LinkList is empty,can not delete..\n" );
         return  0;
     }
     q=L->head->next;
     L->head->next=L->head->next->next;
}
 
/*---将指针s所的一串结点链接在线性表L的最后一个结点-*/
void  Append(LinkList *L,Link s)
{ 
     Link q;
     q=L->head;
     if (!L->tail)
     { /*考虑到链表为空的情况*/
         L->head->next=s;
         while (q->next)
             q=q->next; /*尾结点的处理*/
         L->tail=q;
     }
     L->tail->next=q=s;
     while (q->next)
         q=q->next; /*不能忘了对尾结点的处理*/
     L->tail=q;
     L->len+=Length(s);
}
 
/*---删除线性表l中的尾结点-*/
void  Remove(LinkList *L,Link q)
{  
     if (!L->tail)
     {
         printf ( "\nthe LinkList is empty,can not remonde..\n" );
         return  0;
     }
     q=L->tail;                     
     L->tail=PriorPos(*L,q);
     L->tail->next=NULL;
}
 
/*---将s所指向结点插入在p所指结点之前-*/
void  InsBefore(LinkList *L,Link p,Link s)
{  
     Link q;
     q=PriorPos(*L,p);
     s->next=p;
     q->next=s;
}
 
/*---将s所指向结点插入在p所指结点之后-*/
void  InsAfter(LinkList *L,Link p,Link s)
{   
     s->next=p->next;
     p->next=s;
}
 
/*---用e更新p所指向的当前结点-*/
void  SetCurElem(Link p,ElemType e)
{        
     p->data=e;
}
 
/*---返回p所指结点中元素的值-*/
ElemType GetCurElem(Link p)
{       
     return  p->data;
}
 
 
int  Listempty(LinkList L)
{         /*---若线性表为空表则返回1，否则返回0-*/
     if (L.head==L.tail)
         return  1;
     return  0;
}
 
 
int  Listlength(LinkList L)
{      /*---返回线性表中元素个数-*/
     return  L.len;
}
 
 
Position GetHead(LinkList L)
{     /*---返回线性表l中头结点的位置-*/
     return  L.head;
}
 
 
Position GetLast(LinkList L)
{      /*-----返回线性表l中最后一个结点的位置-------*/
     return  L.tail;
}
 
 
/*---返回p所指结点的直接前驱的位置-*/
Position PriorPos(LinkList L,Link p)
{   
     Link q;
     q=L.head;
     if (q->next==p)
         return  0;
     while (q->next!=p)  
         q=q->next;
     return  q;
}
 
/*-----返回p所指结点的直接后继的位置-------*/
Position NextPos(Link p)
{    
     Link q;
     q=p->next;
     return  q;
}
 
/*-----用p返回线性表l中第i个结点的位置，并返回ok-------*/
void  LocatePos(LinkList L, int  i,Link p)
{   
     p=L.head;
     if (i<=0||i>Listlength(L))  
         return  0;
     while (i)
     {
         p=p->next;
         i--;
     }
}
 
/*----返回表中第一个与e满足一定函数关系的结点次序位置----*/
int  LocatElem(LinkList L,ElemType e)
{    
     int  i=0;
     Link p;
     p=L.head->next;
     while (compare(p->data,e)&&p)
     {
         p=p->next;
         ++i;
     }
     if (!p)
     { /*考虑到查找不到指定元素的情况*/
         printf ( "\nthere's no '%c' in this LinkList." ,e);
         return  0;
     }
     return  i;
}
 
/*----用一个函数遍历表中所有结点-------*/
void  ListTraverse(LinkList L)
{        
     Link p;
     p=L.head;
     while (!visit(p)) 
         p=p->next;  

}

应用：将单链线性表La和Lb的元素按值非递减排列

Status MergeList_L(NLinkList &La, NLinkList &Lb, NLinkList &Lc,
                    int  (*compare)(ElemType, ElemType))
{ 
     // 算法2.21
     // 已知单链线性表La和Lb的元素按值非递减排列。
     // 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列。
     NLink ha, hb;
     Position pa, pb, q;
     ElemType a, b;
     if  (!InitList(Lc))
         return  ERROR;  // 存储空间分配失败
     ha = GetHead(La);      // ha和hb分别指向La和Lb的头结点
     hb = GetHead(Lb);
     pa = NextPos(La, ha);  // pa和pb分别指向La和Lb中当前结点
     pb = NextPos(Lb, hb);
     while  (pa && pb)
     {     // La和Lb均非空
         a = GetCurElem(pa);  // a和b为两表中当前比较元素
         b = GetCurElem(pb);
         if  ((*compare)(a, b)<=0)
         {  // a≤b
             DelFirst(ha, q);  Append(Lc, q);  pa = NextPos(La, pa); 
         }
         else
         {   // a＞b
             DelFirst(hb, q);  Append(Lc, q);  pb = NextPos(Lb, pb); 
         }
     } // while
     if  (pa)
         Append(Lc, pa);        // 链接La中剩余结点
     else
         Append(Lc, pb);        // 链接Lb中剩余结点
     FreeNode(ha);  
     FreeNode(hb);              // 释放La和Lb的头结点
     return  OK;
} // MergeList_L

此账号已停用
关注
专栏目录
已知3个带头结点的线性链表A,B,C中的结点均依元素值自小至大非递减排列（可能存在两个或两个以上值相同的结点），编写算法对链表A进行如下操作：使操作后的链表A中仅留下3个表中均包含的数据元素的结点
yuyunzhen的博客
11-29 1558
/* 已知3个带头结点的线性链表A,B,C中的结点均依元素值自小至大非递减排列（ 可能存在两个或两个以上值相同的结点），编写算法对链表A进行如下操作： 使操作后的链表A中仅留下3个表中均包含的数据元素的结点，且没有值相同的结 点，并释放所有无用结点。限定算法的时间复杂度为O(m+n+p),其中m,n和p 分别为三个表的长度。 */ typedef struct LNode{ int data; struct LNode *next; }*Linkedlist; LinkedList Com...
BUPT-DSA 2019 Fall Chap.1 利用带头结点的链表实现多项式的乘法
A land whole of flowers.
10-07 183
利用带头结点的链表实现多项式的乘法（实际上不带头结点操作起来要方便一些） 由于使用了结构体的整体赋值，需要打开C++11语法，如果不想开也可以单独逐个赋值。 由polynomialMultiply()函数返回一个新的多项式，而不对输出的poly1和poly2做修改。 多用const是好习惯。 typedef struct _polynomial { int coef,expon; struct...
带头结点的线性链表
qq_40422286的博客
03-12 553
#include &amp;amp;lt;stdio.h&amp;amp;gt; #include &amp;amp;lt;stdlib.h&amp;amp;gt; #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 typedef int
【数据结构】：线性表之单链表（带头结点）
呋喃吖的博客
06-07 273
前言 继上一篇 数据结构第三篇（1）：线性表之单链表（不带头节点） 讲带头结点的链表。 首先说说有头节点的好处： 最直接的好处就是头插头删不应修改头指针了。 空链表和非空链表能统一处理，不用单独处理空链表了。 存储结构 存储结构没变化 #define ELemType int typedef struct LinkNode { ELemType date; //数据域 struct LinkNode* next; //指针域 }LinkNode; typedef LinkNode* Link;
带头结点的线性链表的基本操作
我的梦
11-15 3334
持续了好久，终于有了这篇博客，链表的操作需要借助图像模型进行反复学习，这里尽可能的整理并记录下自己的思考，以备后面复习，和大家分享。
线性表链接存储（单链表，带头结点）操作的18种算法 C
Kaleidoscope的博客
05-14 694
线性表链接存储（单链表，带头结点）操作的18种算法 #include<stdio.h> #include<stdlib.h> typedef struct node{ int data; struct node *next; }Node; /* 1.初始化带头结点的线性表 */ Node *initList(void) { Node *head; head=(Node *)malloc(sizeof(Node)); head->next=NULL; r
详谈线性表中带头节点与不带头结点链表
Judy_c的博客
07-14 2670
        之前给别人讲解过线性表这一数据结构，发现很多人在引入线性表的控制头后就把控制头指针与不带头节点链表的链表头指针混淆了，其实造成这一误区的根本原因还是对于带头节点链表与不带头节点链表的本质不够清楚。本文会通过线性表数据结构实现方式与线性表类的区别作为切入点，详细解释带头结点链表与不带头结点链表的区别。        首先我们区别三个概念：线性表，链表，链表类。        线性表是...
利用头插法建立一个带头结点的的线性链表，链表中依次插入26个小写的英文字母，显示该链表中所有元素，将第十个字母删除后再显示该链表中剩下的元素（提问为什么这么写不对）
cwl010530的博客
04-20 1135
C语言代码求助
【链表】带头节点和不带头节点单链表的区别
风铃的博客
12-11 8539
目录 ????当链表的结点只包含一个指针域时，叫做单链表 ????不论带不带头节点，所有的链表都要有个头指针！ ????带头结点的链表的头指针指向的是头结点，头结点的指针域指向首元结点 ????不带头结点的头指针直接指向首元结点 ????初始化 ????2.带头节点的初始化 ????不带头节点的初始化 ????判空条件 ????带头节点 ????不带头节点 ????操作上有区别 ????带头节点 ????不带头节点 ????当链表的结点只包含一个指针域时，叫做单链表 ?
数据结构之链表的实际应用
m0_63932570的博客
03-27 2293
今天给大家分享链表的实际应用，很多人学数据结构时总是学课本里的伪代码，其实看懂了课本的伪代码只是学会了数据结构的20%，在学数据结构时我们应该要多注重实践，多用已学的数据结构来解决一些实践的问题。下面是我自己写的链表完整代码（包括创建链表，链表插入数据，链表删除数据，修改链表指定位置的值），以供大家参考。 完整源代码： #include <stdio.h> #include <stdlib.h> struct Stu *create(int n); void print(str.
带头结点的线性链表的编写与实现
rookie_lzy的专栏
04-01 1092
4月1号，完成头文件的编写 明天写实现。/*线性表的链式存储结构的特点是用一组任意的 **存储单元存储线性表的数据元素 **（这组存储数据元素可以是连续的，也可以是不连续的） */#include <stdlib.h> #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define OVERFLOW
带头结点的线性链表基本操作以及归并操作
Mongo_girl
01-25 474
    Status DelFirst_E(ELinkList *L, Link h, Link *q) { *q = h-&gt;next; if(*q) //链表非空 { h-&gt;next = (*q)-&gt;next; if(!h-&gt;next) //h后只有一个结点 (*L).tail = h; (*L).len--;...
链表的三个经典问题
云计算?
04-26 112
问题1：给定一个单项链表，设计一个时间优化并且时间优化的算法，找出该链表的倒数第m个元素。当m=0时，返回链表的最后一个元素。 [分析：用双指针来实现，两指针间隔m。同步移动两指针，当前一个指针为该链表tail时，后一个指针就为要找的元素] Element * FindMToLastElement( Element * head, int m) { Element * current, *...
数据结构线性表习题（一）
无知的我
10-20 2998
已知三个带头结点的线性链表A，B，C中的结点均依元素值从小向大递减排列，编写算法对A表进行如下操作：使操作后的链表A中仅留下三个表中均包含的数据元素的结点，且没有值相同的结点，并释放所有无用的结点。算法时间复杂度为O(m+n+p)，为m,n,p三表长度 设计思路：留下三个表中的公共数据，首先查找两表A、B的公共数据，然后去C中找有无该数据。 代码： void Common(L
线性表(带头结点的单链表)
那又怎样的博客
03-11 1062
node.h#pragma once template<typename T> class node { public: node() = default;//默认构造函数 node(T x) :elem(x),next(NULL) {}; T elem; //节点元素 node *next; };linkList.h#pragma once # include"nod
数据结构（四）——单链表 、带头结点的单链表、循环链表 及其实现
热门推荐
阿修罗道
09-19 2万+
一、 链式存储       以结点的形式存储数据。除了存放一个结点的信息外，还需附设指针。                   数据在内存中存储是不连续的，每个结点只能也只有它能知道下一个结点的存储位置。     二、单链表   单链表是线性表链式
带头结点与不带头结点的单链表-LinkList
知行合一，止于至善
05-04 6327
1.辅助文件包Assistance.h#ifndef __ASSISTANCE_H__ // 如果没有定义__ASSISTANCE_H__ #define __ASSISTANCE_H__ // 那么定义__ASSISTANCE_H__// 辅助软件包// ANSI C++标准库头文件 #include <cstring>
逆置带头结点的单链表
qq_41885826的博客
10-03 1万+
      对问题的分析：              对于带头结点的点链表，逆置其中最核心的步骤就是对链表就行头插法。                 第一步：先定义两个指针（pCur 和 pNext），同时指向第一个元素的地址;             第二步：使头结点和第一个元素断开链接（Phead-&gt;pnext=NULL）              第三步：    （1）...
带头节点的链表和不带头结点的链表有何不同
haoshen's blog
04-14 1万+
单链表是一种最为基本的数据结构，常用的单链表又分为带头结点和不带头结点两种。从线性表的定义可以知道，线性表要求允许在任意位置进行插入和删除操作。所有的链表都有一个头指针head，带头结点的链表中head的数据项为空。接下来具体分析。 1.带头节点的链表的插入，首先使用临时变量p等于要插入之前的节点（不管具体的插入位置），之后不管要插入的节点x是插到链表头还是插到链表的其他位置都是如下语句:x->
带头结点链表实现与操作详解
在C语言中，一个带头结点的线性链表是一个重要的数据结构，它通过节点之间的链接来存储和管理数据。在【标题】"一个带头结点的线性链表类型-东北大学c数据结构ppt"中，我们探讨了线性链表的基础概念及其在C语言中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值