数据结构与算法学习记录（一）

已于 2022-07-07 21:27:32 修改
阅读量141 收藏
点赞数
分类专栏： 笔记 文章标签： c# 数据结构
于 2022-07-07 21:26:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/erenlui/article/details/125664711
版权

数据结构对我来说其实并不陌生，写项目的时候其实也用的不少，但是很少关心他们底层是怎么实现的，还是要补一下，来自己写一下数据结构的实现。

今天主要是用两种方法实现List，一种是顺序表，一种是单链表

目录

1、先定义一个IListDS的接口，定义出需要具体实现的功能

2、List底层实现：

3、LinkList实现

1、先定义一个IListDS的接口，定义出需要具体实现的功能

namespace 数据结构与算法
{
    public interface IListDS<T>
    {
        /// <summary>
        /// 获取List长度（元素个数）
        /// </summary>
        /// <returns></returns>
        int GetLength();
        
        /// <summary>
        /// 清空List
        /// </summary>
        void Clear();
        
        /// <summary>
        /// 判断List是否为空
        /// </summary>
        /// <returns></returns>
        bool IsEmpty();
        
        /// <summary>
        /// 往List添加元素
        /// </summary>
        /// <param name="item"></param>
        void Add(T item);
        
        /// <summary>
        /// 往LIst插入元素
        /// </summary>
        /// <param name="item">要插入的元素</param>
        /// <param name="index">要插入的位置</param>
        void Insert(T item, int index);
        
        /// <summary>
        /// 删除元素
        /// </summary>
        /// <param name="index">要删除的元素位置</param>
        /// <returns>要删除的元素</returns>
        T Delete(int index);
        
        /// <summary>
        /// 索引器，通过下标访问具体元素
        /// </summary>
        /// <param name="index"></param>
        T this[int index] { get; }
        
        /// <summary>
        /// 通过下标获取元素
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        T GetEle(int index);
        
        /// <summary>
        /// 通过元素值返回下标
        /// </summary>
        /// <param name="value"></param>
        /// <returns></returns>
        int Locate(T value);
    }
}

2、List底层实现：

看源码的可以知道，list底层是用泛型数组来存储数据已经进行一系列操作的。

具体实现List中的方法

using System;

namespace 数据结构与算法
{
    /// <summary>
    /// 顺序表实现方式
    /// </summary>
    public class SeqList<T> : IListDS<T> //继承ListDS接口，实现其中的方法
    {
        private T[] data; //用来存储数据

        private int count; //表示存了多少个数据

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

        public SeqList() : this(10) //默认构造函数,默认容器的容量为10
        {
        }

        /// <summary>
        /// 往顺序表添加元素
        /// </summary>
        /// <param name="item"></param>
        public void Add(T item)
        {
            if (count == data.Length) //当前数组已经存满了
            {
                Console.WriteLine("当前顺序表已经存满，不允许再存数入");
            }
            else
            {
                data[count] = item;
                count++;
            }
        }

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

        /// <summary>
        /// 清除所有元素
        /// </summary>
        public void Clear()
        {
            count = 0;
        }

        /// <summary>
        /// 判断List是否为空
        /// </summary>
        public bool IsEmpty()
        {
            return count == 0;
        }

        /// <summary>
        /// 往顺序表插入元素
        /// </summary>
        /// <param name="item">插入的元素</param>
        /// <param name="index">插入的位置</param>
        public void Insert(T item, int index)
        {
            //从后往前遍历到index的位置，把index往后的元素都向后移动一位
            for (int i = count - 1; i >= index; i--)
            {
                data[i + 1] = data[i];
            }

            data[index] = item; //index位置上的元素改为要插入的元素
            count++; //总元素数自增
        }

        /// <summary>
        /// 按索引从顺序表删除元素
        /// </summary>
        /// <param name="index">索引值</param>
        public T Delete(int index)
        {
            T temp = data[index];
            //把被删除元素往后的元素都往前移动一位
            for (int i = index + 1; i < count; i++)
            {
                data[i - 1] = data[i];
            }

            count--;
            return temp;
        }

        public T this[int index] => GetEle(index);


        /// <summary>
        /// 按照索引获取元素
        /// </summary>
        /// <param name="index"> 索引值 </param>
        /// <returns></returns>
        public T GetEle(int index)
        {
            if (index >= 0 && index <= count - 1) //索引存在
            {
                return data[index];
            }
            else
            {
                Console.WriteLine("索引不存在");
                return default(T);
            }
        }

        /// <summary>
        /// 根据元素值获取元素索引
        /// </summary>
        /// <param name="value">元素值</param>
        public int Locate(T value)
        {
            for (int i = 0; i < count; i++)
            {
                if (data[i].Equals(value))
                {
                    return i;
                }
            }

            return -1;//如果返回-1，表示元素不存在
        } }
}

自己写完这个实现也能发现List的特点：在末尾添加删除操作效率高，在中间插入删除元素效率较低，因为需要整体移动被修改元素之后的所有元素。

3、LinkList实现

先定义一个Node节点类：

using System;
using System.Collections.Generic;
using System.Text;

namespace 数据结构与算法
{
    /// <summary>
    /// 单链表的节点
    /// </summary>
    /// <typeparam name="T"></typeparam>
    class Node<T>
    {
        private T data;//存储数据
        private Node<T> next;//指针，用来指向下一个元素

        public Node()
        {
            data = default(T);//default:返回元素的默认值
            next = null;
        }

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

        public Node(T value, Node<T> next)
        {
            this.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; }
        }

    }
}

具体代码：

using System;
using System.Collections.Generic;
using System.Text;

namespace 数据结构与算法
{
    class LinkList<T> : IListDS<T>
    {
        private Node<T> head;//存储一个头节点
        public LinkList()
        {
            head = null;
        }

        /// <summary>
        /// 索引器
        /// </summary>
        public T this[int index]
        {
            get
            {
                Node<T> temp = head;
                for (int i = 1; i <= index; i++)
                {
                    temp = temp.Next;
                }

                return temp.Data;
            }
        }

        /// <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 (true)//死循环
                {
                    if (temp.Next != null)//如果下一个节点不为空
                    {
                        temp = temp.Next;//把下一个节点赋值给temp
                    }
                    else //直到没有下一个节点了
                    {
                        break;
                    }
                }
                temp.Next = newNode;//把新的节点放到链表的尾部
            }

        }

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

        /// <summary>
        /// 按索引从顺序表删除元素
        /// </summary>
        /// <param name="index">索引值</param>
        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向后移动index - 1个位置（移动到要删除的位置的前一个位置）
                    temp = temp.Next;
                }
                Node<T> preNode = temp;//要删除的位置的前一个节点就为temp
                Node<T> curNode = temp.Next;//要删除的节点
                data = curNode.Data;//要删除的节点的数据
                Node<T> nextNode = temp.Next.Next;//要删除的节点的后一个节点
                preNode.Next = nextNode;//把要删除的节点的【前一个节点】指向要删除的节点的【后一个节点】
            }

            return data;
        }

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

        /// <summary>
        /// 获取链表长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            if (head == null)//如果头节点为空
            {
                return 0;//没有元素返回0
            }
            Node<T> temp = head;//设一个临时变量为头节点
            int count = 1;//元素数量至少为1
            while (true)
            {
                if (temp.Next != null)//如果头节点的下一个节点不为空
                {
                    count++;//元素数量自增
                    temp = temp.Next;//重新赋值临时变量
                }
                else
                {
                    break;//直到没有下一个节点为止，跳出循环
                }
            }

            return count;//最后返回元素数量
        }

        /// <summary>
        /// 往单链表中插入元素
        /// </summary>
        /// <param name="item"></param>
        /// <param name="index"></param>
        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向后移动index - 1个位置（移动到要插入的位置的前一个位置）
                    temp = temp.Next;
                }
                Node<T> preNode = temp;//要插入的位置的前一个节点就为temp
                Node<T> curNode = temp.Next;//要插入的位置的节点就是上个节点的Next
                preNode.Next = newNode;//把要插入的位置的前一个节点指向新节点
                newNode.Next = curNode;//把新节点指向要插入的位置的节点
            }
        }

        /// <summary>
        /// 链表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return head == null;
        }

        /// <summary>
        /// 根据元素值获取元素索引
        /// </summary>
        /// <param name="value">元素值</param>
        public int Locate(T value)
        {
            Node<T> temp = head;
            if (temp == null)//如果没有头节点
            {
                return -1;//返回-1，表示链表内没有元素
            }
            else
            {
                int index = 0;
                while (true)
                {
                    if (temp.Data.Equals(value))//如果节点的值等于value
                    {
                        return index;//返回下标
                    }
                    else//如果节点的值不等于value
                    {
                        if (temp.Next != null)//下一个节点也不为空
                        {
                            temp = temp.Next;//向下遍历
                        }
                        else
                        {
                            break;//直到没有下一个节点为止
                        }
                    }
                }

                return -1;
            }
        }
    }
}

用单链表来实现还是有点复杂的。。。

具体的测试代码就不放了，都测试过没有问题了。

PS：以上代码只是简单实现，并没有考虑代码的健壮性，一些参数检查的工作没有做。

ErenlFY
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法Python版学习笔记一
12-21
多行输入，每一行对应一个input函数，根据题目要求的数据类型进行转换 如果每行一个整数，则可以写入以下代码： a = int(input()) 单行输入多个变量（以字符串形式保存）： #输入两个变量 a,b = input().split() #...
数据结构与算法学习笔记.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
C# 关于判断字符串为空的一些方法
lgheden的专栏
07-16 573
1. 三种常用的字符串判空串方法： 　　Length法：bool isEmpty = (str.Length == 0); 　　Empty法：bool isEmpty = (str == String.Empty); 　　General法：bool isEmpty = (str == ""); 2. 深入内部机制： 　　要探讨这三种方法的内部机制，我们得首先看看.NET是怎样实现的，也就
C#实现一个顺序表和单链表
wangjun的博客
04-02 1147
1. 顺序表    定义了一个接口类IListDS,在类SeqList中实现。1.1 IListDS.csnamespace _401_线性表 { interface IListDS&lt;T&gt; { int GetLength(); void Claer(); bool IsEmpty(); void Add(T...
C# 数据结构 线性表（顺序表 链表 IList 数组）
weixin_30878361的博客
07-13 379
线性表 线性表是最简单、最基本、最常用的数据结构。数据元素 1 对 1的关系，这种关系是位置关系。 特点 （1）第一个元素和最后一个元素前后是没有数据元素，线性表中剩下的元素是近邻的，前后都有元素。 （2）线性表中的元素是有限的（List），线性表中的数据类型一致。 （3）线性表表示方法 L={a1,a2,a3,a4…….an},L=(D,...
C#中IList与List区别
十年磨一剑，沉淀……
09-17 2495
List是一个类（Class）List<T> myFuckList = List<T>();变量 myList 是一个List类型的变量， 可以接受任意继承自List类的类。比如你可以自己实现一个 TheList类，继承自List。都可以赋值给myList。IList是一个接口（Interface）IList<T> myIList = List<T>();变量 myIList 是一个IList类型的
线性表-顺序表和单链表的定义与基本操作
学无止境
01-20 1325
<br />线性表接口定义：IListDS.cs<br /> public interface IListDS<T> { int GetLength(); //求长度 void Clear(); //清空操作 bool IsEmpty(); //判断线性表是否为空 void Append(T item); //附加操作 void Insert(T item, int i); //插入操作
数据结构与算法学习笔记一 —–时间复杂度
01-06
在计算机领域上，算法本质上是一系列的指令，用于解决特定的运算或逻辑问题。 简单点就是：就是解决某类问题的方法，当然某类问题会有很多的解决方法，这些方法就是算法的一种。有多种的解决方法，那么各种方法就有...
数据结构与算法的学习笔记.zip
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
C++数据结构与算法学习笔记
11-22
C++数据结构与算法学习笔记，供大家参考学习用，祝各位学习顺利！
三种常用的字符串判空串方法执行速度比较
weixin_33727510的博客
02-23 193
三种常用的字符串判空串方法： 　　　1: bool isEmpty = (str.Length == 0); 　　　2: bool isEmpty = (str == String.Empty); 　　　3: bool isEmpty = (str == ""); 　　哪种方法最快？ 以下是测试代码： using System; public class strLengt...
isEmpty和null的区别
weixin_33724046的博客
12-12 214
2019独角兽企业重金招聘Python工程师标准>>> ...
C#中NULL,"",DBNULL,String.Empty,Convert.IsDBNull()的区别
周雅钧
02-24 1319
<br />string.Empty就相当于"" <br />一般用于字符串的初始化 <br />比如： <br />string a; <br />Console.WriteLine(a);//这里会报错，因为没有初始化a<br />而下面不会报错： <br />string a=string.Empty; <br />Console.WriteLine(a);<br />或者用于比较： <br />if(a=="") <br />if(a==string.Empty) <br />上面两句是一样的效果。
bool布尔类型占位符
落霞与孤鹜齐飞，秋水共长天一色。
12-27 4134
今天考试，定义了一个布尔类型变量，想从键盘输入，思索再三也没想起来是什么占位符，索性用整型零和一代替
集合
行走的逗比
11-16 559
template class ListSet:public DynamicSet { public: ListSet(int mSize); ~ListSet(){delete []l;} bool IsEmpty()const{return n==0;} bool IsFull()const{return n==maxSize;} bool Search(T
使用String类的.isEmpty()方法无法判断字符串为null的情况
Java_Long_Asus的博客
09-30 2575
（1）String的三种状态：null ， “” 和new String,其中，“”和new String都是有占位符的，而为null的情况不会创建占位符。   （2）而isEmpty()方法只会判断有占位符的情况，所以在为null的时候会报空指针异常。   （3）所以可以使用  org.apache.commons.lang3  包下的StringUtils工具类中的isBlank(st...
基于C++语言堆栈push,pop,~stack,isEmpty,isFull实现
Linus_Yan的博客
04-18 1106
以下代码是基于C++语言写的堆栈的压栈，出栈，清栈，读栈指针等方法，在Visual studio 中，可直接使用，供学习者参考学习，希望大家点赞，关注，多多鼓励继续写下去。 stack.h头文件1. #ifndef _STACK_H #define _STACK_H const int MAX_SIZE = 100; class Stack { private: char *data; int size; int top; public: Stack(); //构造函数 Stack(int s); /
isEmpty()和isNotEmpty()区别
Mr_XiaoYuan011的博客
04-13 5508
isEmpty(A);  若A为空，返回true；否则返回false;isNotEmpty(A); 若A为空，返回false,否则返回true;
day26-1boolean isEmpty(): 判断字符串是不是空串,如果是空的就返回true
weixin_34191734的博客
03-19 850
public static void main(String[] args){ fu(); } public static void fu(){ String a=""; System.out.print("原函数"+a+" "); boolean a1=a.isEmpty(); System.out.println("修改后"+a1); } 转载于:https://www.cnbl...
数据结构与算法c++笔记
08-31
很高兴回答你关于数据结构与算法的问题！以下是一些关于C语言中数据结构和算法...这只是数据结构与算法的一小部分内容，还有很多其他知识点和算法可以学习。希望这些笔记对你有所帮助！如果你有任何问题，请随时提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值