链表剖析之单链表剖析(二)

最新推荐文章于 2023-06-16 18:13:07 发布
最新推荐文章于 2023-06-16 18:13:07 发布
阅读量895 收藏 1
点赞数 1
分类专栏： 经典数据结构剖析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qzyf1992/article/details/18923413
版权

微笑代码依旧用c#的写的增加了修改删除合并的方法，我会坚持写下去,如有不对 之处希望大家斧正，注释写的比较详细。有什么问题欢迎留言。

链表节点类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 线性表ccc
{
    public class MyLinkListNode<T>
    {
        public MyLinkListNode()
        {
        
        }
        public T data;
        public MyLinkListNode(T data)
        {
            this.data = data;
        }
        //下一个节点
        public MyLinkListNode<T> next;

    }
}


链表类

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 线性表ccc
{
    public class MyLinkList<T> 
    {
        //链表长度
       private int count;

        public int Count
        {
            get { return count; }
        }
        //链表头
        MyLinkListNode<T> head;
        public MyLinkList()
        {
            head = new MyLinkListNode<T>();
            head.next = null;
        }
        public MyLinkList(T[] nums):this()
        {
            AddItem(nums);
        }
        /// <summary>
        /// 增加一组数组到链表里
        /// </summary>
        /// <param name="nums"></param>
        private void AddItem(T[] nums)
        {
            foreach (T item in nums)
            {
                AddObject(item);
            }
        }
        /// <summary>
        /// 把一个节点加到头节点后面
        /// </summary>
        /// <param name="item"></param>
        private void AddObject(T item)
        {
            //这里给单链表开辟了表长的空间
            MyLinkListNode<T> p = new MyLinkListNode<T>();
            p.data = item;
            //设置原来的父节点的子节点为 现子节点的父节点
            p.next = head.next;
            //建立头节点与子节点的关系
            head.next = p;
            count++;
        }
        /// <summary>
        /// 获取链表某个位置的元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T GetElem(int index)
        {
            MyLinkListNode<T> p = head.next;
            int j = 0;
            while(p!=null&&index>j)
            {
                p = p.next;
                j++;
            }
            if (p==null||j>index)
            {
                throw new Exception("超出界限");
            }
            return p.data;
        }
        /// <summary>
        /// 向链表插入一个元素
        /// </summary>
        /// <param name="index"></param>
        /// <param name="elem"></param>
        /// <returns></returns>
        public void InsertElem(int index,T elem)
        {
            MyLinkListNode<T> p = head;
            int j = 0;
            if (index>=count)
            {
                throw new Exception("插入的索引超界");
            }

            while (p != null&&index>j)
            {
                p = p.next;
                j++;
            }
            MyLinkListNode<T> newnode = new MyLinkListNode<T>(elem);
            //让它指向原来上一个节点指向的元素
            newnode.next = p.next;
            //让老节点指向插入的新节点
            p.next = newnode;
            count++;
        }
        /// <summary>
        /// 删除一个元素
        /// </summary>
        public void DeleteElem(int index)
        {
            //把头节点赋值给一个临时节点
            MyLinkListNode<T> p = head;
            int j = 0;
            // =的情况也不行因为链表最多取到count - 1
            if (index > count)
            {
                throw new Exception("删除的索引超界");
            }
            //取到删除节点的上一个节点
            while (p != null&&index > j)
            {
                p = p.next;
                j++;
            }
            //删除P.next让p.next指向p.next的next; 此时原来的p.next没有引用会被GC自动销毁
            p.next = p.next.next;
            //删除之后count要-1
            count--;
            //GC.Collect();
        }
        /// <summary>
        /// 修改链表index位置的值
        /// </summary>
        /// <param name="index"></param>
        /// <param name="elem"></param>
        public void UpDateElem(int index,T elem)
        {
            MyLinkListNode<T> p = head;
            // =的情况也不行因为链表最多取到count - 1
            if (index >= count)
            {
                throw new Exception("删除的索引超界");
            }
            int j = 0;
            //定位要要修改的位置
            while (index >= j)
            {
                p = p.next;
                j++;
            }
            p.data = elem;
        }
        /// <summary>
        /// 把La和Lb归并成一个单链表,由于不知道类型传一个回调函数进来
        /// </summary>T
        /// <param name="ListA"></param>
        /// <param name="ListB"></param>
        /// <returns></returns>
        public MyLinkList<T> MergeList(MyLinkList<T> La,Func<T,T,bool> func)
        {
            MyLinkList<T> Lc = new MyLinkList<T>();
            Lc.count = La.count + count;
            MyLinkListNode<T> pa, pb, pc;
            pb = La.head.next;
            pa = this.head.next;
            //Lc.head和pc指向同一片空间
            pc = Lc.head;
            while (pa != null && pb!=null)
            {
                //如果pa<=pb
                if (func(pa.data,pb.data))
                {
                    pc.next = pa;
                    //让pc指针前移
                    pc = pa;
                    //pa的指针前移
                    pa = pa.next;
                }
                else
                {
                    pc.next = pb;
                    pc = pb;
                    pb = pb.next;
                }
            }
            if (pb != null)
            {
                //1次就Pb后面链着的都归了pc
                pc.next = pb;
                //这时候pc的指针也得前移
                pc = pc.next;
            }
            else
            {
                pc.next = pa;
                pc = pc.next;
            }
            return Lc;
        }
        public override string ToString()
        {
            StringBuilder sb = new StringBuilder();
            MyLinkListNode<T> p = head.next;
            while (p != null)
            {
                sb.Append(p.data + " ");
                p = p.next;
            }
            return sb.ToString();
        }

    }
}

实际上操作 都是引用的各种变换 。

测试代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace 线性表ccc
{
    class Program
    {
        static void Main(string[] args)
        {
            Console.WriteLine("请输入测试数组类似5 4 3");
            string[] s = Console.ReadLine().Split(' ');
            int[] nums = new int[s.Length];
            for (int i = 0; i < s.Length; i++)
            {
                nums[i] = Convert.ToInt32(s[i]);
            }
            //初始化的时候存的类似于 3=>4=>5
            MyLinkList<int> ml = new MyLinkList<int>(nums);
            Console.WriteLine("链表输出的结果是");
            Console.WriteLine(ml.ToString());
            while (true)
            {
                Console.WriteLine("请输入插入的位置");
                int indexInsert = int.Parse(Console.ReadLine());
                Console.WriteLine("请输入插入的值");
                int value = int.Parse(Console.ReadLine());
                ml.InsertElem(indexInsert, value);
                Console.WriteLine("打印链表结果");
                Console.WriteLine(ml.ToString());
                Console.WriteLine("请输入要删除的索引");
                int indexDel = int.Parse(Console.ReadLine());
                ml.DeleteElem(indexDel);
                Console.WriteLine(ml.ToString());
                Console.WriteLine("请输入要修改的索引");
                int indexUpdate = int.Parse(Console.ReadLine());
                Console.WriteLine("请输入要修改的值");
                int valueUpdate = int.Parse(Console.ReadLine());
                ml.UpDateElem(indexUpdate, valueUpdate);
                Console.WriteLine("打印链表结果");
                Console.WriteLine(ml.ToString());
                Console.WriteLine("请输入链表B类似5 4 3");
                string[] sB = Console.ReadLine().Split(' ');
                int[] numsB = new int[sB.Length];
                for (int i = 0; i < s.Length; i++)
                {
                    numsB[i] = Convert.ToInt32(sB[i]);
                }
                MyLinkList<int> mlB = new MyLinkList<int>(numsB);
                MyLinkList<int> mlC = ml.MergeList(mlB, (x,y)=>x<=y);
                Console.WriteLine("合并两个链表的结果是");
                Console.WriteLine(mlC.ToString());
                Console.WriteLine();
            }
        }  
    }
}


结果如图:

算法分析:

删除要找到 删除节点的前一个节点 故一次循环时间复杂度是O(n)

修改也要找到删除节点 时间复杂度也是O(n)

合并操作一共循环m+n次 时间复杂度是O(m+n) 即O(n)

最后更正一下上一篇的一个错误 遍历的时间复杂度是O(n) 不需要循环GetElem详细代码 请参考 这篇里MyLinkList 重载的ToString()方法


 

qzyf1992
关注
专栏目录
数据结构~~~线性表复习2（动态链表的合并）
aooubei7175的博客
07-27 104
// 线性表（链表）.cpp: 定义控制台应用程序的入口点。 // #include "stdafx.h" #include"iostream" using namespace std; template<class T> struct Node { T data; Node *next; }; template<cla...
一文搞懂链表结构（单链表、双链表、循环链表、删除、添加、内存结构）
w20001118的博客
07-24 782
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）。链接的入口节点称为链表的头结点也就是head。所以链表中的节点在内存中不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。数组是在内存中是连续分布的，但是链表在内存中可不是连续分布的。链表是通过指针域的指针链接在内存中各个节点。...
04-常见的链表操作 之 单链表反转
其木王·王子的博客
03-15 1537
单链表反转1. 几个常见的链表操作2.单链表反转 1. 几个常见的链表操作 需要把这几个操作都能写熟练，不熟就多写几遍，我保证你之后再也不会害怕写链表代码。 单链表反转 链表中环的检测 两个有序的链表合并 删除链表倒数第 n 个结点 求链表的中间结点 2.单链表反转 题目描述 反转一个单链表。 示例 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 思路分析 1）根据题目给出的输入示例，构造出下的链
【数据结构】单链表与双链表
鲑鱼弥勒的博客
03-20 1113
1.和数组一样，链表也是一种线性表。2.从内存结构来看，链表的内存结构是不连续的内存空间，是将一组零散的内存块串联起来，从而进行数据存储的数据结构。3.链表中的每一个内存块被称为节点Node。节点除了存储数据外，还需记录链上下一个节点的地址，即后继指针next。
[数据结构]链表之单链表
最新发布
beenles的博客
06-16 658
单链表是一种常见的线性数据结构，由若干个节点组成，每个节点包含两部分：数据元素和指向下一个节点的指针。每个节点只有一个指针，通常称为 next 指针，它指向该节点的后继节点。头节点是第一个节点前面额外添加的一个节点，它不包含数据元素，但是包含对第一个节点的指针。单链表可以表示任意长度的序列，可以动态地插入、删除节点，使其具有灵活性和高效性。但由于每个节点只有一个指针，因此单链表只能从前往后遍历，不能反向遍历。以下是单链表常用的操作：创建链表：创建一个空链表，可选是否带有头节点。
单链表和双链表
SHUIHAN_007的博客
04-06 2921
单链表 链表是有序的列表，但是它在内存中的存储如下： 链表是以节点的方式来存储, 是链式存储 每个节点包含 data 域（存储数据），next 域（指向下一个节点） 链表的各个节点不一定是连续存储 链表分为带头节点的链表和 没有头节点的链表，根据实际的需求来确定 单链表的应用实例 使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 可以考虑学员独立完成，也可带学员完成 1) 第一种方法在添加英雄时，直接添加到链表的尾部 第二种方式在添加英
循环链表详解(循环单链表/循环双链表)
Curz酥的博客
10-05 1万+
王道数据结构笔记
数据结构之链表（单链表）
u012977486的博客
02-02 675
单链表的物理结构 链表是有序的列表，但是它在内存中是存储如下
【链表】单链表的基本操作详解(C语言)
热门推荐
HongKnight的博客
06-01 4万+
本文是单链表的C语言实现方法，包括创建单链表结点、创建单链表、显示链表的数据、获取链表长度、在链表指定位置插入结点、删除指定位置的结点、查找链表中指定的数据、修改链表中指定位置结点的值、修改链表中指定数据的值。
循环单链表-双链表_循环单链表-双链表_throat6v2_
09-30
循环单链表和双链表是数据结构中的基础概念，它们在计算机科学中扮演着重要角色，尤其是在处理线性数据序列时。这两种链表都属于动态数据结构，因为它们允许在运行时添加或删除元素，而不需要预先知道数据的大小。 ...
C数据结构之单链表详细示例分析
01-21
//=============================================================// 语法格式： TYPE *init_link_head(int n)// 实现功能： 从头到尾，正序创建一个具有n个节点的链表，并对其值进行初始化// 参数： n: 链表的...
第二章——单链表和循环单链表
weixin_55835175的博客
09-17 2878
线性表——链表 顺序表需要事先占用一整块实现分配大小的存储空间，但是对于某些问题：很多空间只使用一次(甚至根本用不到)，使用顺序表存储空间的利用率往往很低。于是需要一种能够动态管理存储空间的存储结构——链表。 线性表的链式存储结构——链表 线性表的链式存储结构我们简称为链表。其中每个存储结点不仅包含元素本身的信息(称为数据域)，而且包含表示元素之间逻辑关系的信息，在C和C++中用指针实现，称为指针域。 一种最常见，最基本的方法是在每个结点除包有数据域以外只设置一个指针域，用于指向其后继结点，这样构成的链表
c语言建立字符链表,c语言单链表的创建，字符串搜索
weixin_42469315的博客
05-17 990
最近在写课程设计，奈何本人水平有限，查询了各个大佬们博客的写法，最终还算是完成了，下面分享下单链表的创建，删除，搜索的代码。一，创建和尾插struct Node{char id[10];struct Node *next;};typedef struct Node ListNode;ListNode* CreatList(ListNode*p)//创建链表{ListNode *head;//指向头...
特殊的线性结构--队列
qzyf1992的专栏
03-02 1444
c#数据结构
特殊线性结构--栈
qzyf1992的专栏
02-19 1134
栈也是一种线性结构。内部是对线性表或者链表的封装。栈有着先进先出的特性。如图   源码实现代码依旧是用c#写的 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 栈队列 { pu
链表剖析之双向链表剖析
qzyf1992的专栏
02-05 983
双向链表 和单链表不同的是每个节点增加了一个前驱 如图 这里我暂时 不涉及到循环链表 链表节点结构如下      using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace 双向链表 {
链表剖析之单链表剖析(一)
qzyf1992的专栏
02-02 962
最近 发现学习算法发现到一个瓶颈了。所以又开始学习大学时学习的数据结构了 参考的是严蔚敏的数据结构了，然分享一些心得给大家分享,代码用c#写的写的不好之处请各位道友指出来. 线性表结构如图 这里有个头节点。单链表的能够拿到的就是头节点 构造链表节点类如下 using System; using System.Collections.Generic; using System.Linq;
双向链表与单链表：操作与实现分析
"这篇资料主要介绍了双向链表的操作特点，并对比了链表和顺序存储结构的优缺点，同时还深入讲解了单链表的定义、结构以及C语言中的描述方法。内容涵盖线性表的链式存储实现，包括插入、删除等操作的算法描述。" ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值