数据结构链式表的实现

最新推荐文章于 2024-06-11 22:29:04 发布
最新推荐文章于 2024-06-11 22:29:04 发布
阅读量491 收藏 6
点赞数
分类专栏： 数据结构 文章标签： 数据结构 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Xuyiming564445/article/details/104869692
版权

数据结构链式表的实现

1. 单链表

#include <cstdio>
#include <cstdlib>
#include <iostream>

#define MaxSize 100

typedef int ElemType;

using namespace std;

typedef struct LNode {
    ElemType data;
    struct LNode *next;
} LNode, *LinkList; 
// *LinkList表示人为增加的头结点，也可以用LNode *表示，LinkList是全局变量 指向头结点，
//可以这样定义：LNode *LinkList
  • 头插法建立单链表（输出时会得到反序的链表）
LinkList List_HeadInsert(LinkList &L) {     //时间复杂度为O(n)
    int x;
    LinkList s;     //LNode *s;
    L = (LinkList) malloc(sizeof(LNode));   //L = (LNode *) malloc(sizeof(LNode));  为头结点申请内存分配
    L->next = nullptr;     //初始化为空链表
    cout << "输入结点的值，输入9999表示结束：";
    cin >> x;
    while (x != 9999) {
        s = (LinkList) malloc(sizeof(LNode));
        s->data = x;
        s->next = L->next;
        L->next = s;
        cout << "输入结点的值，输入9999表示结束：";
        cin >> x;
    }
    return L;
}
  • 尾插法建立单链表（输出时会得到正序的链表）
LinkList List_TailInsert(LinkList &L) {     //时间复杂度为O(n)
    int x;
    L = (LinkList) malloc(sizeof(LNode));
    LinkList s, r = L;
    cout << "输入结点的值，输入9999表示结束：";
    cin >> x;
    while (x != 9999) {
        s = (LinkList) malloc(sizeof(LNode));
        s->data = x;
        r->next = s;
        r = s;
        cout << "输入结点的值，输入9999表示结束：";
        cin >> x;
    }
    r->next = nullptr;
    return L;
}
  • 按序号查找结点值（时间复杂度为O(n)）
LinkList GetElem(LinkList L, int i) {       //因为不会对链表进行改动，所以可以不用 &L，直接用 L
    int j = 1;
    LinkList p = L->next;
    if (i == 0)     //返回头结点
        return L;
    if (i < 1)
        return nullptr;
    while (p && j < i) {    //从第一个结点出发，逐个往下查找第i个结点
        p = p->next;
        j++;
    }
    return p;   //返回第i个结点的指针，若i大于表长则返回 NULL
}
  • 按值查找表结点（时间复杂度为O(n)）
LinkList LocateElem(LinkList L, ElemType e) {
    LinkList p = L->next;
    while (p->data != e && p != nullptr) {
        p = p->next;
    }
    return p;       //找到则返回该结点指针，否则返回 NULL
}
  • 在位置i上插入新值e
LinkList ListInsert(LinkList &L, int i, ElemType e) {
//法一：
// （对位置i前插操作，时间复杂度为O（n），对位置i的前驱结点后插操作，时间复杂度O（1））
//主要消耗时间在查找上
    if (i < 1)
        return nullptr;
    LinkList p = GetElem(L, i - 1);    //找到要插入的位置的前驱结点
    LinkList s;
    s = (LinkList) malloc(sizeof(LNode));   //新建一个结点放要插入的值
    s->data = e;
    s->next = p->next;  //对位置i的前驱结点后插操作
    p->next = s;
    return L;
//法二：
//可以直接把值插在位置i结点的后面，然后交换值(时间复杂度为O（1）)，假设已经知道i位置的结点Q,插入其前面的结点为s
//    s->next = Q->next;
//    Q->next = s;
//    ElemType temp = Q->data;
//    Q->data = s->data;
//    s->data = temp;
}
  • 删除位置i结点操作
LinkList ListDelete(LinkList &L, int i) {
//法一：
//
    LinkList p = GetElem(L, i - 1); //寻找前驱结点
    LinkList q = p->next;   //把q指向要删除结点
    p->next = q->next;
    ElemType e = q->data;
    free(q);    //释放存储空间
    return L;
//法二：
//假设要删除Q点，可以把后继结点的值赋给自身（时间复杂度为O（1））
//    q = Q->next;
//    Q->data = Q->next->data;
//    Q->next = q->next;
//    free(q);
}
  • 求表长长度
ElemType ListLength(LinkList L) {
    int count = 0;
    LinkList p = L;
    if (p->next == nullptr)
        return 0;
    while (p->next != nullptr) {    //（p->next != nullptr指下一个结点， p != nullptr指当前结点）
        p = p->next;
        count++;
    }
    cout << "个数为：" << count << endl;
    return count;
}
  • 输出链表（针对有头结点的）
void List_show(LinkList &L) {
    if (L->next == nullptr)
        return;
    LinkList p = L;
    p = p->next;
//    do {
//        cout << p->data << " ";
//        p = p->next;
//    } while (L->next != nullptr);
    int m = ListLength(L);
    for (int i = 0; i < m; i++) {
        cout << p->data << " ";
        p = p->next;
    }
}

2. 双链表

typedef struct DNode {
    ElemType data;
    struct DNode *prior, *next;
} DNode, *DLinkList;
  • 双链表的插入操作(头插法)
DLinkList DListInsert(DLinkList &L, int i, ElemType e) {
    DLinkList p = DGetElem(L, i - 1);   //在p后面插入s
    DLinkList s;
    s = (DLinkList) malloc(sizeof(DNode));
    s->next = p->next;
    p->next->prior = s;
    s->prior = p;
    p->next = s;
    return L;
}
  • 双链表的删除操作(头插法)
DLinkList DListDelete(DLinkList &L, int i) {
    DLinkList p = DGetElem(L, i - 1);   //在p后面删除q
    DLinkList q = p->next;
    p->next = q->next;
    q->next->prior = p;
    free(q);
    return L;
}

3. 循环单/双链表

/*
void 判空() {
	LinkList M;
	DLinkList L;

M->next == M;		//循环单链表判空

L->next == L;
L->prior == L;		//循环双链表判空

}
*/

4. 静态链表，用数组实现链式的存储方式(适用于不借助指针)

typedef struct SDNode {
    ElemType data;
    int next;
} SLinkList[MaxSize];

6. 练习题

//设计一个递归算法，删除不带头结点的单链表L中所有值为x的结点
void test1_Delete_x(LinkList &L, ElemType x) {
//法一：交换前后值删除结点
    if (L->next == nullptr)
        return;
    if (L->data == x) {
        LinkList p = L->next;
        L->data = L->next->data;
        L->next = p->next;
        free(p);
        test1_Delete_x(L, x);
    } else {
        test1_Delete_x(L->next, x);     //这里不能先让 L=L->next，再把L代入test1_Delete_x，会导致所有结果都会消失，
    }
//法二：直接删除结点
//    LinkList p;
//    if (L->next == nullptr)
//        return;
//    if (L->data == x) {
//        p = L;
//        L = L->next;
//        free(p);
//        test1_Delete_x(L, x);
//    } else
//        test1_Delete_x(L->next, x);   //这里不能先让 L=L->next，再把L代入test1_Delete_x，会导致所有结果都会消失，
}

//在带头结点的单链表L中，删除所有值为x的结点，释放其空间
void test2_Delete_x(LinkList &L, ElemType x) {
//法一：由p从头扫描到尾，每一次都要连接前驱和后继
    if (L->next == nullptr)
        return;
    LinkList p = L->next;
    LinkList pre = L;   //pre作为p的前驱，起连接作用
//    int Len = ListLength(L);
//    for (int i = 0; i < Len; i++) {
    while (p != nullptr) {
        if (p->data == x) {
            LinkList q = p;
            p = p->next;
            pre->next = p;
            free(q);
        } else {
            pre = p;
            p = p->next;
        }
    }
//法二：采用尾插法建立单链表
//    LinkList p = L->next, r = L, q;
//    while (p != nullptr) {
//        if (p->data != x) {
//            r->next = p;
//            r = p;
//            p = p->next;
//        } else {
//            q = p;
//            p = p->next;
//            free(q);
//        }
//    }
//    r->next = nullptr;
}

//L为带头结点的单链表，实现反向输出每个结点的值
//本题为递归思想，也可以用逆置法，相当于尾插法
void test3_Reverse_output(LinkList L) {
    if (L->next != nullptr)
        test3_Reverse_output(L->next);
    cout << L->data << " ";
}

//带头结点的单链表L，删除其最小值的结点
LinkList test4_Delete_min(LinkList &L) {
    LinkList pre = L, p = pre->next, minpre = pre, minp = p;
    while (p != nullptr) {
        if (p->data < minp->data) {
            minp = p;
            minpre = pre;
        }
        pre = p;
        p = p->next;
    }
    minpre->next = minp->next;
    free(minp);
    return L;
}

//将一个带头结点的单链表就地逆置，即空间复杂度为O（1），即不能新建一个链表
LinkList test5_Reverse_Local(LinkList &L) {
//法一：先把头结点摘下来，然后用头插法的方法从第一个结点开始吧结点插在头结点的后面
//    LNode *p, *r;
//    p = L->next;
//    L->next = nullptr;        //把头结点摘下
//    while (p != nullptr) {
//        r = p->next;
//        p->next = L->next;
//        L->next = p;
//        p = r;
//    }
//    return L;
//法二：把各结点的指针反向指
    LNode *pre, *p = L->next, *r = p->next;
    p->next = nullptr;      //这个要作为尾结点
    while (r != nullptr) {
        pre = p;
        p = r;
        r = r->next;
        p->next = pre;
    }
    L->next = p;
    return L;
}

//使一个带头结点的单链表有序递增
void test6_increasing_order(LinkList &L) {
    LinkList p = L->next, pre;
    LinkList r = p->next;   //r始终要为p的后继结点
    p->next = nullptr;      //从原链表断开，和头结点构造一个有序的链表
    p = r;      //令p指针指回还未排序的原链表
    while (p != nullptr) {
        r = p->next;
        pre = L;    //pre始终要从头结点开始
        while (pre->next != nullptr && p->next->data < p->data)
            pre = pre->next;
        p->next = pre->next;
        pre->next = p;
        p = r;    //令p指针指回还未排序的原链表
    }
}

//带头结点的无序单链表L，删除所有值在（s， e）之间的元素，不包括s和e
void test7_Delete_s_e(LinkList &L, ElemType s, ElemType e) {
    LinkList p = L->next, pre = L;
    if (L->next == nullptr)
        return;
    while (p != nullptr) {
        if (p->data > s && p->data < e) {
            LinkList q = p;
            p = p->next;
            pre->next = p;
            free(q);
            //或者
//            pre->next = p->next;
//            free(p);
//            p = pre->next;
        } else {
            pre = p;
            p = p->next;
        }
    }
}

//给定两个单链表，找出两个链表的公共结点(公共结点指某一时刻两个链表的某个节点->next会指向同一个结点，
// 并且之后的结点都是公共的，直到尾结点,会形成一个 Y 型)
//暴力法：逐个检查,时间复杂度为O（n?）
//线性时间复杂度法O（len1+len2）：先求出长度差，减去差后同步寻找
LinkList test8_find_common_LNode(LinkList L1, LinkList L2) {
    int len1 = ListLength(L1), len2 = ListLength(L2);
    LinkList longList, shortList;
    int dist;
    if (len1 > len2) {
        longList = L1->next;
        shortList = L2->next;
        dist = len1 - len2;
    } else {
        longList = L2->next;
        shortList = L1->next;
        dist = len2 - len1;
    }
    while (dist--)
        longList = longList->next;
    while (longList != nullptr) {
        if (longList == shortList)
            return longList;
        else {
            longList = longList->next;
            shortList = shortList->next;
        }
    }
    return nullptr;
}
素履、
关注
  • 0
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构链表实现
哆啦咪~fo
08-21 270
主要实现了链表的增加、删除、查找结点，逆置链表，求两个链表的交集、并集和差集，以及对链表排序 package SqList_Operator; import java.text.MessageFormat; public class LinkListTool { public LinkListTool(){ } public int getListLength(LinkLis
数据结构--单链表
abc_xian的博客
08-28 381
带头结点的单链表简单操作： # include <malloc.h> # include <stdio.h> # include <iostream> using namespace std; typedef struct node { int data; struct node* next; }Lnode,*Linklist; int L...
链表-单链表
qwe954443563的博客
11-24 159
线性表-链式储存（链表） 链表的优点是容易扩展容量，缺点是不易进行随机存储，即读取某个元素时，需要从第一个元素开始慢慢读取。 链表可分为单链表、双链表、循环链表和静态链表。 1. 单链表 1.1 单链表定义 单链表中每个数据内存中不只存放着单个元素的数据元素，还存放着指向下一个节点的指针。 1.1.1 单链表定义代码 //c++代码 struct LNode { int data; //存放数据 LNode * next;//指向下一个节点的指针 }; 1.2单链表的插入和删除 1.2.1 按位序插入
单链表的遍历与长度计算
Lucky
08-08 1582
#include using namespace std; typedef struct Node { int val; Node *next; }node; int sum; node* mycreat(int n) { node *head=NULL,*p=NULL,*ne=NULL; head=(node*)malloc(sizeof(node));
数据结构:求单链表(有头节点)长度
热门推荐
匿名攻城狮
03-13 2万+
- 单链表的长度求法与顺序表不同(顺序表有现成的函数length()),下面是求单链表长度的两种方法。 方法一: Status Length_L(LinkList L,int &amp;e) { LinkList p=L-&gt;next;//定义头指针 int j=1;//定义j来计数 while(p)//while(p!=NULL) { p=p-&gt;next;//指针向.........
数据结构链式表，c语言简单实现
01-12
数据结构链式表，c语言简单实现
数据结构链式表
10-18
用C实现的数据结构课程中的链式表，实现初始化、插入删除、取前去后继等操作
php数据结构之顺序链表与链式线性表示例
10-18
主要介绍了php数据结构之顺序链表与链式线性表,结合实例形式较为详细的分析了php实现顺序链表与链式线性表的各种常用操作技巧,需要的朋友可以参考下
C++数据结构之链式队列实现
09-20
链式队列c++模版实现，功能：创建，删除，出入队，修改元素，包含测试代码。
链式表的运算实现(带头结点的链式表)
03-30
内容概要：内含带头结点的链式表的运算实现和使用方式，包括创建、删除、添加、插入、修改等 能学到什么：了解和使用带头结点的链式表，与不带头结点的链式表以此做出更好的区分和理解 阅读建议：建议先能够掌握一定...
程序员面试宝典（第三版）——单链表的基本操作：建立，求长度，输出，排序，插入，删除，逆置
看见阳光就微笑的专栏
07-27 1826
总结：单链表的基本操作，包括建立单链表，对单链表求长度，打印输出单链表，对单链表进行排序，删除元素，插入元素，对单链表逆置。这些操作都是程序员必须掌握的，虽然它是一种相对简单的数据结构，但是能够做到熟练掌握运用也是需要花时间的。
数据结构与算法——单链表
Mr_Wuyan的博客
09-20 361
C语言数据结构与算法 单链表的插入，删除以及计算长度。 #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; typedef struct lista{ struct lista *next; int data; }list; void insert(list *h); void del(list *h); int main() { ...
求单链表长度（C语言）
像鱼的博客
05-03 8412
#include <stdio.h> #include <stdlib.h> // 求链表长度 // 定义链表类型 typedef struct Node { int data; struct Node *next; }Node,*LinkList; // 初始化 LinkList initList () { LinkList L = (Node *) malloc (sizeof(Node)); L->next = NULL; .
C语言单链表
sdaujz的博客
03-27 215
单链表的增删查操作 #include <stdio.h> #include <malloc.h> #include <stdlib.h> #define OK 0 #define TRUE 1 #define ERROR -1 #define OVERFLOW -2 #define LIST_INIT_SIZE 10 #define LISTINCREAMENT 2 /*单链表的建立*/ typedef struct LNode { char data;
数据结构笔记（五）-- 循环链表的实现
m0_43609475的博客
05-28 1040
单循环链表的实现 1、构造一个空的线性表L void InitList(LinkList &L)//传递实参而非形参 {// 操作结果：构造一个空的线性表L L = (LinkList)malloc(sizeof(LNode));// 产生头结点，并使L指向此头结点 if (L == NULL) { printf("内存分配是失败，退出程序\n"); exit(-1); } L->next = L; // 指针域指向头结点 } 2、判断单循环链表是否为空 如果单循环链表为
单链表的基本操作C语言详解
学习笔记，仅供参考
03-21 6528
1. 单链表：单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。 2. 头指针：是指向头结点的指针，无论链表是否为空，头指针均不为空。 3. 头结点：放在第一个结点之前的结点（“零结点”），数据域可以不存放东西，也可以存放链表信息（如链表长度）。 单链表的存储结构 typedef struct Node //单链表的存储结构，Node是结构体类型名，"s...
Java实现快速排序
最新发布
liuhaikang的博客
06-11 343
方法是快速排序的核心，它选择一个基准值（在这个例子中是最右侧的元素），然后重新排列数组，使得所有小于基准值的元素都出现在基准值的左侧，所有大于基准值的元素都出现在基准值的右侧。快速排序（Quick Sort）是一种高效的排序算法，它采用分治的思想。方法，它是快速排序的主要方法。该方法接受一个数组和左、右索引作为参数，并使用递归对数组进行排序。方法中，我们创建了一个测试数组并调用。方法用于交换数组中的两个元素。这个代码首先定义了一个。
数据结构链式表合并两个表
03-25
A：链式表合并是指将两个链式表按有序排列依次合并成一个链式表。具体操作步骤如下： 1. 定义一个新的链式表作为合并后的结果链表； 2. 分别从两个原始链式表的头结点开始，比较两个结点的值的大小，将值较小的结点...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

素履、

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

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

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

打赏作者

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

抵扣说明：

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

余额充值