单链表：添加、查找、删除、插入、查找倒数第k个

最新推荐文章于 2022-07-02 15:02:52 发布
最新推荐文章于 2022-07-02 15:02:52 发布
阅读量435 收藏 2
点赞数 1
分类专栏： 数据结构 文章标签： 数据结构 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/thegodofcloud/article/details/110096167
版权

链表的基本操作

/*1.2-a-f 链表

    void createLink();				//1.2-a 以表尾添加结点的方式构建链表
    int findNode(const T& value);	//1.2-b 查找值为value的结点，返回第一个值为value的结点位置，若不存在返回-1
    void deleteValue(const T& value);//1.2-c 删除所有值为value的结点
    bool insertPos(const int i, const T value); //1.2-d 在指定位置插入结点
    bool deletePos(const int i);				//1.2-e 删除指定位置的结点
    int reFindPos(const int K);     //1.2-f 查找倒数第K个结点

*/
#include <iostream>
using namespace std;

template <class T>
class LinkNode {
public:
    T data; //数据域
    LinkNode<T>* link; //指向后继指针的结点
    LinkNode()
    {
        data = 0;
        link = NULL;
    }
    LinkNode(const T& el)
    {
        data = el;
        link = NULL;
    }
};

template <class T>
class LinkList {
private:
    LinkNode<T>* head, * tail; //表头和表尾指针
public:
    LinkList()
    {
        head = tail = NULL;
    }
    ~LinkList()
    {
        clear();
    }
    void createLink(); //1.2-a 以表尾添加结点的方式构建链表
    int getSize() const; //返回链表中的元素个数
    bool isEmpty() const; //链表是否为空
    void clear(); //清空链表：释放所有结点的内存空间

    int findNode(const T& value); //1.2-b 查找值为value的结点，返回第一个值为value的结点位置，若不存在返回-1
    void deleteValue(const T& value); //1.2-c 删除所有值为value的结点
    LinkNode<T>* setPos(int pos); //返回指定位置pos的指针
    bool insertPos(const int i, const T value); //1.2-d 在指定位置插入结点
    bool deletePos(const int i); //1.2-e 删除指定位置的结点
    int reFindPos(const int K); //1.2-f 查找倒数第K个结点
    void printList(); //输出链表
};

/*
TODO:1.2-a 以表尾添加结点的方式构建链表,输入为0时，链表构建结束。
 */
template <class T>
void LinkList<T>::createLink()
{
    LinkNode<T>* s = new LinkNode<T>;
    LinkNode<T>* p;
    this->head = s;
    this->tail = s;
    this->tail->link = NULL;
    cout << "输入以 0 为结束" << endl;
    T value;
    cin >> value;
    if (value == 0)
        return;
    s->data = value;
    cin >> value;
    while (value != 0 && value != '0') //输入为0时，链表构建结束
    {
        //TODO:构建链表
        LinkNode<T>* p = new LinkNode<T>(value);
        this->tail->link = p;
        tail = p;
        cin >> value;
    }
}

//返回链表中的元素个数
template <class T>
int LinkList<T>::getSize() const
{
    int count = 0;
    LinkNode<T>* p = head->link;
    if (isEmpty())
        return 0;
    while (p != NULL) {
        p = p->link;
        count++;
    }
    return count;
}

//链表是否为空
template <class T>
bool LinkList<T>::isEmpty() const
{
    if (head->link == NULL) {
        return true;
    }
    return false;
}

//清空链表：释放所有结点的内存空间
template <class T>
void LinkList<T>::clear()
{
    LinkNode<T>* p;
    while (head != NULL) {
        p = this->head;
        head = this->head->link;
        delete p;
    }
    head = tail = NULL;
}

/*
TODO:1.2-b 查找值为value的结点，返回第一个值为value的结点位置，若不存在返回-1。
比如：假如第一个元素就是value，则返回0，依次类推
返回值说明：返回第一个值为value的结点位置，若不存在返回-1。
 */
template <class T>
int LinkList<T>::findNode(const T& value)
{
    LinkNode<T>* p = this->head;
    int count = -1;
    if (p->data == value)
        return count++;
    while (p->link)
    {
        count++;
        if (p->data == value)
            return count;
        p = p->link;
    }
    if(p==tail)
    return -1;
}

/*
TODO:1.2-c 删除所有值为value的结点

 */
template <class T>
void LinkList<T>::deleteValue(const T& value)
{
    LinkNode<T>* p = this->head;
    LinkNode<T>* s = this->head;
    if (p == head && p->data == value)
    {
        head = p->link;
        delete p;
    }
    p = p->link;
    while (this->findNode(value) != -1)
    {
        if (p->data == value)
        {
            if (p == tail)
            {
                s->link = NULL;
                tail = s;
                delete p;
            }
            else
            {
                s->link = p->link;
                delete p;
                break;
            }
        }
        p = p->link;
        s = s->link;
    }

}

//返回指定位置pos的指针
template <class T>
LinkNode<T>* LinkList<T>::setPos(int pos)
{
    if (pos == -1)
        return head;
    int count = 0;
    LinkNode<T>* p = this->head->link;
    while (p != NULL && count < pos) {
        p = p->link;
        count++;
    }
    return p;
}

/*
TODO:.2-d 在指定位置i插入值为value的结点，比如：i为0，表示在链表头部插入
返回值说明：如果成功插入，则返回true，否则，返回false。
注意事项：假如插入的位置i非法，即位置i处不能进行插入操作，则打印cout << "插入操作不允许" << endl;并返回false。
 */
template <class T>
bool LinkList<T>::insertPos(const int i, const T value)
{
    LinkNode<T>* p, * s, * n;
    int num = this->getSize();
    if (i > num + 1)
    {
        cout << "插入操作不允许" << endl;
        return false;
    }
    else
    {
        p = this->setPos(i);
        s = this->setPos(i - 1);
        n = new LinkNode<T>;
        n->data = value;
        if (i == 0)
        {
            n->link = head;
            head = n;
        }
        else if (i == num + 1)
        {
            tail->link = n;
            tail = n;
        }
        else
        {
            s->link = n;
            n->link = p;
        }
        return true;
    }

}

/*
TODO:1.2-e 删除指定位置i处的结点
返回值说明：成功删除结点，则返回true，否则返回false。
注意事项：如果位置i处没有元素，则打印cout << "非法删除点" << endl;并返回false
 */
template <class T>
bool LinkList<T>::deletePos(const int i)
{
    LinkNode<T>* p, * s;
    int num = this->getSize();
    if (i < 0 || i>num)
    {
        cout << "非法删除点" << endl;
        return false;
    }
    else
    {
        p = this->setPos(i);
        s = this->setPos(i - 1);
        if (i == 0)
        {
            head = p->link;
            delete p;
        }
        else if (i == num)
        {
            tail = s;
            s->link = NULL;
            delete p;
        }
        else
        {
            s->link = p->link;
            delete p;
        }
        return true;
    }

}

/*
TODO:1.2-f 查找倒数第K个结点,并返回它的值。比如：K为1，表示要查找的元素是倒数第1个，也即是链表最后一个元素
返回值说明：如果查到到倒数第K个结点，则返回它的值，否则返回-1
注意事项：1）如果输入的K非法，即小于等于0，则打印cout << "非法输入" << endl;并返回-1
         2）如果输入的K非法，即大于链表长度，则打印cout << "表长不够" << endl;并返回-1
 */
template <class T>
int LinkList<T>::reFindPos(const int K)
{
    LinkNode<T>* p = head;
    int count = -1;
    if (K < 0)
    {
        cout << "非法输入" << endl;
        return count;
    }
    else if (K > this->getSize())
    {
        cout << "表长不够" << endl;
        return count;
    }
    else
    {
        while (p)
        {
            if (count + K == this->getSize())
                return p->data;
            p = p->link;
        }
    }
}

template <class T>
void LinkList<T>::printList()
{
    LinkNode<T>* p = this->head;
    while (p != NULL) {
        cout << p->data << " ";
        p = p->link;
    }
    cout << endl;
}

int main()
{
    LinkList<int> l;
    l.createLink(); //创建链表
    l.printList();
    int value0, value1, value2, pos0, pos1, pos2;
    cin >> value0 >> value1 >> value2 >> pos0 >> pos1 >> pos2;
    cout << "值为" << value0 << "的结点位置：" << l.findNode(value0) << endl;
    l.deleteValue(value1); //删除值为value1的结点
    l.printList();
    l.insertPos(pos0, value2); //在pos0处插入值为value2的结点
    l.printList();
    l.deletePos(pos1); //删除pos1处的元素
    l.printList();
    cout << "倒数第" << pos2 << "个结点的值" << l.reFindPos(pos2) << endl; //查找倒数第pos2所表示的位置处的元素
    return 0;
}
TheGodOfCloud
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
单链表的基础操作
阿劼
05-02 194
单链表：又名单向链表、线性链表，是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过从头部开始，依序往下读取。 单向链表的数据结构可以分为两部分：数据域和指针域，数据域存储数据，指针域指向下一个储存节点的地址。 下面以具体程序看看单链表的各种操作： 基本操作：头插法、尾插法、指定位置插入元素、求长度、求倒数第k个元素、链表逆置。 class Link{ E...
线性表——单链表的增删改查（头插法，尾插法，按序号查找，按值查找，某个位置插入元素，某个位置删除元素）
weixin_46398446的博客
01-04 1463
目录一、链表的特点二、链表的特点三、代码实现结构体1.头插法打印链表完整代码 一、链表的特点 逻辑上相邻的两个元素在物理位置上不相邻。 二、链表的特点 两部分组成：数据域data和指针域next。最后一个为NULL。 三、代码实现 结构体 typedef int ElemType; // 定义结构体 typedef struct LNode { ElemType data; // 数据域 struct LNode* next; // 定义结构体指针，指向下一个结点。因为从上往下编译，所以不能
单链表的基本操作(增删改查）
uiiiiii的博客
11-28 331
对于单链表的创建上篇文章我们已经写过了，但是在这还为大家展示一下尾插法创建链表： 首先定义一个头指针，接下来为新的节点开辟空间，并让头指针等于它： 接下来再创建新的节点并让前一个节点变为旧的结点，并让旧节点中的指针指向新节点： 然后就是不断重复上述第二步。 struct notes { int n; struct notes *next; }; int cnt;//定义一个整型变量用来计算结点的数量 struct notes*create() { struct ..
自己手动实现单链表的头插 、尾插、删除、逆置、倒数第K个节点、判断是否有环、求其入口点、合并有序单链表
weixin_44579258的博客
05-20 161
class Link<T extends Comparable<T>> { /** * 单链表的节点类型 * @param <T> */ static class Entry<T> { T data; // 链表节点的数据域 Entry<T> next; //...
单向链表基础操作（删除、插入、查询）代码实现及进阶（反转、排序、逆置、查找倒数第K个节点、查找中间节点）
Faded0104的博客
08-10 280
single_linked_list.h /* **功能：应用C语言实现单链表的各项操作 ** 1：建立节点 ** 2：打印单链表 ** 3：尾插 ** 4：尾删 ** 5：头插 ...
linux环境编译实现的单链表的常见操作
09-25
工作之余,温习了以前的数据结构,重新写了单链表的一些常见操作,如尾插法建表,查找中间元素和倒数第N个元素,单链表的就地逆置,有序单链表的合并等.该程序在linux环境下编译通过.
linked-list:C用于单链表和双链表
05-12
linked-list C for single linked list and double linked list single_list 结点结构体 创建结点 创建链表 显示链表的数据 获取链表长度 插入结点 ...查找倒数第K个结点 删除重复结点 查找中间结点
数据结构实验二（单链表基本操作）题目和源程序
04-02
实验内容 1．编写程序完成单链表的下列基本操作： (1)初始化单链表La。 (2)在La中第i个元素之前插入一个新结点。...（即最后一个结点变成第一个结点，原来倒数第二个结点变成第二个结点，如此等等。）
数据结构之单链表
05-28
包括如下操作：初始化、销毁、清空、求长度、遍历 指定位置插入和删除元素 ... 距离-标尺法：求单链表倒数第Ｎ个结点；求未知长度的单链表的中间结点； 建环／判断环存在 删除重复元素 合并两种有序单链表
合工大宣城校区数据结构实验报告_单链表.doc
09-26
"数据结构实验报告_单链表" 本实验报告的目的是熟练掌握线性表的链式存储...（3）设计一个算法来查找链表中倒数第 k 个位置上的结点。 在实验报告的结尾，我们需要总结实验的结果，并对实验的结果进行分析和讨论。
数据结构之单链表的简单操作（插入 删除 查找 撤销 打印）
qq_43060759的博客
10-11 1728
链接表首先要建立指针域和数据域，并用本节点的指针域指向下一个节点，对于链表的特点这里不做详细解释 1.建立指针域和数据域 typedef struct Noded{ struct Noded *next;//指针域 int data;//数据域 }Noded; 2.对链表进行初始化，链表为空（确保建立空链表） //链表初始化 void Init(Noded *head){ head...
LeetCode 剑指 Offer 22. 链表中倒数第k个节点（c语言实现）
qq_44243059的博客
07-02 405
LeetCode 剑指 Offer 22. 链表中倒数第k个节点（c语言实现）
寻找链表中倒数第K个位置的元素(只能遍历一遍)
weixin_46503238的博客
05-09 371
寻找链表中倒数第K个位置的元素(只能遍历一遍) 由于只能遍历一遍链表,我们无法先获取链表长度,在遍历到倒数第k个位置,这样的操作是遍历两次链表 用两个指针p、q其中p先走k步,然后q在和p同时走,当p到达结尾时,q正好在倒数第k个位置 实现代码 #include <stdio.h> #include <stdlib.h> #include<stdbool.h> typedef int Elemtype; typedef struct LNode { E
表尾插入法建立链表
云华100的专栏
08-04 1463
#include #include typedef struct node { int data; struct node *next; } Lnode, *LinkList; int len=sizeof(Lnode); void create(LinkList head); void disp(LinkList head); int main() {
【C语言】【链表】尾插法创建一个链表，并在指定位置插入一个结点
新手小白
06-30 990
Oj 期末考试倒数第二题 需要分类讨论 注意细节
最基本的单链表C++
mmdev
09-17 112
// 单链表.cpp -- 最基本的单链表C++ // Singly-linked list node template &lt;class Elem&gt; class Link { public: Elem element; // value for this node Link *next; // pointer to next node in list Link(...
数据结构与算法分析笔记与总结(java实现)--链表2：倒数第k个结点问题（k从1开始）
小菜鸟也想飞的博客
01-17 387
数据结构与算法分析(java实现)--链表2：输入一个链表，输出该链表中倒数第k个结点。（k从1开始）
1.2预备知识（链表指针）
瓜洲的博客
01-24 353
## 预备知识  1. **指针**    C语言的灵魂           定义             地址：                 内存单元的编号 （内存可被CPU直接访问，CPU不可直接访问硬盘）                 从0开始的非负整数                 范围;O~FFFFFFFF(0 ~ 4G-1)             指针：          ...
【数据结构】JAVA语言实现—顺序表和单链表的基本功能（附超详细注释）
潘潘的博客
11-13 1346
文章目录1、线性表2、顺序表2.1 概念及结构2.2 顺序表接口的实现2.2.1 打印顺序表2.2.2 在pos位置新增元素2.2.3 判定是否包含某个元素2.2.4 查找某个元素对应的位置2.2.5 获取 pos 位置的元素2.2.6 给 pos 位置的元素设为 value2.2.7 删除第一次出现的关键字key2.2.8 获取顺序表长度2.2.9 清空顺序表2.3 顺序表所存在的问题及思考3、链表3.1 链表的概念及结构3.2 链表的实现3.2.1 打印链表3.2.2 头插法3.2.3 尾插法3.2.
1. 建立单链表,并在单链表上实现插入、删除和查找操作
最新发布
05-19
下面我们来实现一个单链表，并在单链表上实现插入、删除和查找操作。 首先，定义一个节点类： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next ``` 每个...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值