数据结构（线性结构，单链表，双链表）

最新推荐文章于 2024-11-04 13:52:23 发布
最新推荐文章于 2024-11-04 13:52:23 发布
阅读量90 收藏
点赞数
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SeptemberTan/article/details/117258307
版权
本文详细介绍了三种常见数据结构的实现：线性表（顺序表和链表）、单链表以及双链表。内容包括它们的基本操作如添加、删除、查找等，并提供了具体的C#代码实现。这些数据结构是计算机科学的基础，广泛应用于各种算法和数据管理中。
摘要由CSDN通过智能技术生成 
//接口
 interface IListDS<T>
    {
        int GetLength();//获取长度
        void Clear();//清空

        bool IsEmpty();//判断列表是否为空

        void Append(T item);//添加数据

        void Insert(T item,int i);//在某个位置添加数据

        T Delete(int i);//根据位置删除数据

        T GetElement(int i);//根据位置得到元素

        int Locate(T value);//根据元素得到位置
    }

//线性表

 class SeqLise<T> : IListDS<T>
    {
        private int maxsize;
        private T[] data;
        private int last;
        public int Maxsize
        {
            get { return maxsize; }
            set { maxsize = value; }
        }
        public int Last
        {
            get { return last; }
        }
        public SeqLise(int size)
        {
            data = new T[size];
            maxsize = size;
            last = -1;
        }

        public T this[int index]
        {
            get { return data[index]; }
            set { data[index] = value; }
        }

        bool isFull()
        {
            if (Last == maxsize-1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }


        public void Append(T item)
        {
            if (isFull())
            {
                Console.WriteLine ("列表已存满");
                return;
            }
            data[++last] = item;
        }

        public void Clear()
        {

             last=-1;
            Array.Clear(data,0,maxsize);
           
        }

        public T Delete(int i)
        {
            T tmp = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("List is empty !列表为空");
                return tmp ;
            }
            if (i<1||i>last +1)
            {
                Console.WriteLine("Position is error !无法删除");
                return tmp;
            }
            if (i==last +1)
            {
                tmp = data[last];
            }
            else
            {
                for (int k=i ;k<=last ;++k)
                {
                    data[k-1]=data[k];
                    data[k] = default(T);
                }
              tmp= data[i - 1];
            }
            --last;
            return tmp;
        }

        public T GetElement(int i)
        {
            if (IsEmpty()||i>last+1)
            //123456
            //012345
            {
                Console.WriteLine("List is empty or Position is error !");
                return default(T);
            }
            return data[i-1];
        }

        public int GetLength()
        {
            return last + 1;
        }

        public void Insert(T item, int i)
        {
            if (isFull ())
            {
                Console.WriteLine("List is full 列表已存满");
                return;
            }
            if (i<1||i>last+2)
            {
                Console.WriteLine("Position is error 无法插入");
                return;
            }
            if (i==last+2)
            {
                data[last+1] = item;
            }
            else
            {
                for (int k =last;k>=i-1; --k)
                {
                  data[k+1]=data[k];
                }
                data[i-1]=item;
            }
            ++last;
        }

        public bool IsEmpty()
        {
            if (Last==-1)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int Locate(T value)
        {
            if (IsEmpty())
            {
                Console.WriteLine("List is empty!");
                return -1;
            }
            int i = 0;
            for (i = 0; i <= last; ++i)
            {
                if (data[i].Equals(value))
                {
                    break;
                }
            }
            if (i>last )
            {
                return -1;
            }
            return i+1;
        }
    }

//单链表

 class Node<T>
    {
        private T data;//数据域 存储数据的对象

        private Node<T> next;//引用域  指向下一个对象

        public Node (T val,Node <T> p)
        {
            data = val;
            next = p;
        }
        public Node( Node<T> p)
        {         
            next = p;
        }
        public Node(T val)
        {
            data = val;
            next = null;
        }
        public Node ()
        {
            data = default(T);
            next = null;
        }

        public T Data
        {
            get { return data;}
            set { data = value;}
        }
        public Node <T> Next
        {
            get { return next;}
            set { next = value;}
        }
    }

 class LinkList<T> : IListDS<T>
    {

        private Node<T> head;
        public Node<T> Head
        {
            get { return head; }
            set { head = value; }
        }
        public LinkList()
        {
            head = null;
        }
        public void Append(T item)
        {
            Node<T> q = new Node<T>(item);
            Node<T> p = new Node<T>();
            if (head ==null)
            {
                head = q;
                return;
            }
            p = head;
            while (p.Next!=null )
            {
                p = p.Next;

            }
            p.Next = q;
        }
        public T this [int i]
        {
            get { return GetElement(i);}
        }
        public bool isEmpty()
        {
            if (head==null )
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        public void Clear()
        {
            head = null;
        }

        public T Delete(int i)
        {
            if (isEmpty ()||i<1)
            {
                Console.WriteLine("List is empty or position is errors !");
                return default(T);
            }
            Node<T> q = new Node<T>();
            if (i==1)
            {
                q = head;
                head = head.Next;
                return q.Data ;
            }
            Node<T> p = head ;       
            int j = 1;
            while (p.Next != null && j < i)
            {
                ++j;
                q = p;
                p = p.Next;
            }
            if (j == i)
            {
                q.Next = p.Next;
                return p.Data;
            }
            else
            {
                Console.WriteLine("The ith node is not exist!");
                return default(T);
            }
        }

        public T GetElement(int i)
        {
            if (isEmpty())
            {
                Console.WriteLine("List is empty!");
                return default(T);
            }
            Node<T> p = new Node<T>();
            p = head;
            int j = 1;
            while (p.Next!=null &&j<i)
            {
                ++j;
                p = p.Next;
            }
            if (j==i)
            {
                return p.Data;
            }
            else
            {
                Console.WriteLine("The ith node is not exist!");
                return default(T);
            }
        }

        public int GetLength()
        {
            Node<T> p = head;
            int len = 0;
            while (p!=null )//节点是否存在
            {
                ++len;
                p = p.Next;
            }
            return len;
        }

        public void Insert(T item, int i)
        {
            if (IsEmpty ()||i <1)
            {
                Console.WriteLine("List is empty or position is errors !");
                return ;
            }
            if (i==1)
            {
                Node<T> q = new Node<T>(item);
                q.Next = head;
                head = q;
                return;
            }
            Node<T> p = head;
            Node<T> r = new Node<T>();
            int j = 1;
            while (p.Next!=null ||j<i)
            {             
                r  = p;
                p = p.Next;
                ++j;
            }
            if (j==i)
            {
                Node<T> q = new Node<T>(item);            
                q.Next = p;
                r.Next = q;
            }
        }

        public bool IsEmpty()
        {
            if (head == null)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        public int Locate(T value)
        {
            if (isEmpty ())
            {
                Console.WriteLine("List is empty");
                return -1;
            }
            Node<T> p = new Node<T>();
            p = head;
            int i = 1;
            while (!p.Data.Equals(value )&&p.Next!=null )
            {
                p = p.Next;
                ++i;               
            }
            if (p.Data.Equals(value))
            {
                return i;
            }
            else
            {
                Console.WriteLine("数据不存在");
                return -2;
            }
           
        }
    }

//双链表

```csharp
 class dbLinkList<T> : IListDS<T>
    {
        private DoubleNode<T> head;//头
        private DoubleNode<T> tail;//尾
        private int length;//长度
        public DoubleNode<T> Head
        {
            get { return head; }
            set { head = value; }
        }
        public DoubleNode<T> Tail
        {
            get { return tail; }
            set { tail = value; }
        }
        public int Length
        {
            get { return length; }
        }
        public dbLinkList ()
        {
            head = null;
            tail = new DoubleNode<T>(default(T));
            length = 0;
        }
        public T this[int i]
        {
            get { return GetNode(i).Data ; }
        }
        public void Append(T item)
        {
            DoubleNode<T> q = new DoubleNode<T>(item);
            if (head==null )
            {
                head = q;
                head.Next = tail;
                tail.Prev = head;
            }
            else
            {
                DoubleNode<T> temp = tail.Prev;
                temp.Next = q;
                q.Prev = temp;
                q.Next = tail;
                tail.Prev = q;
            }
            ++length;
        }


        public void Clear()
        {
            head = null;
            tail = new DoubleNode<T>(default(T));
            length  = 0;
        }

        public T Delete(int i)
        {
            T data;
            if (i==1)
            {
                data = head.Data;
                head = head.Next;
                --length;
            }
            else if (i>GetLength()||i<1)
            {
                Console.WriteLine("The ith does not exist!数值错误");
                data = default(T);
            }
            else 
            {
                data = GetNode(i).Data;
                DoubleNode<T> tempNext = GetNode(i).Next ;
                DoubleNode<T> tempPrev = GetNode(i).Prev;
                tempNext.Prev = tempPrev;
                tempPrev.Next = tempNext;
                --length;
            }
            return data;
        }

        public T GetElement(int i)
        {
            return GetNode(i).Data;
        }

        public int GetLength()
        {
            return length;
        }

        public void Insert(T item, int i)
        {
            DoubleNode<T> q = new DoubleNode<T>(item);
            if (i==1)
            {
                DoubleNode<T> temp = head;
                head = q;
                temp.Prev = head;
                head.Next = temp;
                ++length;
            }
            else if (i>GetLength())
            {
                Append(item );
            }
            else if (i<1)
            {
                Console.WriteLine("The ith does not exist!");
                return;
            }
            else
            {
                DoubleNode<T> temp = GetNode(i);
                DoubleNode<T> tempprev = GetNode(i).Prev;
                temp.Prev = q;
                tempprev.Next = q;
                q.Prev = tempprev;
                q.Next = temp;
                ++length;
            }
        }

        public bool IsEmpty()
        {
            return length == 0;
        }

        public int Locate(T value)
        {
            for (int i = 1; i <= GetLength (); ++i)
            {
                if (GetNode(i).Data.Equals(value ))
                {
                    return i;
                }
            }
            Console.WriteLine("Value does not exist!");
            return -1;
        }
        private DoubleNode <T>GetNode(int i)
        {
            if (i==1)
            {
                if (head!=null )
                {
                    return head;
                }
                else
                {
                    Console.WriteLine("List is empty!");
                    return null ;
                }
            }
            else if (i==GetLength())
            {
                return tail .Prev;
            }
            else if (i<1||i>GetLength ())
            {
                Console.WriteLine("Position is error!");
                return null;
            }
            else if (i<=GetLength()/2)
            {
                DoubleNode <T >temp = head;
                for (int j = 1; j <=i; ++j)
                {
                    temp = temp.Next;
                }           
                return temp;
            }
            else
            {
                DoubleNode<T> temp = tail;
                for (int j = GetLength()-i;j >=0; --j)
                {
                    temp = temp.Prev ;
                }
                return temp;
            }
        }
    }
卿屿­­­­­­­-轻尘
关注
数据结构课程作业 单链表 双链表 线性表 堆栈 等课程编程作业
08-07
在本课程作业中，我们重点关注了几种基本的数据结构：单链表、双链表、线性表和堆栈，同时也涉及到二叉树。这些概念在解决实际问题，特别是优化算法效率时起着关键作用。 首先，单链表是一种线性数据结构，其中每个...
Java模拟单链表和双端链表数据结构的实例讲解
09-02
单链表是一种基本的线性数据结构，它的每个节点包含两部分：数据元素和指向下一个节点的引用。在Java中，我们可以创建一个类`Link`来表示链表的节点，该类通常包含一个数据域（如`data`）和一个指向下一个节点的引用...
【数据结构】单链表和双链表
炸掉地球的博客
05-06 1161
1.通过本篇，掌握不带头单向非循环链表和带头双向循环链表之后，大概也能类推写出其他六种链表结构。2.不带头的链表传参数需要二级指针来接收，因为函数中可能会改变头结点(第一个结点)的值，例如链表为空时的操作。带头的链表传参时只需一级指针接收即可，因为并不会改变头结点(哨兵位头结点)的值。3.双向链表插入删除操作时，如果不事先保存结点的前后结点，则需要注意链接顺序，否则会找不到原来的结点。4.在pos位置进行删除操作时，要么传入二级指针置空，要么在外部调用函数完自行置空，否则会形成野指针。
数据结构5——单链表与双链表（超全）
zxdznyy的博客
06-06 2490
文章目录前言一、链表1.单链表2.双链表二、单链表1.成员变量2.getSize()和isEmpty()3.链表的虚拟头节点1.什么是链表的虚拟头结点2.代码4.链表的基础方法1.向链表中添加节点2.链表中删除节点3.找到index处的元素4.查找是否有该元素5.知索引获取元素5.打印链表5.整体的代码实现三.双链表1.双链表的结构2.双链表的成员变量3.与单链表的不同之处1.双链表中增加元素2.双链表中删除元素4.整体代码实现总结 前言 本节讲述的是单链表与双链表基础方法的原理及实现，双链表将在单链表的
[数据结构]链表之单链表
beenles的博客
06-16 673
单链表是一种常见的线性数据结构，由若干个节点组成，每个节点包含两部分：数据元素和指向下一个节点的指针。每个节点只有一个指针，通常称为 next 指针，它指向该节点的后继节点。头节点是第一个节点前面额外添加的一个节点，它不包含数据元素，但是包含对第一个节点的指针。单链表可以表示任意长度的序列，可以动态地插入、删除节点，使其具有灵活性和高效性。但由于每个节点只有一个指针，因此单链表只能从前往后遍历，不能反向遍历。以下是单链表常用的操作：创建链表：创建一个空链表，可选是否带有头节点。
数据结构链表上——单链表
2201_75537973的博客
07-18 489
单链表有两部分1结点的数据data2结点的next指针指向下一个结点}SLTNode;
单链表、双链表、循环链表简介
z2141830440的博客
03-10 798
对于一个链表，是由一系列不必在内存中相连的结构组成，每一个结构均含有表元素和指向包含该元素下一个表结构的指针（我们称之为Next指针）,它们也叫数据域和指针域。最后一个表结构的Next指针指向NULL，ANSI C规定NULL为零。（图1-2中箭头表示的就是Next指针）
【数据结构】单链表（超全）
春人.的博客
06-28 1万+
上一次我们分享了线性表中的一种结构顺序表，它存在着一些其缺点，比如：在中间位置或者头部进行元素插入或者删除的时候时间复杂度是O(N)效率比较低，并且顺序表在扩容的时候也存在时间和空间上的消耗，由于我们每次都是按照二倍来扩的，那就很有可能会出现扩大了用不完导致空间浪费的现象。这些问题该如何解决呢？那就需要用到今天分享给大家的另一种线性结构链表。
数据结构——链表
linzixi0220的博客
12-02 3101
链表是由多个地址不连续的存储结点连接而成的一种线性表，每个存储结构不仅包含元素本身的信息（数据域），而且包含表示元素之间的逻辑关系的信息，在c/c++中采样指针来实现，称为指针域，这个逻辑关系用指针来表示就是指向在线性表中与其相连的元素的地址。在线性表中，每个元素最多只有一个前驱结点和后继结点，采样链式存储时，每个结点需要包含前驱结点或者后继结点的地址信息，其中最简单也是最常用的方法是只存储每个结点的后继结点的地址，以这种方式构成的链表称为单链表。
数据结构与算法——线性表（链表篇）
热门推荐
小田是个程序员的博客欢迎你的到来呀~
06-20 2万+
本篇文章，主要详细解读和总结线性表的链式存储结构——链表，包括单链表、双链表、静态链表以及循环链表，讲解较为全面，图文并茂，总结各链表的特性以及基本操作，干货满满，各位小伙伴们请细细品读，你会收获你想要的知识的！.........
数据结构（线性结构：双链表）
qq_66298799的博客
09-16 1184
数据结构（线性结构：双链表详细解析）
数据结构与算法 - 单链表 & 双链表 -- 概念+实现
Distinguished_z的博客
10-12 990
链表有八种（下述三种特性任意组合）： 单向或者双向 带头或者不带头 循环或者非循环 1、其中，在单结构中，链表分为单向链表、双向链表； 单向链表：上一个结点存放了下一个结点的地址； 双向链表：前一个结点存了后一个结点的地址，后一个结点也存放了前一个结点的地址； 注：如若想在单链表中找倒数第k个结点，是非常麻烦的，因为单向链表只记录了数据与下一结点的地址，也就是说单链表中的结点不能找到自己的上一结点；但是对于双向链表来说，就完全不是事；并且在双向链表中，删除结点无需保存上一个结点的地址（相较于单链表）；
用VC编写单链表(数据结构).rar_VC 链表_单链表_数据结构 链表_链表
09-21
单链表是数据结构中一种基础且重要的线性结构，它在VC++编程环境中有着广泛的应用。VC++，全称Visual C++，是Microsoft公司开发的一款强大的C++集成开发环境，支持Windows平台上的应用程序开发。 单链表由一系列...
数据结构顺序表与单链表课程设计报告.doc
10-06
在这个课程设计报告中，我们将关注两种基本的数据结构：顺序表和单链表。这两种结构都是线性数据结构，它们提供了不同的方式来组织和操纵数据。 顺序表是一种将数据元素存储在内存中连续的位置上的数据结构。这种...
C语言实现数据结构：单链表，循环链表，双向链表；静态顺序队列
10-19
单链表是一种线性数据结构，每个元素（节点）包含两个部分：数据域和指针域。数据域存储实际的数据，而指针域指向下一个节点的地址。单链表的头节点通常用来初始化链表，其指针域指向第一个元素。插入和删除操作...
C++ 数据结构 静态顺序表、动态顺序表。
qq_50373827的博客
11-01 681
静态顺序表（Static Array List）是一种线性数据结构，通常用数组实现。它具有固定的大小，并在编译时分配内存。以下是静态顺序表的一些基本概念和实现示例。
探索数据结构：数组与链表
最新发布
qq_36287830的博客
11-04 440
数组和链表是两种基本但重要的数据结构。选择合适的数据结构对于优化程序性能至关重要。理解它们的特点和适用场景可以帮助开发者做出更好的设计决策。希望本文能为你提供有关数组和链表的清晰认识。
线性数据结构之数组
m0_61840987的博客
10-31 393
数组是一种数据结构，用于存储多个相同类型的元素。在许多编程语言中，数组是最基本的数据结构之一，常用于管理和处理数据。数组的元素在内存中是连续存储的，可以通过索引直接访问。
数据结构————map,set详解
2301_79083481的博客
10-29 1095
详解map,set
数据结构讲解：线性链表与单链表实现
线性链表是一种数据结构，它通过一组任意的存储单元来存放线性表的数据元素，这些元素在物理存储上可能不连续，但逻辑上保持顺序。链表中的每个节点由两部分组成：数据域和指针域。数据域存储实际的数据元素，而指针...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

卿屿­­­­­­­-轻尘

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

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

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

打赏作者

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

抵扣说明：

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

余额充值