线性表(顺序表，链表等）及其实现（C#版）

最新推荐文章于 2023-03-23 16:29:38 发布
最新推荐文章于 2023-03-23 16:29:38 发布
阅读量369 收藏 1
点赞数 1
分类专栏： 算法 文章标签： 算法 c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a15970673567/article/details/113122037
版权

线性表

线性表的实现方式有下面几种

1.顺序表

线性表的顺序存储是指在内存中用一块地址连续的空间依次存放线性表的数据元素，用这种方式存储的线性表叫顺序表,它的实现主要依赖于数组。

(1)空间上：
顺序表的实现一般是实现连续开辟一段空间，然后在进行数据的增删查改,所以当我们不知道要存储多少数据时，用顺序表来开辟的空间如果太大，就会造成一定程度上的浪费，
(2)时间上：
访问随机元素的时间复杂度:由于支持数组下标访问，所以顺序表访问随机元素的时间复杂度是O（1）。
随机位置插入、删除元素的时间复杂度：
因为顺序表的元素是连续存储的，因此要在特定位置插入、删除元素需要把它之后的元素全部后移或前移一个元素的位置，时间开销比较大

顺序表的实现：

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

namespace _线性表
{
    //IComparable<T>接口定义由值类型或类实现的特定于类型的通用比较方法，旨在对其实例进行排序。
    public class SelfList<T> where T:IComparable
    {
        //T GetItem(int index);//获取索引对应的值
        //void Add(T item);//增添元素的方法    
        //void Insert(int index, T item);  //插入元素的方法
        //void RemoveAt(int index); // 移除对应指定索引处的元素。
        //int IndexOf(T item);//搜索指定的对象，并返回整个 System.Collections.Generic.List`1 中第一个匹配项的从零开始的索引。
        //int LastIndexOf(T item); //搜索指定的对象，第一个匹配项的从最后开始的索引。                               
        //void Sort();//从小到大排序
        int count;
        T[] arry;
 
        public int Count { get => count;}
        public int Capacity{ get => arry.Length; }//容量，用于扩容

        public SelfList(int size)
        {
            arry = new T[size];
        }
        public SelfList()
        {
            arry = new T[4];//没有指定size时，默认为4
        }

        public T GetItem(int index)
        {
            if (index>=0&&index<Count)
            {
                return arry[index];
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }


        //通过索引器访问
        public T this[int index]
        {
            get
            {
                return GetItem(index);

            }
            set
            {
                if (index >= 0 && index < Count)
                {
                    arry[index] = value;
                }
                else
                {
                    throw new Exception("索引超出范围");
                }
            }
        }

        public void Add(T item)
        {
            if (Count==Capacity)
            {
                T[] newarry = new T[Count * 2];
                Array.Copy(arry, newarry, Count);
                arry = newarry;
            }
            arry[Count] = item;
            count++;
        }

        public void Insert(int index, T item)
        {
            if (index>=0&&index<=Count)//可以插入最后一位
            {
                if (Count == Capacity)
                {
                    T[] newarry = new T[Count * 2];
                    Array.Copy(arry, newarry, Count);
                    arry = newarry;
                }

                for (int i = Count-1; i >= index; i--)
                {
                    arry[i + 1] = arry[i];
                }
                arry[index] = item;
                count++;
            }
            else
            {
                throw new Exception("索引超出范围");
            }


        }
        public int IndexOf(T item)
        {
            for (int i = 0; i < count; i++)
            {
                if (arry[i].Equals(item))
                {
                    return i;
                }
            }
            return -1;
        }
        public int LastIndexOf(T item)
        {
            for (int i = Count; i >=0; i--)
            {
                if (arry[i].Equals(item))
                {
                    return i;
                }
            }
            return -1;
        }

        public void RemoveAt(int index)
        {
            
             if (index >= 0 && index < Count)
             {
              
                for (int i = index; i < count-1; i++)
                {
                    arry[i - 1] = arry[i];
                }
                count--;
             }
            else
            {
                throw new Exception("索引超出范围");
            }

            
        }




        //         CompareTo(Object) 必须返回 Int32 具有以下三个值之一的，如下表所示。
        //注解
        //“值”	                含义
        //小于零     当前实例 CompareTo 在排序顺序中位于方法所指定的对象之前。
        //等于零    前实例与方法所指定的对象在排序顺序中出现的位置相同 CompareTo 。
        //大于零     此当前实例 CompareTo 在排序顺序中跟随方法所指定的对象之后。
    
    public void Sort()
        {
            for (int i = 0; i < Count-1; i++)
            {
                for (int j = 0; j < Count-i-1; j++)
                {
                    if (arry[j].CompareTo(arry[j+1])>0)
                    {
                        T tem = arry[j+1];
                        arry[j+1] = arry[j];
                        arry[j] = tem;
                    }
                }
            }
        }
    }
}

单链表

链表是用一组任意的存储单元来存储线性表中的数据元素（这组存储单元可以是连续的，也可以是不连续的）。在存储数据元素时，除了存储数据元素本身的信息外，还要存储与它相邻的数据元素的存储地址信息。这两部分信息组成该数据元素的存储映像，称为结点(Node)。把存储据元素本身信息的域叫结点的数据域，把存储与它相邻的数据元素的存储地址信息的域叫结点的引用域。

在这里插入图片描述

下图是线性表(a1,a2,a3,a4,a5,a6)对应的链式存储结构示意图。
在这里插入图片描述

(1)空间上：
单链表则是一次只开辟一个结点的空间，用来存储当前要保存的数据及指向下一个结点或NULL的指针，但由于每次开辟的空间不是连续的，容易形成碎片空间，造成空间的浪费
(2)时间上：

**访问随机元素的时间复杂度:**单链表的数据是链式存储的，它的元素是不支持随机访问的，想要知道某个元素，只能从头结点开始遍历整个链表，直到找到了该元素为止。
所以单链表访问随机元素的平均时间复杂度是O（n）。
随机位置插入、删除元素的时间复杂度：
单链表在插入或删除元素时，只需要改变它的前驱节点及插入或删除元素的指向即可，所以单链表在插入随机位置插入、删除元素的时间复杂度是O（1）。

链式表的实现

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

namespace _线性表
{
    /// <summary>
    /// 链式表(单向链表)
    /// </summary>
    class Chain<T> where T:IComparable
    {
        //T GetItem(int index);//获取索引对应的值
        //void Add(T item);//增添元素的方法    
        //void Insert(int index, T item);  //插入元素的方法
        //void RemoveAt(int index); // 移除对应指定索引处的元素。
        //int IndexOf(T item);//搜索指定的对象，并返回整个 System.Collections.Generic.List`1 中第一个匹配项的从零开始的索引。
        //int LastIndexOf(T item); //搜索指定的对象，第一个匹配项的从最后开始的索引。                               
        //void Sort();//从小到大排序
        int count;
        Node<T> head;

        public Chain()
        {
            head = null;
        }

        public int Count { get => count; }

        public T GetItem(int index)
        {
            if (index >= 0 && index < Count)
            {
               
                    Node<T> temp = head;
                    for (int i = 1; i <= index; i++)
                    {
                        temp = temp.next;
                    }
                  return temp.deta;
            }
            else
            {
                throw new Exception("索引超出范围");
            }
        }


        //通过索引器访问
        public T this[int index]
        {
            get
            {
                return GetItem(index);

            }
            set
            {
                if (index >= 0 && index < Count)
                {
                    Node<T> temp = head;
                    for (int i = 0; i < index; i++)
                    {
                        temp = temp.next;
                    }
                    temp.deta = value;
                }
                else
                {
                    throw new Exception("索引超出范围");
                }
            }
        }

        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 = head.next;
                }

                temp.next = newnode;
            }
            count++;
        }

        public void Insert(int index, T item)
        {
            Node<T> newnode = new Node<T>(item);
            if (index == 0)
            {//插入位置为第一个节点时

                head= newnode;
                newnode.next = head.next;
            }
            else
            {//插入位置为不是第一个节点时，获取插入位置的结点(currentNode)和插入位置前一个结点（preNode),
             //使插入位置前一个结点（preNode)指向新节点(newNode),新节点(newNode)指向插入位置的结点(currentNode)
                Node<T> temp = head;
                for (int i = 1; i <= index-1; i++)
                {
                    temp = temp.next;
                }
                Node<T> preNode = temp;
                Node<T> currentNode = temp.next;
                temp.next = newnode;
                newnode.next = currentNode;
            }
            count++;
        }
        public int IndexOf(T item)
        {
            Node<T> temp = head;
            int index = 0;
            while (temp!=null)
            {               
                if (temp.deta.Equals(item))
                {
                    return index;
                }
                index++;
                temp = temp.next;
            }
            return -1;
        }
        public int LastIndexOf(T item)
        {
            Node<T> temp = head;
            int index = 0;
            T[] array = new T[Count];
            while (temp != null)
            {
                array[index++] = temp.deta;
                temp = temp.next;
            }
            for (int i = index-1; i >=0; i++)
            {
                if (array[i].Equals(item))
                {
                    return i;
                }
            }
            return -1;
        }

        public void RemoveAt(int index)
        {           
            if (index == 0)
            {//移除位置为第一个节点时

                head = head.next;
              
            }
            else
            {//移除位置为不是第一个节点时，获取移除位置前一个结点（preNode),移除位后置一个结点（nextNode)
             //使移除位置前一个结点（preNode)指向移除位后置一个结点（nextNode)
                Node<T> temp = head;
                for (int i = 1; i <= index - 1; i++)
                {
                    temp = temp.next;
                }
                Node<T> preNode = temp;
                Node<T> nextNode = temp.next.next;
                preNode.next = nextNode;
            }
            count--;
        }

        public void Sort()
        {
            //获取所有节点位置
            Node<T> temp = head;
            Node<T>[] detas = new Node<T>[Count];
            for (int i = 0; i < Count; i++)
            {
                detas[i] = temp;
                temp = temp.next;
            }


            //冒泡排序
            for (int i = 0; i < Count - 1; i++)
            {
                for (int j = 0; j < Count - i - 1; j++)
                {
                    if (detas[j].deta.CompareTo(detas[j+1].deta)>0)
                    {
                        T temdeta = detas[j].deta;
                        detas[j].deta = detas[j + 1].deta;
                        detas[j+1].deta = temdeta;
                    }

                }
            }
        }

       

    }
}
_不动明王
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【数据结构】C#代码实现【顺序表】和【链表】
weixin_48343145的博客
04-24 2543
第一、创建一个接口 为了统一顺序表和链表的方法命名，先创建一个接口，里面定义了一般线性表所有方法的名称。 定义接口的原因：1.外部对不论顺序表还是链表的操作是一样的；2.但是顺序表和链表的具体方法实现不一样 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace case1 {//这是一个接口，头字母用I
【数据结构c#】线性表
intsum的博客
04-21 1189
线性表是是具有相同数据类型的n个数据元素的有限序列 依据存储结构分为顺序表和链表（链表又分为单链表，循环链表，双向链表，静态链表） 顺序表 特点是表中元素的逻辑顺序与物理顺序相同 以下为顺序表基础操作 #include<stdio.h> #define MAXSIZE 100//线性表存储空间的初始分配量 #define LISTINCREMENT//线性表存储空间的初始增量 typedef void Status; typedef int ElemType; //线性表的静态
数据结构-线性表的两种实现方式：顺序表和链表
a2352159950的博客
07-16 1155
顺序表就是在内存中按顺序连续开辟一段空间来存储数据的结构，在java中就是数组，如a所示 链表就是在内存中随机开辟内存一段段存储数据的结构，如图b所示 线性表的接口 使用一个接口表明基本操作的需求： public interface Ilist { //清空线性表 public void clear(); //判断线性表是否为空 public boolean isEmpty(); //获取线性表的长度 public int length(); /.
C#数据结构之线性表
zsqf813的博客
03-23 73
C#数据结构之线性表
C#实现一个顺序表和单链表
wangjun的博客
04-02 1149
1. 顺序表    定义了一个接口类IListDS,在类SeqList中实现。1.1 IListDS.csnamespace _401_线性表 { interface IListDS&lt;T&gt; { int GetLength(); void Claer(); bool IsEmpty(); void Add(T...
C#实现顺序表(线性表)完整实例
01-21
本文实例讲述了C#实现顺序表(线性表)的方法。分享给大家供大家参考，具体如下： 基本思想是使用数组作为盛放元素的容器，数组一开始的大小要实现确定，并使用一个Pointer指向顺序表中最后的元素。顺序表中的元素是...
数据结构学习--线性表及其应用--顺序表
06-25
在众多数据结构当中，线性表是最简单、也是最...本实验相对比较简单，通过本实验，对顺序表基本操作及 其组合应用的演练，加深对线性表顺序存储方法及其基本操作的理解，为以后进一步学习更 复杂的数据结构打下基础。
数据结构实验线性表（用java创建顺序表与链表并解决实验题目）
05-10
（1）创建一个顺序表，存放在数组 A[N]中，元素的类型为整型，设计算法调整 A，使其左边的所有元素小于 0，右边的所有元素大于 0（要求算法的时间复杂度和空间复杂度均为 O(n)）。 （2）建立一个循环单链表，其节点...
线性表的顺序存储API实现以及测试函数
03-26
第一个接触的一般就是线性表了，线性表虽然简单，但他起到了一个敲门砖的作用，理解并掌握了线性表在慢慢学习更高级的数据结构就可以慢慢入门了，在此，把线性表的顺序存储结构，API实现及测试函数上传，配套我的...
顺序表和数组（易混淆），线性表，链表的区别与联系 数组和链表.pdf
04-18
数据结构基础知识概述 本节内容将对顺序表、数组、线性表、链表的概念和...数据结构的基础知识包括逻辑结构、物理结构、线性表、顺序表、数组、链表等概念。只有牢固掌握这些基础知识，才能更好地理解和应用数据结构。
线性表小程序，C#,可以实现线性表中某一元素的删除、插入，及线性表的连接
12-10
线性表小程序，C#,可以实现线性表中某一元素的删除、插入，及线性表的连接，绝对原创，拿出来和大家分享一下，望大家多提宝贵意见
C#数据结构反转线性表算法
11-13
C#数据结构反转线性表算法 ...........
C# 数据结构- 线性表的几种实现
路漫漫其修远兮
05-31 2306
什么是线性表 线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即： （ 1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素； （ 2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。也就是说，数据元素是一个接一个的排列。...
C#（线性表）
qq_40223639的博客
03-26 362
1.线性表 线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即：（ 1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素；（ 2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。也就是说，数据元素是一个接一个的排列。因此，...
实验一顺序表的实现
Guangshan_H的博客
09-23 477
 #include using namespace std; const int MaxSize = 50; class SeqList { public: SeqList() { length = 0; } SeqList(int a[], int n); ~SeqList(){} int Length() { return length; } int Locate(int
【数据结构】C#代码实现【顺序栈】和【链栈】
weixin_48343145的博客
04-24 1931
第一、创建接口 包含了栈的所有方法，为统一命名，使用接口，在顺序栈和链栈的具体实现中就继承该接口，以此统一命名。 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace case2_Stack { interface IStack<T> { int Count { ge
数据结构之线性表(C#向)
ht_game的博客
03-19 643
线性表的定义：零个或多个数据元素的有限序列 线性表元素的个数n(n>=0)定义为**线性表的长度，**当n=0时，称为空表 线性表的中的元素的相邻的前一个元素称为直接前驱元素，后一个元素称为直接后继元素 线性表的顺序存储结构 定义：线性表的顺序存储结构，指的是用一段地址连续的存储单元依次存储线性表的数据元素 线性表长度：线性表中数据元素的个数 数组长度：存放线性表的存储空间的长度 1. 获得线性表的元素 通过数组的下标直接获得 int[] array = new int[] { 1,2,3,4,5
c#线性表
超纯的小白兔
01-31 2355
顺序表类SeqList的实现说明如下所示。 public class SeqList : IListDS { private int maxsize; //顺序表的容量 private T[] data; //数组，用于存储顺序表中的数据元素 private int last; //指示顺序表最后一个元素的位置 //索引器 public T this[int index] { get { retu
C++线性表是链表嘛
最新发布
09-01
引用主要介绍了C语言实现线性表之链表的原理和相关技巧。链表是一种线性表的实现方式之一，但并不是唯一的实现方式。除了链表，还有顺序表等其他实现线性表的方式。在C语言中，链表可以通过定义一个结构体来表示每个节点，每个节点包含数据和指向下一个节点的指针。通过不断创建新节点并将它们连接起来，就可以实现链表。所以可以说，C语言的线性表可以通过链表来实现。<span class="em">1</span> #### 引用[.reference_title] - *1* [C++语言实现线性表之链表实例](https://download.csdn.net/download/weixin_38665122/12806385)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_1"}}] [.reference_item style="max-width: 100%"] [ .reference_list ]

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值