C#实现一个顺序表和单链表

最新推荐文章于 2022-01-17 17:22:18 发布
最新推荐文章于 2022-01-17 17:22:18 发布
阅读量1.1k 收藏 7
点赞数 2
分类专栏： 数据结构 文章标签： 顺序表 数据结构 单链表 C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a962035/article/details/79793517
版权

1. 顺序表

    定义了一个接口类IListDS,在类SeqList中实现。

1.1 IListDS.cs

namespace _401_线性表
{
    interface IListDS<T>
    {
        int GetLength();
        void Claer();
        bool IsEmpty();
        void Add(T item);
        void Insert(T item, int index);
        T Delete(int index);
        T this[int index] { get; }
        T GetEle(int index);
        int Locate(T value);
    }
}

1.2 SeqList.cs

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

namespace _401_线性表
{
    class SeqList<T> : IListDS<T>
    {
        /// <summary>
        /// 顺序表实现方式
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>


        public int count=0;//计数器,表示存了多少个数据
        public T[] data;//用来存储数据

        public SeqList(int size)//size就是最大容量
        {
            data = new T[size];
            count = 0;
        }

        public SeqList() : this(10)//默认构造函数容量是10
        {

        }
        public T this[int index]
        {
            get { return GetEle(index); }
        }
        

        public void Claer()
        {
            count = 0;
        }

        public T Delete(int index)
        {
            T temp = data[index];
            if (index >= 0 && index <= count - 1)
            {
                for(int i=index+1;i<count;i++)
                {
                    data[i - 1] = data[i];//将数据向前移动
                }
                count--;
            }
            else
            {
                Console.WriteLine("删除位置有误");
            }

            return temp;
        }

        public T GetEle(int index)
        {
            if(index>=0&&index<=count-1)//索引存在
            {
                return data[index];
            }
            else
            {
                Console.WriteLine("索引不存在");
                return default(T);//取得类型的默认值
            }
            
        }

        /// <summary>
        /// 取得数据的个数
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return count;
        }

        public void Insert(T item, int index)
        {
            if(index>=0&&index<=count-1)
            {
                for(int i=count-1;i>=index;i--)
                {
                    data[i + 1] = data[i];
                }
                data[index] = item;
                count++;
            }
            else
            {
                Console.WriteLine("插入位置有误");
            }
        }

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

        public int Locate(T value)
        {
            for(int i=0;i<count;i++)
            {
                if(data[i].Equals(value))
                {
                    return i;
                }
            }
            return -1;
        }

        public void Add(T item)
        {
            if (count == data.Length)
            {
                Console.WriteLine("当前顺序表已满");
            }
            else
            {
                data[count] = item;
                count++;
            }
        }
    }
}

1.3 Program.cs

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

namespace _401_线性表
{
    class Program
    {
        static void Main(string[] args)
        {
            //1.使用BCL中的List线性表
            //List<string> strList = new List<string>();
            //strList.Add("34");
            //strList.Add("3435");
            //strList.Add("6767");

            //strList.Remove("3435");

            //foreach(var temp in strList)
            //{
            //    Console.WriteLine(temp);
            //}
            //Console.WriteLine(strList.IndexOf("34"));
            //Console.WriteLine(strList.Count);
            //Console.ReadKey();

            //2.使用自己定义的顺序表
            SeqList<string> seqList = new SeqList<string>();

            seqList.Add("45");
            seqList.Add("657");
            seqList.Add("243");

            Console.WriteLine(seqList.GetEle(1));
            Console.WriteLine("长度:" + seqList.GetLength());
            seqList.Insert("888", 2);

            seqList.Delete(3);
            Console.WriteLine(seqList.IsEmpty());
            Console.WriteLine(seqList.Locate("45"));

            Console.WriteLine("遍历结果：");
            for (int i = 0; i < seqList.count; i++)
            {

                Console.WriteLine(seqList[i]);
            }
            Console.WriteLine("清空后");
            seqList.Claer();
            Console.WriteLine("长度:" + seqList.GetLength());

            Console.ReadKey();
}
}}

2. 单链表

    定义了一个j节点类Node，接口类IListDS,在类LinkList中实现。

2.1 Node.cs

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

namespace _401_线性表
{
    /// <summary>
    /// 单链表的节点
    /// </summary>
    class Node<T>
    {
        private T data;//数据域
        private Node<T> next;//指针，用来指向下一个节点

        public Node()
        {
            data = default(T);
            next = null;
        }
        public Node(T value)
        {
            data = value;
            next = null;
        }
        public Node(T value,Node<T> next)
        {
            data = value;
            this.next = next;
        }
        public Node(Node<T> next)
        {
            this.next = next;
        }

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

2.2 IListDS.cs

namespace _401_线性表
{
    interface IListDS<T>
    {
        int GetLength();
        void Claer();
        bool IsEmpty();
        void Add(T item);
        void Insert(T item, int index);
        T Delete(int index);
        T this[int index] { get; }
        T GetEle(int index);
        int Locate(T value);
    }
}

2.3 LinkList.cs

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

namespace _401_线性表
{
    class LinkList<T> : IListDS<T>
    {
        private Node<T> head;//储存一个头结点

        public LinkList()
        {
            head = null;
        }
        public T this[int index]
        {
            get
            {
                Node<T> temp = head;
                for (int i = 1; i <= index; i++)
                {
                    temp = temp.Next;
                }
                return temp.Data;
            }
        }
        public void Add(T item)
        {
            Node<T> newNode = new Node<T>(item);//根据新数据创建一个节点
            
            if(head==null)
            {
                head = newNode;
            }
            else
            {//把新来的节点放到链表尾部
                
                Node<T> temp = head;

                //要访问到链表尾部
                while(true)
                {
                    if(temp.Next!=null)
                    {
                        temp = temp.Next;
                    }
                    else
                    {
                        break;
                    }
                }
                temp.Next = newNode;
            }
        }

        public void Claer()
        {
            head = null;
        }

        public T Delete(int index)
        {
            T data = default(T);
            if(index==0)
            {
                data = head.Data;
                head = head.Next;
            }
            else
            {
                Node<T> temp = head;
                for(int i=1;i<=index-1;i++)
                {
                    temp = temp.Next;
                }
                Node<T> preNode = temp;
                Node<T> currentNode = temp.Next;
                Node<T> nextNode = temp.Next.Next;
                preNode.Next = nextNode;
            }
            return data;
        }

        public T GetEle(int index)
        {
            return this[index];
        }

        public int GetLength()
        {
            if (head == null) return 0;
            Node<T> temp = head;
            int count = 1;
            while(true)
            {
                if(temp.Next!=null)
                {
                    count++;
                    temp = temp.Next;
                }
                else
                {
                    break;
                }
            }
            return count;
        }

        public void Insert(T item, int index)
        {
            Node<T> newNode = new Node<T>(item);
            if(index==0)//插入到头结点
            {
                newNode.Next = head;
                head = newNode;
            }
            else
            {
                Node<T> temp = head;
                for(int i=1;i<=index-1;i++)
                {
                    //让temp向后移动一个位置
                    temp = temp.Next;
                }
                Node<T> preNode = temp;
                Node<T> currentNode = temp.Next;
                preNode.Next = newNode;
                newNode.Next = currentNode;
            }
        }

        public bool IsEmpty()
        {
            return head == null;
        }

        public int Locate(T value)
        {
            Node<T> temp = head;
            if(temp==null)
            {
                return -1;
            }
            else
            {
                int index = 0;
                while(true)
                {
                    if(temp.Data.Equals(value))
                    {
                        return index;
                    }
                    else
                    {
                        if(temp.Next!=null)
                        {
                            temp = temp.Next;
                        }
                        else
                        {
                            break;
                        }
                    }
                }
                return -1;
            }
        }
    }
}

2.4 Program.cs

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

namespace _401_线性表
{
    class Program
    {
        static void Main(string[] args)
        {
//3.使用链表
            LinkList<string> seqList = new LinkList<string>();
            seqList.Add("45");
            seqList.Add("657");
            seqList.Add("243");

            Console.WriteLine(seqList.GetEle(1));
            Console.WriteLine("长度:" + seqList.GetLength());
            seqList.Insert("888", 2);

            seqList.Delete(3);
            Console.WriteLine(seqList.IsEmpty());
            Console.WriteLine(seqList.Locate("45"));

            Console.WriteLine("遍历结果：");
            for (int i = 0; i < seqList.GetLength(); i++)
            {

                Console.WriteLine(seqList[i]);
            }
            Console.WriteLine("清空后");
            seqList.Claer();
            Console.WriteLine("长度:" + seqList.GetLength());
            Console.ReadKey();
        }
    }
}

王大匣
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
数据结构——顺序表 (C#)
凉夏微微
05-16 2837
  1. 顺序表 线性表的顺序存储是指在内存中用一块地址连续的空间依次存放线性表的数据元素，用这种方式存储的线性表叫顺序表。 特征：表中相邻的数据元素在内存中存储位置也相邻。     3. 顺序表的存储  假设顺序表中的每个数据元素占w个存储单元，设第1个数据元素的存储地址为Loc(ai)，则有:Loc(ai)= Loc(a1)+(i-1)*w   1&lt;=i&lt;=n 式中...
c# 实现线性表（一）（顺序表(MyList)
zzzsss123333的博客
06-12 1337
** c# 实现线性表（一）（顺序表(MyList)） ** 你好！ 本篇文章将用C#向你讲述一个完整的顺序表 发稿理由 网上有很多关于c/c++关于线性表的内容,但C#的却很少，因为C#有自己的list，里面已经封装好了，下面我将用我自己写的代码创建一个自己的Mylist 1.参考文章：https://blog.csdn.net/qq_40985921/article/details/90709669 2.参考文章：https://www.bilibili.com/video/BV1px411f7pe?p
C#实现顺序表（线性表）
丛晓男
02-28 3505
基本思想是使用数组作为盛放元素的容器，数组一开始的大小要实现确定，并使用一个Pointer指向顺序表中最后的元素。顺序表中的元素是数组中元素的子集。顺序表在内存中是连续的，优势是查找，弱势是插入元素和删除元素。 为避免装箱拆箱，这里使用泛型，代替object。使用object的例子可以参照http://blog.csdn.net/suinon/archive/2010/02/02/5280
C#实现顺序表(线性表)完整实例
09-02
主要介绍了C#实现顺序表(线性表)的方法,结合完整实例形式分析了顺序表的原理及C#相关实现技巧,需要的朋友可以参考下
C#数据结构（顺序表，单链表，顺序表应用，冒泡排序，折半查找）
11-10
例如，你可以用顺序表实现一个简单的银行排队系统，通过在表的一端添加客户，在另一端移除服务完成的客户。 接下来，**冒泡排序**是一种简单的排序算法，它通过重复遍历待排序的序列，比较每对相邻元素并交换位置...
c#实现顺序表、单链表、顺序栈、冒泡排序、折半查找.zip
08-01
使用c#语言编写的winform程序，实现顺序表、单链表、顺序栈、冒泡排序、折半查找 源代码和程序展示： 顺序表：https://blog.csdn.net/HAIIAKU/article/details/119302855 单链表：...
C#实现单链表(线性表)完整实例
12-26
本文实例讲述了C#实现单链表(线性表)...所以，在下面的例子中，执行Purge（清洗重复元素）的时候，没有使用Add（）方法去添加元素，而是定义一个节点，让它始终指向目标单链表的最后一个节点，这样就不用每次都从头到尾
数据结构_顺序表_单链表_循环链表C#
01-12
在实现这些数据结构时，C#提供了丰富的内置类型和功能，如List可以轻松创建动态数组（类似于顺序表），LinkedList则提供了链表的功能。此外，可以自定义节点类，如`class ListNode { public int Data; public ...
数据结构之链表,C#链表;数据结构之链表,C#链表
11-22
数据结构之链表,C#链表 数据结构之链表,C#链表 数据结构之链表,C#链表 数据结构之链表,C#链表 数据结构之链表,C#链表 数据结构之链表,C#链表
c#之线性表（顺序表）实现(第四季)
taotaoahui
04-16 1207
在计算机内，保存线性表最简单、最自然的方式，就是把表中的元素一个接一个地放进顺序的存储单元，这就是线性表的顺序存储(SequenceStorage)。线性表的顺序存储是指在内存中用一块地址连续的空间依次存放线性表的数据元素，用这种方式存储的线性表叫顺序表(SequenceList)，如图所示。顺序表的特点是表中相邻的数据元素在内存中存储位置也相邻。 顺序表的存储 假设顺
【数据结构】一看就会系列之线性表--顺序表（C#语言描述）
他在试图用代码书写这个世界，字里行间温柔尽显。勿忘初心，努力做有价值的技术文章。
01-17 1099
目录导航线性表线性表的接口定义顺序表顺序表的实现获得元素的操作插入操作删除操作求顺序表的长度清空操作判断顺序表是否为空判断顺序表是否为满附加操作按值查找顺序表的应用---元素倒置顺序存储结构的优缺点优点缺点 线性表 线性表是最简单、最基本、最常用的数据结构。其结构中的数据元素之间是一对一的线性关系。即：（1）除第一个位置的数据元素外，其他数据元素的前面都只有一个元素 ；（2）除最后一个位置的数据元素外，其他数据元素位置的后面都只有一个元素。 线性表的接口定义 /// 线性表的接口 public interf
使用c#实现顺序表的操作
javatome
08-30 301
using System; using System.Collections.Generic; using System.Text; namespace 线性结构 { /* 作者:it小金 */ //线性表接口 public interface IListDS&lt;T&gt; { int ...
单链表排序(冒泡排序&快速排序)
迷路的小绅士之家
09-23 3838
void BubbleSord(pList plist) { pNode pCur = NULL; pNode pPre = NULL; pNode pTail = NULL;//pTail的指向是这个算法的关键 if (plist == NULL || plist-&gt;next == NULL)//排除空和一个结点的情况 { return; } while (plist ...
链表排序
yangss123的博客
06-04 3254
1. 单链表排序 时间复杂度O(nlogn)----快速排序实现、归并排序实现 leetcode 148 在O(nlogn) 时间复杂度和常数级空间复杂度下，对链表进行排序。 示例 1: 输入: 4->2->1->3 输出: 1->2->3->4 示例 2: 输入: -1->5->3->4->0 输出: -1-&g...
C#_数据结构--数据表(顺序表,链表,栈,队列)
anzhuo0908的博客
10-25 222
常见的线性表: 1.顺序表 List<> 表中元素有索引和固定连续的顺序, 方便元素遍历和查找 2.链表 需要自己构建, 有固定的链接,没有索引 方便元素插入和删除 3.栈 Stack<T> 类似于一个桶,后进入的元素先...
数据结构--链表的排序详解
热门推荐
William
11-18 11万+
1、前言 前面两篇博客，我已经把线性表的两种基本的表示形式，做了一个基本的介绍和一些对比。但是，我突然发现在链表这里我缺少一个很重要的内容，那就是对我们的链表进行排序，其实，在连接两个链表的时候，就要求我们的那两个链表是有序的。2、链表排序—最简单、直接的方式（直接采用冒泡或者选择排序，而且不是交换结点，只交换数据域）//线性表的排序,采用冒泡排序,直接遍历链表 void Listsort(Nod
C#winform实现顺序表的增删改查
最新发布
06-03
顺序表是一种数据结构，C#中可以使用数组来实现。下面是一个简单的顺序表的增删改查的实现： 1. 声明一个数组作为顺序表的存储结构： ``` int[] array = new int[100]; int size = 0; // 当前数组中元素的个数 ``` 2. 实现插入元素的方法，在末尾插入元素： ``` public void Insert(int value) { if(size < array.Length) { array[size] = value; size++; } } ``` 3. 实现删除元素的方法，删除指定位置的元素： ``` public void Delete(int index) { if(index >= 0 && index < size) { for(int i = index; i < size - 1; i++) { array[i] = array[i + 1]; } size--; } } ``` 4. 实现修改指定位置元素的方法： ``` public void Modify(int index, int value) { if(index >= 0 && index < size) { array[index] = value; } } ``` 5. 实现查找元素的方法： ``` public int Search(int value) { for(int i = 0; i < size; i++) { if(array[i] == value) { return i; } } return -1; } ``` 以上就是一个简单的顺序表的增删改查的实现。你可以将这些方法放在一个类中，并在 Winform 中调用这个类来操作顺序表。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王大匣

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

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

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

打赏作者

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

抵扣说明：

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

余额充值