C#实现数据结构-线性表（一）

于 2023-08-13 20:01:07 发布
阅读量210 收藏 2
点赞数
文章标签： c# 数据结构 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51186493/article/details/132264424
版权

本文章纯属个人练习笔记，如有错误欢迎纠正。

顺序表和单链表实现

1、通用接口实现如下：

namespace 手撕数据结构之线性表
{
    /// <summary>
    /// 通用接口
    /// </summary>
    /// <typeparam name="T"></typeparam>
    interface IList<T>
    {
        void Add(T item); //添加
        void Insert(T item, int index); //插入
        T Remove(int index); //删除
        void Clear(); //清空
        int GetLength(); //获取表长
        bool IsEmpty(); //判空
        T FindEle(int index); //查找元素
        int Local(T item); //获取数据位置
    }
}

2、顺序表实现类如下：

namespace 手撕数据结构之线性表
{
    /// <summary>
    /// 顺序表
    /// </summary>
    class SeqList<T> : IList<T>
    {
        T[] datas; //数据存储
        int length; //记录表长

        public SeqList(int size) //构造函数初始化
        {
            this.datas = new T[size];
            length = 0;
        }

        public SeqList() : this(10) //默认初始化表容量为10
        {

        }

        /// <summary>
        /// 添加数据
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            if (length == datas.Length)
            {
                Console.WriteLine("当前顺序表容量已满!");
                return;
            }
            datas[length] = item; //将数据存入表中
            length++; //表长加1
        }

        /// <summary>
        /// 插入数据
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        public void Insert(T item, int index)
        {
            if (index < 0 || index > datas.Length - 1)
            {
                Console.WriteLine("当前插入索引溢出!");
                return;
            }
            for (int i = length - 1; i >= index; i--)
            {
                datas[i + 1] = datas[i]; //把当前索引值后的数据往后移
            }

            datas[index] = item;
            length++;
        }

        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T Remove(int index)
        {
            if (IsEmpty())
            {
                Console.WriteLine("该顺序表为空！");
                return default(T);
            }
            else
            {
                T temp = datas[index];
                for (int i = index + 1; i < length; i++)
                {
                    datas[i - 1] = datas[i]; //数据前移
                }
                length--;
                return temp;
            }
        }

        /// <summary>
        /// 清空
        /// </summary>
        public void Clear()
        {
            length = 0;
        }

        /// <summary>
        /// 查找
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T FindEle(int index)
        {
            if (IsEmpty())
            {
                Console.WriteLine("该顺序表为空！");
                return default(T);
            }
            else
            {
                if (index < 0 || index > datas.Length - 1)
                {
                    Console.WriteLine("当前查询索引溢出!");
                    return default(T);
                }

                return datas[index];
            }
        }

        /// <summary>
        /// 获取表长
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            return length;
        }

        /// <summary>
        /// 判空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return length == 0;
        }

        /// <summary>
        /// 获取数据所在索引
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public int Local(T item)
        {
            if (IsEmpty())
            {
                Console.WriteLine("该顺序表为空！");
                return -1;
            }
            else
            {
                for (int i = 0; i < length; i++)
                {
                    if (item.Equals(datas[i]))
                        return i;
                }
                return -1;
            }
        }

        
    }
}

 测试代码：

namespace 手撕数据结构之线性表
{
    class Program
    {
        static void Main(string[] args)
        {
            SeqList<string> seqList = new SeqList<string>();
            seqList.Add("张三");
            seqList.Add("李四");
            seqList.Add("王五");
            Console.WriteLine(seqList.GetLength());
            seqList.Remove(0);
            for (int i = 0; i < seqList.GetLength(); i++)
            {
                Console.WriteLine(seqList.FindEle(i));
            }
            seqList.Insert("老六", 0);
            for (int i = 0; i < seqList.GetLength(); i++)
            {
                Console.WriteLine(seqList.FindEle(i));
            }
            seqList.Clear();
            Console.WriteLine(seqList.GetLength());
        }
    }
}

3、单链表实现如下：

单链表节点类：

namespace 手撕数据结构之线性表
{
    /// <summary>
    /// 链表的节点类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class Node<T>
    {
        private T data; //数据存储
        private Node<T> next; //指向下一个节点指针

        public Node()
        {
            data = default(T);
            next = null;
        }

        public Node(T data)
        {
            this.data = data;
            next = null;
        }

        public Node(Node<T> next)
        {
            this.next = next;
        }

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

        public T Data
        {
            get { return data; }
            set { data = value; }
        }

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

单链表实现类：

namespace 手撕数据结构之线性表
{
    /// <summary>
    /// 单链表
    /// </summary>
    class LinkList<T> : IList<T>
    {
        private Node<T> head; //头节点

        public LinkList()
        {
            head = null;
        }
        /// <summary>
        /// 添加节点
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            Node<T> newNode = new Node<T>(item);
            if (head == null) //如果头节点为空，即新节点就为头节点
            {
                head = newNode;
            }
            else
            {
                Node<T> temp = head;
                while (temp.Next != null)
                {
                    temp = temp.Next;
                }
                temp.Next = newNode; //把新的节点放到链表的最后面
            }
        }

        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.Next;
                }
                Node<T> preNode = temp;
                Node<T> nextNode = temp.Next;
                preNode.Next = newNode;
                newNode.Next = nextNode;
            }
        }

        /// <summary>
        /// 删除节点
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T Remove(int index)
        {
            T data = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("链表为空!");
                return data;
            }
            if (index == 0) //如果删除的是头节点
            {
                data = head.Data;
                head = head.Next;
                return data;
            }
            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;
                data = currentNode.Data;
                preNode.Next = currentNode.Next;
                return data;
            }
        }

        /// <summary>
        /// 清空链表
        /// </summary>
        public void Clear()
        {
            head = null;
        }

        /// <summary>
        /// 获取表长
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            if (IsEmpty())
                return 0;
            int length = 1;
            Node<T> temp = head;
            while (temp.Next != null)
            {
                length++;
                temp = temp.Next;
            }
            return length;
        }

        /// <summary>
        /// 查询链表元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T FindEle(int index)
        {
            T data = default(T);
            if (IsEmpty())
            {
                Console.WriteLine("链表为空!");
                return data;
            }
            Node<T> temp = head;
            for (int i = 0; i <= index - 1; i++)
            {
                temp = temp.Next;
            }
            return temp.Data;
        }

        /// <summary>
        /// 查找当前元素的索引位置
        /// </summary>
        /// <param name="item"></param>
        /// <returns></returns>
        public int Local(T item)
        {
            int index = 0;
            if (IsEmpty())
            {
                Console.WriteLine("链表为空!");
                return -1;
            }
            Node<T> temp = head;
            while (temp.Next != null)
            {
                if (!item.Equals(temp.Data))
                {
                    temp = temp.Next;
                    index++;
                }
                else
                {
                    return index;
                }
            }
            return -1;
        }

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

测试代码：

namespace 手撕数据结构之线性表
{
    class Program
    {
        static void Main(string[] args)
        {
            LinkList<string> seqList = new LinkList<string>();
            seqList.Add("张三");
            seqList.Add("李四");
            seqList.Add("王五");
            for (int i = 0; i < seqList.GetLength(); i++)
            {
                Console.WriteLine(seqList.FindEle(i));
            }
            Console.WriteLine(seqList.GetLength());
            seqList.Remove(0);
            for (int i = 0; i < seqList.GetLength(); i++)
            {
                Console.WriteLine(seqList.FindEle(i));
            }
            seqList.Insert("老六", 0);
            for (int i = 0; i < seqList.GetLength(); i++)
            {
                Console.WriteLine(seqList.FindEle(i));
            }
            Console.WriteLine(seqList.Local("老六"));
            seqList.Clear();
            Console.WriteLine(seqList.GetLength());
        }
    }
}

挽风于你
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
用C#学习数据结构之线性表
12-22
什么是线性表 　线性表是简单、基本、常用的数据结构。...因此，可以把线性表想象为一种数据元素序列的数据结构。 　线性表的接口定义 1 public interface IListDS<T> { 2 int GetLength(); //求长度 3 
【数据结构】C# 实现常用数据结构总结
好学若饥，谦卑若愚。
02-02 3090
自行整理的C#常见数据结构笔记。
线性表
weixin_30730151的博客
08-24 99
什么是线性表： 线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。 这种一对一的关系指的是数据元素之间的位置关系，即： （ 1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素； （ 2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。也就是说，数据元...
C#基础：数组的简单使用
QQhelphelp的博客
10-30 240
数组是有序的元素序列，下标从0开始，数组必须在访问之前初始化， 示例代码如下： //一维数组：             string[] names = { "张三","李四","王五"};             for (int i = 0; i &lt; names.Length; i++)//for循环输出数组内容             {                 C...
c#中的Length和GetLength()的区别
weixin_41529093的博客
04-06 1万+
文章目录代码格式简明做一个小实验 仅作为操作记录，大佬请跳过。 代码格式 首先 Length直接，GetLength()需要用括号 Length是取所有的元素个数，GetLength()是取行数和列数 简明 假如一个数组：(两行三列) array= 1,2,3 4,5,6 Length是6； GetLength(0)是2，【GetLength(0)表示取行数】 GetLength(1)是3 做一个...
【C#数据结构系列】线性表
weixin_30516243的博客
06-11 160
一：线性表 1.1：定义：零个或多个数据元素的有限序列 1.2： 　　线性表元素个数n定义为线性表的长度，n = 0称为空表，i 为数据元素ai在线性表中的位序。 1.3：满足线性表的条件：（1）：有序，有限 　　　　　　　　　　 （2）：第一个元素无前驱，最后一个元素无后继 　　　　　　　　　　 （3）：数据类型相同 　　　　　　　　　　 （4）：元素之间...
实验2内容要求-线性表的设计与实现1
08-04
实验2的主要目标是深入理解和实践线性表这一重要的数据结构，同时强化对Visual Studio项目管理和C#编程技能的运用。在这个过程中，学生将通过创建和管理项目，实现不同类型的线性表，以及进行性能比较，来巩固理论...
数据结构（C#）第二章线性表ppt
05-09
线性表作为最基本的数据结构之一，是构建其他复杂数据结构的基础。本文将深入探讨线性表的定义、抽象数据类型描述以及顺序存储结构。 线性表（Linear List）是由相同特性的数据元素组成的一个有序集合。在非空...
C#实现顺序表(线性表)完整实例
01-21
本文实例讲述了C#实现顺序表(线性表)的方法。分享给大家供大家参考，具体如下： 基本思想是使用数组作为盛放元素的容器，数组一开始的大小要实现确定，并使用一个Pointer指向顺序表中最后的元素。顺序表中的元素是...
数据结构与算法C#实现 线性表 BinaryTree
04-06
本资源"数据结构与算法C#实现 线性表 BinaryTree"聚焦于两种基本的数据结构——线性表和二叉树，并使用C#语言进行实现。下面将详细探讨这两个主题及其相关知识点。 线性表是一种基本的一维数据结构，它包含有限个...
C#中的Hashtable（哈希表）详解
最新发布
wenchm的博客
07-04 7771
一、Hashtable（哈希表）Hashtable（哈希表）是一种重要的集合类型。Hashtable通常称为哈希表，它表示键值对的集合，这些键/值对根据键的哈希代码进行组织。它的每个元素都是一个存储在DictionaryEntry对象中的键/值对。键不能为空引用，但值可以。
C#开发之——更新数据表(15.9)
我的博客
08-18 1099
一 概述 在前面C#操作数据库一节中已经介绍了使用SqlCommand对象中的ExecuteNonQuery方法执行非查询SQL语句来实现对数据表的更新操作，使用DataSet对象也能实现相同的功能，并且能节省数据访问时间 每个DataSet都是由多个DataTable构成的，更新DataSet中的数据实际上是通过更新DataTable来实现的 每个DataTable对象都是由行(DataRow)和列(DataColumn)构成的，下面分别介绍DataRow类和DataColumn
C#网格控件dataGridView(利用List列表和DataTable数据表绑定dataGridView)构建数据表
qq_48492162的博客
04-08 7865
C#网格控件(List列表和DataTable数据表)操作，利用DataTable来对网格进行增加删除
C#创建表格
热门推荐
abcwanglinyong的博客
04-26 3万+
1.新建Form窗体frmTest2.在工具箱中找到GridControl，拖入Form窗体3.点击Run Designer,然后在Columns项中可以添加字段，然后修改Name、Caption、FieldName值，其中Caption是表格显示的字段名，FildName是数据库字段名,可以参考如下： Name   id Caption id FieldName id Visabl...
C# Winform DataGridView 控件和 DataTable
熊思雨的博客
06-27 1万+
DataGridView 控件提供用于显示数据的可自定义表。类 DataGridView 允许通过使用属性（如 DefaultCellStyle、 ColumnHeadersDefaultCellStyle、 CellBorderStyle和）自定义单元格、行、列和 GridColor边框。有关详细信息，请参阅微软 DataGridView 控件中的基本格式设置和样式设置。可以使用 DataGridView 控件在基础数据源中或不使用基础数据源显示数据。
C#--数据结构
月光下的麦田的博客
04-12 253
一、线性表 1. 顺序表： List<T>      顺序表是用 地址连续 的存储单元顺序存储线性表中的各个数据元素，逻辑上相邻的数据元素在物理位置上也是相邻的。因此，在顺序表中查找任何一个位置上的数据元素非常方便。但是，在对顺序表进行数据的插入和删除的时候，需要通过移动数据元素来实现，会影响运行效率。 以下是通过代码实现List数据结构： 定义接口，规定所拥有的数据操作（增，删，插...
简单数据结构（一）线性表
a361445613的博客
03-06 262
最简单的结构：线性表 先进先出的结构：队列 先进后出的结构：栈 线性表 线性表数据结构具有以下特征： 有且只有一个“首元素” 有且只有一个“末元素” 除末元素之外，其余元素均有惟一的后继元素 除首元素之外，其余元素均有惟一的前驱元素 对于线性表，主要可进行以下操作： ...
c# 线性表
microsoftMSDNNET的博客
09-08 1052
线性表的形式化定义为：线性表(List)简记为L，是一个二元组， L = (D, R) 其中：D是数据元素的有限集合。 R是数据元素之间关系的有限集合。 1线性表的基本操作C#接口的形式表示线性表，接口中的方法成员表示基本操作。并且，为了使线性表对任何数据类型都适用，数据元素的类型使用泛型的类型参数。在实际创建线性表时，元素的实际类型可以用应用程序中任何方便的数据类型来代替，比如用简单的整型或
线性表代码示例2---C#
NeilQ的专栏
05-11 907
之前写了个线性表示例，但由于只能对整型数进行操作，将之改为泛型： public class LinearList { private int length; //线性表元素长度 private int MaxSize; //线性表最大容量 private Item[] element; //存放元素的数组
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值