C - 数据结构 - 线性表 - 链式实现

最新推荐文章于 2021-10-30 16:10:17 发布
最新推荐文章于 2021-10-30 16:10:17 发布
阅读量1.4k 收藏 4
点赞数
分类专栏： C 文章标签： c语言 数据结构 线性表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuxinmingcode/article/details/52728094
版权

上一章节我们研究和学习了线性表的顺序存储结构
特点是逻辑关系上相邻的两个元素在物理位置上也相邻
因此可以随机存取表中任一元素，它的存储位置可用一个简单、直观的公式来表示。

弱点: 在作插入或删除操作时，需移动大量元素。
SO: 我们学习另一种表示方法 链式存储结构。

  1. 链式存储结构不要求逻辑上相邻的元素在物理位置上也相邻
  2. 它没有顺序存储结构的弱点
  3. 但同时也失去了顺序表可随机存取的优点

单链表

对链表的访问要通过顺序读取从头部（头指针）开始。
包含两个域，一个信息域和一个指针域(指针或链)。这个链指向列表中的下一个结点，而最后一个结点则指向一个空(NULL)。

这里写图片描述

// 单链表可由头指针唯一确定，在C语言中可用“结构指针”来描述
// 假设L是LinkList型的变量，则L为单链表的头指针，它指向表中第一个结点
// 头结点的数据域可以不存储任何信息，也可存储如线性表的长度等类的附加信息
typedef struct LNode{
    ElemType data;
    struct LNode *next;
}LNode, *LinkList;

插入

假设我们要在线性表的两个数据元素a和b之间插入一个数据元素x，已知p为其单链表存储结构中指向结点a的指针

  • 生成一个数据域为x的结点
  • 修改结点a中的指针域，令其指向结点x
  • x中的指针域应指向结点b

这里写图片描述

代码片段

Status ListInster(LinkList L , int i, ElemType e){
    int j = 0;
    LinkList p,s;
    p = L;

    while (p && j < i-1) { // 寻找第i-1个结点
        p = p->next; // p指向其前驱(即i-1(a)结点)
        j++; // 计数器
    }

    if(!p || j>i-1)
        return ERROR; // i小于1或者大于表长加1
    s = (LinkList)malloc(sizeof(struct LNode)); // 生成新结点
    s->data=e; // 插入数据
    s->next=p->next;// s为指向结点i的指针
    p->next = s;// p为指向s结点的指针
    return OK;
}

删除

删除元素b时

  • 修改结点a中的指针域即可
  • 执行free(b)，回收后的空间可以再次生成结点时用

这里写图片描述

假设p为指向结点a的指针，则修改指针的语句为

p->next = p->next->next;

Status ListDelete_L(LinkList L, int i, ElemType *e){
    int j = 0;
    LinkList p, q;
    p = L;

    while (p->next && j < i-1) { // 找到第i-1个结点
        p = p->next; // p指向其前驱(i-1(a)结点)
        j++;
    }

    if(!p->next||j>i-1)
        return ERROR; // 删除位置不合理

    // 删除并释放结点
    q = p->next; // q为指向p结点的指针(即b结点)
    p->next=q->next; // p为指向q结点的指针
    *e = q->data;
    free(q);// 释放q(即b结点)
    return OK;
}

实例代码

// linklist.h
//
//  linked.h
//  LinkList
//
//  Created by liuxinming on 16/9/29.
//  Copyright © 2016年 liuxinming. All rights reserved.
//
#include <stdio.h>
#include <stdlib.h>
#include "string.h"

#ifndef linked_h
#define linked_h



// 函数结果状态代码
#define TRUE 1
#define FALSE 0
#define OK  1
#define ERROR 0
#define INFEASIBLE -1
#define OVERLOW -2

// Status 是函数的类型, 其值是函数结果状态代码
typedef int Status;
typedef int ElemType;

// 线性表的单链表存储结构
typedef struct LNode
{
    ElemType data;
    struct LNode * next;
}LNode,* LinkList;

// 操作结果：构造一个空的线性表
Status InitList(LinkList *L){
    // 产生头结点，并使L指向此结点
    *L = (LinkList)malloc(sizeof(struct LNode));
    if(!*L)
        exit(OVERLOW); // 存储分配失败
    (*L)->next=NULL; // 指针域为空
    return OK;
}

// 在带头结点的单链线性表L中第i个位置之前插入元素e
Status ListInster(LinkList L , int i, ElemType e){
    int j = 0;
    LinkList p,s;
    p = L;

    while (p && j < i-1) { // 寻找第i-1个结点
        p = p->next; // p指向其后续(即i-1结点)
        j++; // 计数器
    }

    if(!p || j>i-1)
        return ERROR; // i小于1或者大于表长加1
    s = (LinkList)malloc(sizeof(struct LNode)); // 生成新结点
    s->data=e; // 插入数据
    s->next=p->next;// s为指向结点i的指针
    p->next = s;// p为指向s结点的指针
    return OK;
}

// L为带头结点的单链表的头指针。当第i个元素存在时，其赋值给e并返回OK，否则返回ERROR
Status GetElem(LinkList L, int i, ElemType *e){
    int j = 1;
    LinkList p = L->next; // p指向第一个结点
    while (p && j<i) {
        p=p->next;
        j++;
    }

    if (!p||j>i) // 第i个元素不存在
        return ERROR;
    *e = p->data; // 取第i个元素
    return OK;
}

// 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值
Status ListDelete_L(LinkList L, int i, ElemType *e){
    int j = 0;
    LinkList p, q;
    p = L;

    while (p->next && j < i-1) { // 找到第i-1个结点
        p = p->next; // p指向其后续(i-1结点)
        j++;
    }

    if(!p->next||j>i-1)
        return ERROR;// 删除位置不合理

    // 删除并释放结点
    q = p->next;
    p->next=q->next;
    *e = q->data;
    free(q);
    return OK;
}

// 已知单链线性表La 和 Lb 的元素按值非递减排列
void MergeList(LinkList La, LinkList *Lb, LinkList *Lc){
    // 归并La和Lb得到新的单链线性表Lc,Lc的元素也按值非递减排列

    // 定义三个指针，分布指向La,Lb中当前待比较插入的结点
    // pc指向Lc表中档最后一个结点
    LinkList pa,pb,pc;

    pa = La->next; pb = (*Lb)->next;
    *Lc = pc = La;//用La的头结点作为Lc的头结点

    while (pa && pb) {
        // pa,pb皆非空，当其中一个为空时，说明有一个表的元素已归并完，则只需将另一个表的剩余段链接在pc所指的结点之后即可
        if(pa->data <= pb->data)
        {
            pc->next = pa; // 将pa所指结点链接到pc所指结点之后
            pc=pa;
            pa=pa->next;

        }
        else
        {
            pc->next = pb; // 将pb所指结点链接到pc所指结点之后
            pc=pb;
            pb=pb->next;
        }
    }

    // 插入剩余段
    pc->next = pa ? pa : pb;
    // 释放Lb的头结点
    free(*Lb);
    Lb = NULL;

}// MergeList

// 逆位序(插在表头)输入n个元素的值，建立带表头结构的单链线性表L
void CreateList(LinkList *L, int n){
    int i;
    LinkList p;
    *L = (LinkList)malloc(sizeof(struct LNode));
    (*L)->next = NULL ; // 先建立一个带头结点的单链表
    printf("请输入%d个数据\n",n);
    for (i=n;i>0;--i){
        p = (LinkList)malloc(sizeof(struct LNode)); // 生成新结点
        scanf("%d",&p->data); // 插入元素值
        p->next = (*L)->next; // 插入到表头
        (*L)->next = p;
    }
}

// 正位序(插在表尾)输入n个元素的值，建立带表头结构的单链线性表
void CreateList_2(LinkList *L, int n){
    int i;
    LinkList p, q;
    *L = (LinkList)malloc(sizeof(struct LNode));
    (*L)->next = NULL;
    q = *L;

    printf("请输入%d个数据\n",n);
    for (i = 1;i<=n; i++){
        p = (LinkList)malloc(sizeof(struct LNode)); // 生成新结点
        scanf("%d",&p->data);
        q->next = p;
        q = q->next;
        p->next = NULL;
    }


}

// 初始条件：线性表L已存在
// 操作结果：将L重置为空表
Status ClearList(LinkList L){ // 不改变L
    LinkList p, q;
    p = L->next; // p指向第一个结点
    while (p) {
        q = p->next;
        free(q);
        p = q;
    }
    L->next=NULL; // 头结点指针域为空
    return OK;
}

// 初始条件：线性表L已存在
// 操作结果：销毁线性表L
Status DestroyList(LinkList *L)
{
    LinkList q;
    if(*L == NULL) return ERROR;
    while (*L) {
        q = (*L)->next;
        free(*L);
        *L=q;
    }
    return OK;
}

// 初始条件：线性表L已存在
// 操作结果：若L为空表，则返回TRUE,否则返回FALSE
Status ListEmpty(LinkList L){
    if (L->next) // 非空
        return FALSE;
    else
        return TRUE;
}

// 初始条件：线性表L已存在
// 操作结果：返回L中的数据元素个数
Status ListLenght(LinkList L)
{
    int i = 0;
    LinkList p = L->next; // p指向第一个结点
    while (p) { // 没有到表尾
        i++;
        p = p->next;
    }
    return i;
}

// 初始条件：线性表L已存在，compare()是数据元素判定函数(满足为1，否则0)
// 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。若这样的数据元素不存在，则返回值0
int LocateElem(LinkList L, ElemType e, Status (*compare)(ElemType,ElemType))
{
    int i = 0;
    LinkList p = L->next;
    while (p) {
        i++;
        if(compare(p->data,e)) // 找到这样的元素
            return  i;
        p = p->next;
    }

    return 0;
}

// 初始条件：线性表L已存在
// 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，返回OK，否则操作失败，pre_e无定义，返回INFEASIBLE
Status PriorElem(LinkList L,ElemType cur_e, ElemType *pre_e){
    LinkList q, p = L->next;
    while (p->next) { // p指向结点有后续
        q = p->next; // q为p的后续
        if (q->data == cur_e)
        {
           *pre_e = p->data;
            return OK;
        }
        p = q; // p向后移

    }

    return INFEASIBLE;
}

// 初始条件：线性表L已存在
// 操作结果：若cur_e是L的数据元素，切不是最后一个，则用next_e返回它的后续，返回OK，否则操作失败,next_e无定义，返回INFEASIBLE
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e){
    LinkList p = L->next;
    while (p->next) { // p所指结点有后续
        if(p->data == cur_e)
        {
            *next_e = p->next->data;
            return OK;
        }
        p = p->next;
    }
    return INFEASIBLE;
}

// 初始条件：线性表L已存在
// 操作结果：依次对L的每个数据元素调用函数vi()。一旦vi()失败，则操作失败
Status ListTraverse(LinkList L, void(*vi)(ElemType))
{
    LinkList p = L->next;
    while (p) {
        vi(p->data);
        p=p->next;
    }
    printf("\n");
    return OK;
}
#endif /* linked_h */

DEMO测试

//
//  main.c
//  LinkList
//
//  Created by liuxinming on 16/9/25.
//  Copyright © 2016年 liuxinming. All rights reserved.
//

#include <stdio.h>
#include "linklist.h"

// ListTraverse()调用的函数(类型要一致)
void visit(ElemType c)
{
    printf("%d ",c);
}

int main(int argc, const char * argv[]) {
    // insert code here...
    printf("Testing start!\n");
    LinkList L,La,Lb,Lc;
    int n = 5;

    printf("按非递减顺序:\n");
    CreateList_2(&La, n);
    // 输出链表La的内容
    printf("La=");
    ListTraverse(La,visit);

    printf("按非递增顺序: ");
    CreateList(&Lb, n);
    printf("Lb=");
    ListTraverse(Lb, visit);

    // 按非递减顺序归并La和Lb,得到新表Lc
    MergeList(La,&Lb,&Lc);
    printf("Lc="); /* 输出链表Lc的内容 */
    ListTraverse(Lc,visit);
    return 0;
}

循环链表

循环链表是另一种形式的链表存储结构

  • 表中最后一个节点的指针指向头节点
  • 整个链表形成一个还
  • 差别仅在于算法中的循环条件不是p或p->next是否为空，而是他们是否等于头指针。
  • 若在循环链表中设立尾指针而不设头指针，可使某些操作简化

双向链表

双向链表的节点中有两个指针域
一个指向直接后续
一个指向直接前趋

// 线性表的双向链表存储结构
typedef struct DuLNode(){
    ElemType  data;
    struct DuLNode *prior;
    struct DuLNode *next;
}DuLNode, *DuLinkList;

插入

借张图说明下
这里写图片描述

  1. 为链表结点x动态分配内存
  2. 为新生成结点x 赋值
  3. 使x前驱指向p的前驱
  4. 使x后驱指向p
  5. 修改原p之前的结点(即i-1)的后驱为x
  6. 修改原p的前驱为x
DuLinkList GetElemP(DuLinkList L,int i)
{
    DuLinkList p;
    //初始化，p指向第一个结点，j为计数器
    p = p->next;
    int j = 1;
    while (p != L && j < i) {
        // 顺指针向后查找，直到p指向第i个元素或p为空
        p = p->next;
        ++j;
    }

    if (p == L && j < 1)
        return NULL; // 第i个元素不存在
    else
        return p;
}
// 在带头结点的双循环线性表L中第i个位置之前插入元素e
// i的合法值为1<=i<=表长+1
Status ListInsertBefore(DuLinkList L, int i, ElemType e){
    DuLinkList p, x;
    if (i<1)
        return ERROR;
    if (!(p = GetElemP(L, i))) // 在L中确认第i个元素的位置指针p
        return ERROR;//p = NULL, 即第i个元素不存在
    x = (DuLinkList)malloc(sizeof(DuLNode));
    if (!x)
        return OVERLOW;

    x->data = e; // 将元素e的值赋给新生成结点x
    x->prior = p->prior; // 使s的前驱指向p的前驱(即i-1)
    x->next = p; // 使x的后驱指向i的结点

    p->prior->next = x; // 原p前驱结点(即i-1)的后驱指向x
    p->prior = x; // 原p前驱指向x
    return OK;
}

删除

// 删除带头结点的双链循环线性表L的第i个元素
Status ListDelete(DuLinkList L, int i, ElemType *e){
    DuLinkList p;
    p = GetElemP(L, i); // 在L中确认第i个元素的位置指针p
    if (!p)
        return ERROR;//p = NULL, 即第i个元素不存在
    *e = p->data;

    p->prior->next = p->next;
    p->next->prior = p->prior;

    free(p);
    return OK;
}// ListDelete
巴途Adolph
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
用C语言实现数据结构中的线性表（链式表示）
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的链式表示和实现都囊括在内了。部分实现中也做了相应的优化处理。如果想看线性表的顺序表示表示和...
数据结构 - 线性表的链式表示和实现
如图所示
07-25 707
数据结构 - 线性表的链式表示和实现
正逆序建立单链表（第二章 P30 算法2.11）
但行好事，莫问前程
03-16 1606
正逆序建立单链表 typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */ typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */ typedef int ElemType; #include<malloc.h> /* malloc()等 */ #include<...
数据结构 线性链表
ylxy
11-10 716
发现自己敲代码有个习惯……注释写的那么详细干嘛啊。。。以后注意 #include #include typedef struct LNode { int data; struct LNode *next; } LNode,*LinkList; //算法2.11*******31 //逆位序输入n个元素的值，建立带表头结点的单链线性表L void Create
数据结构笔记——线性表
Wmiracle的博客
10-30 984
本篇学习笔记包含线性表的定义以及顺序表、链表的代码实现，内容综合各方资料及本人的理解将线性表最基础的理论整合而成。
数据结构学习笔记 --- 线性表 （单链表）
whz_zb的专栏
02-05 1462
1. 引言 单链表有带有结点和不带头结点之分，本文分别讨论带头结点的单链表和不带头结点的单链表的一些基本操作，和用头插法、 尾插法创建单链表，以及两个算法。 2. 带头结点的单链表 2.1 带头结点的单链表的存储结构 typedef struct LNode{ ElemType data; struct LNode *n
线性表的链式实现-----单链表
07-02
LinkList.h与LinkList.c。使用c语言实现单链表数据结构。注释详细。
用C语言实现数据结构中的线性表
11-15
本人在学习数据结构时使用的是严蔚敏的《数据结构》，并根据课本内容完成了这个头文件，这个头文件把课本中的线性表的顺序表的表示和实现都囊括在内了。部分实现中也做了相应的优化处理。由于一次性只能发一个文件，...
全网最详细的-线性表的链式存储
最新发布
12-26
在实现链式存储时，可以使用单链表、双链表或循环链表等不同的结构来实现。单链表包含一个指针域，指向下一个节点；双链表包含两个指针域，分别指向前一个节点和后一个节点；循环链表是一种特殊的链表，尾节点的指针...
线性表的链式表示和实现 C语言 数据结构
11-12
用C语言编写数据结构 线性表的链式表示和实现
c语言实现两个线性表合并,合并两个线性表（数组）并按照非递减排序输出，有点问题过来看看...
weixin_34269309的博客
05-23 402
该楼层疑似违规已被系统折叠隐藏此楼查看此楼这是源代码：#includeint f_len(int l[500]){int i=0 , len;printf("please input numbers: ");do{scanf("%d",&l[i]);i++;}while ( (i<500) && l[i-1]!='\n' );printf("\n");len =...
含头结点的单链线性表的基本操作
好好努力
11-28 706
定义单链表存储结构 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 typedef int ElementType; typedef int Status; typedef int Boolean; struct LNode { ElementType data; LNode * next; }; typedef ...
【数据结构（二）】线性表（二）顺序存储结构
s599796的博客
04-06 365
文章目录上节练习线性表的顺序存储结构顺序存储结构的插入与删除顺序结构的优缺点 上节练习 实现两个线性表集合A和B的并集操作。 void unionL(List *La,List Lb) { int La_len; int Lb_len; //分别声明La和Lb的长度 ElemType e; //声明与La和Lb相同的数据元素 La_len=ListLength(*La); Lb_le...
c语言一个线性表la 逆序,用C/C++语言建立两个带表头结点的有序线性单链表( La, Lb )的合并操作并按原来的相反顺序生成新的逆序线性...
weixin_30431445的博客
05-23 389
满意答案brdgpefc2013.04.04采纳率：44%等级：11已帮助：13753人#include#include/*线性表*/struct TLink {int data;struct TLink * next;};/*end struct TLink*//*生成新元素*/struct TLink * new_item(int number){struct TLink * r = ...
2.2线性表LA和LB按照非递减序列排序，合并为LC，LC仍为非递减序列2
qq_42717239的博客
06-01 8412
需要注意的是： *L.elem=L.elem[0] *(L.elem+i)=L.elem[i] 指针程序(线性表从L.elem[0]开始)： //通过指针比较合并la、lb为lc，使得lc仍为非递减序列 #include<stdio.h> #include<malloc.h> #include<iostream> using namespace std; #d...
数据结构：归并La和Lb得到新的单链表Lc，Lc的元素也按值非递减排列
weixin_43424154的博客
03-26 1万+
#include <iostream> #include <stdio.h> #include<stdlib.h> using namespace std; typedef int Status; typedef int ElemType; typedef struct LNode { ElemType data; struct LNode ...
数据结构详解——线性表（C++实现）
热门推荐
Quanfita的博客
03-11 5万+
线性表   线性表是最常用且是最简单的一种数据结构。形如：A1、A2、A3….An这样含有有限的数据序列，我们就称之为线性表。 线性表 一、线性表的定义 二、线性表的抽象数据类型 三、线性表的顺序存储 1. 顺序存储定义 2. 顺序存储的实现方式 3. 顺序存储的优缺点 四、线性表的链式存储 1. 链式存储定义 2. 链式存储的实现方式 链式存储的优缺点 五、其他线性表 循环链...
数据结构-----链表基本操作
justforfun
05-30 711
// https://code.csdn.net/snippets/369659.js">>
数据结构C语言版的线性表知识点
03-28
- 线性表是一种数据结构，由零个或多个数据元素组成，数据元素之间是有序的，且每个数据元素只有一个前驱和一个后继。 - 基本操作包括插入、删除、查找、遍历等。 2. 线性表的顺序存储结构 - 线性表的顺序存储结构...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值