2.8~2.12带头节点的链表的基本操作

2.8和2.9在带头结点的链表中实现插入和获取元素的操作

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef int Status ;
typedef int ElemType;
#define OK 1
#define ERROR 0

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(struct LNode));
    if(!*L)
        exit(OVERFLOW);
    (*L)->next=NULL;
    return OK;
}
Status ListInsert(LinkList L,int i,ElemType e)
{
    int j=0;
    LinkList p=L,s;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
        return ERROR;
    s=(LinkList)malloc(sizeof(struct LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j=0;
    LinkList p=L;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
        return ERROR;
    *e=p->data;
    return OK;
}
void main()
{
    LinkList L;
    ElemType e;
    int j;
    InitList(&L);
    for(j=1;j<=5;j++)
        ListInsert(L,j,j);
    printf("L=");
    for(j=1;j<=5;j++)
    {
        GetElem(L,j,&e);
        printf("%d ",e);
    }
    printf("\n");
}

程序运行如下:

2.10在带头结点的链表中实现删除元素操作

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef int Status ;
typedef int ElemType;
#define OK 1
#define ERROR 0

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(struct LNode));
    if(!*L)
        exit(OVERFLOW);
    (*L)->next=NULL;
    return OK;
}
Status ListInsert(LinkList L,int i,ElemType e)
{
    int j=0;
    LinkList p=L,s;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
        return ERROR;
    s=(LinkList)malloc(sizeof(struct LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
}
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j=0;
    LinkList p=L;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
        return ERROR;
    *e=p->data;
    return OK;
}
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j=0;
    LinkList p=*L,q;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
        return ERROR;
    q=p->next;
    p->next=q->next;
    *e=q->data;
    free(q);
    return OK;
}

void main()
{
    LinkList L;
    ElemType e;
    int j;
    InitList(&L);
    for(j=1;j<=5;j++)
        ListInsert(L,j,j);
    printf("L=");
    for(j=1;j<=5;j++)
    {
        GetElem(L,j,&e);
        printf("%d ",e);
    }
    printf("\n");
    ListDelete(&L,2,&e);
    printf("删除链表L中的第2个元素\n");
    for(j=1;j<=4;j++)
    {
        GetElem(L,j,&e);
        printf("%d ",e);
    }
    printf("\n");

}

程序运行如下:

2.11在带头结点的链表中,实现逆位序输入n个元素

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef int Status ;
typedef int ElemType;
#define OK 1
#define ERROR 0

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

void CreateList(LinkList *L,int n) //实现逆位序输入n个元素)
{
    int i;
    LinkList p;
    *L=(LinkList)malloc(sizeof(struct LNode));
    if(!*L)
        exit(OVERFLOW);
    (*L)->next=NULL;
    for(i=n;i>0;i--)
    {
        p=(LinkList)malloc(sizeof(struct LNode));
        if(!p)
            exit(OVERFLOW);
        scanf("%d",&((*L)->data));
        p->next=*L;
        *L=p;
    }
}

Status GetElem(LinkList L,int i,ElemType *e)
{
    int j=0;
    LinkList p=L;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
        return ERROR;
    *e=p->data;
    return OK;
}
Status ListDelete(LinkList *L,int i,ElemType *e)
{
    int j=0;
    LinkList p=*L,q;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
        return ERROR;
    q=p->next;
    p->next=q->next;
    *e=q->data;
    free(q);
    return OK;
}

void main()
{
    LinkList L;
    ElemType e;
    int j,k;
    printf("请输入打算建立的带有头结点的链表结点个数:");
    scanf("%d",&k);
    CreateList(&L,k);
    for(j=1;j<=k;j++)
    {
        GetElem(L,j,&e);
        printf("%d ",e);
    }
    printf("\n");

}

程序运行如下:

2.12将两个有序链表并为一个有序链表

#include<stdio.h>
#include<stdlib.h>
#include<math.h>

typedef int Status ;
typedef int ElemType;
#define OK 1
#define ERROR 0

typedef struct LNode
{
    ElemType data;
    struct LNode *next;
}LNode,*LinkList;

Status InitList(LinkList *L)
{
    *L=(LinkList)malloc(sizeof(struct LNode));
    if(!*L)
        exit(OVERFLOW);
    (*L)->next=NULL;
    return OK;
}
Status ListInsert(LinkList *L,int i,ElemType e)
{
    int j=0;
    LinkList p=*L,s;
    while(p&&j<i-1)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i-1)
        return ERROR;
    s=(LinkList)malloc(sizeof(struct LNode));
    s->next=p->next;
    p->next=s;
    s->data=e;
    return OK;
}
Status GetElem(LinkList L,int i,ElemType *e)
{
    int j=0;
    LinkList p=L;
    while(p&&j<i)
    {
        p=p->next;
        ++j;
    }
    if(!p||j>i)
        return ERROR;
    *e=p->data;
    return OK;
}
void MergeList(LinkList *La,LinkList *Lb,LinkList *Lc)
{
    LinkList pa,pb,pc;
    pa=(*La)->next;
    pb=(*Lb)->next;
    *Lc=pc=*La;
    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;
        }
    }
    pc->next=pa?pa:pb;
    free(*Lb);
}

void main()
{
    LinkList La,Lb,Lc,c;
    ElemType e;
    int j;
    InitList(&La);
    for(j=1;j<=5;j++)
        ListInsert(&La,j,j);
    printf("La=");
    for(j=1;j<=5;j++)
    {
        GetElem(La,j,&e);
        printf("%d ",e);
    }
    printf("\n");
    InitList(&Lb);
    for(j=1;j<=5;j++)
        ListInsert(&Lb,j,2*j);
    printf("Lb=");
    for(j=1;j<=5;j++)
    {
        GetElem(Lb,j,&e);
        printf("%d ",e);
    }
    printf("\n");
    MergeList(&La,&Lb,&Lc);
    printf("Lc=");
    c=Lc->next;
    while(c)
    {
        printf("%d ",c->data);
        c=c->next;
    }
    printf("\n");

}

程序运行结果如下:

时间: 2024-10-14 07:15:21

2.8~2.12带头节点的链表的基本操作的相关文章

Java带头节点单链表的增删融合以及是否有环

带头节点单链表 1.优势: 1)当链表为空时,指针指向头结点,不会发生null指针异常 2)方便特殊操作(删除第一个有效节点或者插入一个节点在表头) 3)单链表加上头结点之后,无论单链表是否为空,头指针始终指向头结点,因此空表和非空表的处理也统一了,方便了单链表的操作,也减少了程序的复杂性和出现bug的机会. 4)代码更加简单易懂 2.相关操作 1)建立单链表 即建立一个头结点 static class Entry<T> { T data; // 链表节点的数据域 Entry<T>

单链表——带头节点

一.链表简介 1 数据结构中,链表是最基础的.然而链表根据不同的需求分成的种类很多,单向或双向链表,循环或非循环链表,带头节点或者不带头节点的链表. 2 本文实现——带头节点的单链表. 3 由于仅仅是学习链表的基本操作,所以在数据字段仅仅设置一个字段:   由于仅仅是学习基本操作,不涉及复杂的算法思想,所以不会很难,主要以代码为主,附上必要的解释即可. 二.具体实现 整体分析:带有头节点的单链表的操作很方便,主要体现在插入和删除时不需要判断是否是第一个元素. 1) 头文件定义如下: 1 #ifn

单链表一[带头节点链表]

单链表实现分带头节点链表和不带头节点链表: 使用头文件如下: struct LinkNode {     void *x;      struct LinkNode *next; }; 一,带头节点的链表: 1,链表创建 程序说明: 1)函数调用形式:szyu_link_create0("AA", "BB", NULL);其中NULL结尾是在for循环的判断结束条件为x == NULL.使用NULL可以是for循环正常退出 2)程序先创建头节点head,并初始化he

牛客之错题(2016.1.15) &amp;&amp; 带头节点与不带头的区别

已知集合A和B的元素分别用不含头结点的单链表存储,函数difference( )用于求解集合A与B的差集,并将结果保存在集合A的单链表中.例如,若集合A={5,10,20,15,25,30},集合B={5,15,35,25},完成计算后A={10,20,30}. 链表结点的结构类型定义如下: struct node   {   int elem;   node* next;   };     void difference(node** LA , node* LB)   {   node *pa

数据结构笔记5带头结点单链表

/* 本次操作是对带头节点单链表的操作  包括删除  插入 判空 建立  包括删除插入函数  显示函数 目的是为了对单链表做一个基本操作的总结----1*/ #include<stdio.h>#include<malloc.h>#include<conio.h>#define OK 1#define ERROR -1#define OVERFLOW -2#define ENDFLAG 0typedef struct LNode{ int data; struct LNo

带头节点的单链表-------C语言实现

1 /***************************************************** 2 Author:Simon_Kly Version:0.1 Date:20170520 3 Description:带头接点的单链表 4 Mail:[email protected] 5 Funcion List: 6 *****************************************************/ 7 8 #include <stdio.h> 9 #

单链表二[不带头节点链表]

不带头节点链表 单向链表是链表的一种.单向链表由一系列内存不连续的节点组成,每个节点都包含指向值的域和指向下个节点的next指针.最后一个节点的next域为NULL值,代表链表结束. 链表示意图如下: 一,结构体 1,结构体定义: struct LinkNode {     void *x;      struct LinkNode *next; }; 2,结构体大小: 1)取结构体大小方法:sizeof(struct LinkNode);在64位系统取出结构体大小为:sizeof(struct

带头节点的单链表的插入操作

1.偶然看到了十字链表的应用,想到之前在<数据结构与算法分析>的链表一章中,需要用多重表实现一个简单的查询功能.功能需求如下: “已知 学生 和 学校课程 总数 分别为 40000 和 2500,现在需要得到两份报告,一份显示每门课成注册的所有学生信息, 一份显示每个学生注册了哪些课程.” 显然可以用一个 40000 * 2500 个元素的二维数组来解决,但是每个学生选课数目很少,因此会浪费很多空间.因此选择十字链表来实现. 既然是链表,那么肯定要有插入操作,于是便有了本文.算是对功能实现前的

实际应用中带头节点的线性链表

/*========带头节点的线性链表类型=========*/ typedef char ElemType //结点类型 typedef struct LNode { char data; struct LNode *next; }*Link,*Position; //链表类型 typedef struct { Link head,tail; int len; }LinkList; /*======================================================