C#_dailylifeDataStructure

最新推荐文章于 2024-07-10 10:02:20 发布
最新推荐文章于 2024-07-10 10:02:20 发布
阅读量60 收藏
点赞数
分类专栏： Unity & C# 文章标签： c#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Mr_PEaSutBUtteR/article/details/130987781
版权

线性表


            List<string> list = new List<string>();
            list.Add("12");
            list.Add("asdkj");
            list.Add("jsadklsss");
            list.Add("jsadklsss11");
            list.Add("ss");
            list.Remove("12");
            Console.WriteLine(list.IndexOf("ss"));

            Console.WriteLine(list[0] + list[1]);

顺序表

内存中顺序存储,地址连续。

 class SeqList<T> : Ilist<T>
    {
        /// <summary>
        /// 顺序表实现方式
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        /// <exception cref="NotImplementedException"></exception>
        T Ilist<T>.this[int index] => throw new NotImplementedException();
        private T[] data;//用来存储数据
        private int count = 0;

        
        
        public SeqList(int size)
        {
            data = new T[size];
            count = 0;
        }

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

        }

        void Ilist<T>.Add(T item)
        {
            if(count == data.Length)
            {
                Console.WriteLine("List is full");
            }
            else
            {
                data[count++] = item;
            }
        }

        void Ilist<T>.Clear()
        {
            count = 0;
        }

        T Ilist<T>.Delete(int index)
        {
            T t = data[index];
            for(int i = index+1; i < count; i++)
            {
                data[i-1]= data[i]; 
            }
            count--;
            return t;
        }

        T Ilist<T>.GetEle(int index)
        {
            if(index >= 0 && index < count - 1)
            {
                return data[index];
            }
            else
            {
                Console.WriteLine("not exsits");
                return default(T);
            }
        }

        int Ilist<T>.GetLength()
        {
            return count;
        }

        void Ilist<T>.Insert(T item, int index)
        {
            for(int i = count-1; i >= index; i--)
            {
                data[i+1] = data[i];
            }
            data[index] = item;
            count++;
        }

        bool Ilist<T>.IsEmpty()
        {
            if (count == 0)
                return true;
            else
                return false;
        }

        int Ilist<T>.Locate(T value)
        {
            for(var i = 0; i < count; i++)
            {
                if (data[i].Equals(value))
                {
                    return i;
                }
            }
            return -1;//不存在
        }
    }

public static void main(){
 List<string> list = new List<string>();
            list.Add("12");
            list.Add("asdkj");
            list.Add("jsadklsss");
            list.Add("jsadklsss11");
            list.Add("ss");
            list.Remove("12");
            Console.WriteLine(list.IndexOf("ss"));

            Console.WriteLine(list[0] + list[1]);



}

单链表

internal class LinkList<T> : Ilist<T>
    {
        private Node<T> head; //头节点
        private T data;
        public LinkList()
        {
            head = null; 
        }
         T Ilist<T>.this[int index]
        {
            get
            {
                Node<T> temp = head;
                for (int i = 0; i < index; i++)
                {
                    temp = temp.Next;

                }
                return temp.Data;
            }
        } 

        void Ilist<T>.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指向尾节点
                temp.Next = newNode;
            }
        }

        void Ilist<T>.Clear()
        {
            head = null;
        }

        T Ilist<T>.Delete(int index)
        {
            if(index == 0)
            {
                head = head.Next;
                data = head.Data;

            }
            else
            {
                Node<T> temp = head;//头节点赋值给temp
                for (int i = 0; i < index - 1; i++)
                {
                    temp = temp.Next;//向后移动index次
                }
                Node<T> preNode = temp;
                Node<T> currentNode = temp.Next;
                data = currentNode.Data;

                Node<T> nextNode = temp.Next.Next;
                preNode.Next = nextNode;

            }
            return data;
        }

         T Ilist<T>.GetEle(int index)
        {
            return this[index];
        }

        int Ilist<T>.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;
        }

        void Ilist<T>.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 = 0; i < index-1; i++)
                {
                    temp = temp.Next;//向后移动index次
                }
                Node<T> preNode = temp;
                Node<T> currentNode = temp.Next;
                preNode.Next = newNode;
                newNode.Next = currentNode;
            }
        }

        bool Ilist<T>.IsEmpty()
        {
            return head == null;
        }

        int Ilist<T>.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;
            }
        }
    }

双向链表

每个节点多了一个指向前驱节点的引用。
表头没有前驱节点，表尾没有后继节点。

循环链表

尾节点指向表头节点的单链表。

栈

受限制的线性表，先进后出

 static void Main(string[] args)
        {
            Stack<string>stack = new Stack<string>();
            stack.Push("213");
            stack.Push("as");
            Console.WriteLine(stack.Count);
            stack.Pop();
            stack.Push("ads");
            stack.Pop();    
            Console.WriteLine(stack.Peek());//空栈取元素，会异常
            stack.Clear();
            Console.WriteLine(stack.Count);

        }

栈的接口

 internal interface IStackDS<T>
    {
        int Count { get; }//存储数据的个数
        int GetLength();
        bool IsEmpty();
        void Clear();
        void Push(T item); 
        T Pop();
        T Peek();
    }

顺序栈

internal class SeqStack<T> : IStackDS<T>
    {

        private T[] data;
        private int top;

        public SeqStack(int size)
        {
            data = new T[size];
            top = -1;
        }

        public SeqStack()
        {
            data = new T[10];
            top = -1;
        }


        int IStackDS<T>.Count
        {
            get { return top + 1; }
        }

        void IStackDS<T>.Clear()
        {
            top = -1;
        }

        int IStackDS<T>.GetLength()
        {
            return top + 1;

        }

        bool IStackDS<T>.IsEmpty()
        {
            return top == -1;
        }

        T IStackDS<T>.Peek()
        {
            return data[top];
        }

        T IStackDS<T>.Pop()
        {
            T temp = data[top];
            top--;
            return temp;
        }

        void IStackDS<T>.Push(T item)
        {
            top++;
            data[top] = item;
        }
    }

链栈

internal 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(T data, Node<T> next) : this(data)
        {
            this.next = next;
        }  
        public Node(Node<T> next)
        {
            data = default (T);
            this.next = next;
        }

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

    }

   internal class LinkStack<T> : IStackDS<T>
    {
        private Node<T> top;//栈顶
        private int count = 0;//栈中元素的个数
        
        
        /// <summary>
        ///  取得栈中元素的个数
        /// </summary>
        public int Count
        {
            get { return count; }
        }

        public void Clear()
        {
            count = 0;
            top = null;
        }

        public int GetLength()
        {
            return count;
        }

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

        public T Peek()//取得栈顶数据
        {
            return top.Data;
        }

        public T Pop()
        {
            T temp = top.Data;
            top = top.Next;
            count--;
            return temp;

        }

        public void Push(T item)
        {
            Node<T> newNode = new Node<T>(item);   
            count++;
            newNode.Next = top;
            top = newNode;
            
        }
    }

队列

操作受限的线性表

 static void Main(string[] args)
        {
            Queue<int> queue = new Queue<int>();
            queue.Enqueue(1);
            queue.Enqueue(2);
            queue.Enqueue(3);
            Console.WriteLine(queue.Count);
            int k = Convert.ToInt32(Console.ReadLine());
            queue.Enqueue(k);
            Console.WriteLine(queue.Dequeue());
            Console.WriteLine(queue.Dequeue());
            Console.WriteLine(queue.Dequeue());
            Console.WriteLine(queue.Peek());
            Console.WriteLine(queue.Count);


        }

队列的接口

  internal interface IQueue<T>
    {
        int Count { get; }
        int GetLength();
        bool IsEmpty();
        void Clear();
        void Enqueue(T item);
        T Dequeue();
        T Peek();

    }

顺序队列

internal class SeqQueue<T> : IQueue<T>
    {
        private T[] data;
        private int count;//当前元素个数
        private int front;//队首元素索引减1
        private int rear;//队尾元素索引

        public SeqQueue(int size)
        {
            data = new T[size];
            count = 0;
            front = rear = -1;
        }
        public SeqQueue()
        {
            data = new T[10];
            count = 0;
            front = rear = -1;

        }
        public int Count
        {
            get { return count; }
        }

        public void Clear()
        {
            count = 0;
            front = rear = -1;

        }

        public T Dequeue()
        {
            if(count <= 0)
            {
                Console.WriteLine("Queue is empty");
                return default(T);
            }
            else
            {
                front = (front + 1)%data.Length;
                T temp = data[front];
                count--;
                return temp;
                
            }
        }

        public void Enqueue(T item)
        {
            if(count == data.Length)
            {
                Console.WriteLine("Queue is full");
            }
            else
            {
                rear = (rear + 1) % data.Length;
                data[rear] = item;
                count++;
            }
        }

        public int GetLength()
        {
            return count;
        }

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

        public T Peek()
        {
            return data[(front + 1) % data.Length];
        }
    }

链队

  internal class Node<T>
    {
        private T data;
        private Node<T> next;

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



  internal class LinkQueue<T> : IQueue<T>
    {
        
        private int count;
        private Node<T> front;//头节点
        private Node<T> rear;//尾节点
      
        public LinkQueue()
        {
            count = 0;
            front = rear = null;
        }

        public int Count
        {
            set { count = value; }
            get { return count; }   
        }

        public void Clear()
        {
            count = 0;
            front = rear = null;
        }

        public T Dequeue()
        {
            if(front == null)
            {
                Console.WriteLine("Queue is Empty.");
                return default(T);
            }
            else
            {
                T temp = front.Data;
                front = front.Next;
                count--;
                return temp;
            }
          
        }

        public void Enqueue(T item) //尾部入队，头部出队
        {
            Node<T> newNode = new Node<T>(item);
            count++;
            if (rear == null)//空队
            {
                front = rear = newNode;
            }
            else
            {
                rear.Next = newNode;
                rear = newNode;
            }

          
        }

        public int GetLength()
        {
            return count;
        }

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

        public T Peek()
        {
            return front.Data;
        }
    }

串

string类的实现

  internal class StringDS
    {
        private char[] data;
        public StringDS(char[] array)
        {
            data = new char[array.Length];
            for (int i = 0; i < data.Length; i++)
            {
                data[i] = array[i];
            }
        }

        public StringDS(string str)
        {
            data = new char[str.Length];
            for (int i = 0; i < data.Length; i++)
            {
                data[i] = str[i];
            }
        }

        public char this[int index] //根据索引器取字符
        {
            get { return data[index]; }
        }
        public int GetLength()
        {
            return data.Length;
        }
        /*如果两个字符串一样，返回0
         * 如果当前字符小于other，返回-1
         * 如果当前字符大于other，返回1
         */
        public int Compare(StringDS other)
        {
            int len = this.GetLength() < other.GetLength()?this.GetLength():other.GetLength();
            //取得两个字符串中长度更小的字符串的长度
            int index=-1;
            for (int i = 0; i < len; i++)
            {
                if (this[i] != other[i])
                {
                    index = i;
                    break;
                }
            }
            if(index!= -1) //index为不等于字符出现的位置
            {
                if (this[index] > other[index])
                {
                    return 1;
                }
                else
                {
                    return -1;
                }
            }
            else //短字符串和长字符串在重复区域匹配 或者 两字符串完全一样
            {
                if(this.GetLength() == other.GetLength())
                {
                    return 0;
                }
                else
                {
                    if(this.GetLength() > other.GetLength()) { return 1; }
                    else { return -1; }
                }
            }
        }
    }

数组

Array类

static void Main(string[] args)
        {
            int[] list = { 34, 72, 13, 44, 25, 30, 10 };
            int[] list2 = new int[10];
            Console.Write("原始数组： ");
            
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

            // 逆转数组
            Array.Reverse(list);
            //搜索
            Console.WriteLine("25在list中出现的位置是"+Array.IndexOf(list, 25));
            //获取元素
            Console.WriteLine(list.GetValue(0));
            //复制
            //Array.Copy(list, list2, 7);
            list.CopyTo(list2, 0);
            foreach (int i in list2)
            {
                Console.Write(i+" ");
            }

            Console.Write("逆转数组： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

            // 排序数组
            Array.Sort(list,0,3);
            Console.Write("局部排序数组前四个： ");
            foreach (int i in list)
            {
                Console.Write(i + " ");
            }
            Console.WriteLine();

            Console.ReadKey();
        }
欧尼sama
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c# 拼接字符串数组_C#_字符串拼接_浅
weixin_42386504的博客
01-12 4181
测试环境：Unity2018.4；.Net4.x。需要注意.Net4.x和3.5差异还是挺大的写的内容大部分网上已有，算是总结他人的成果，是浅谈。1、先说几条结论：1_1、字符串在C#中是高频出现的1_2、这类高频出现方法、字段通常不是每帧的性能瓶颈。但有可能是瞬间卡顿的来源。1_3、字符串内存开销计算：26b(基础开销) + string.Length * sizeof(char)。如字符串“1...
Unity.rar_AGV C#_AGV C#_C# AGV小车_C# AGV小车_UNITY AGV
07-15
C#实现对XBOx控制AGV小车，实现仓库管理自动化
C#_遍历枚举
ashmoc的博客
09-28 3396
C#_遍历枚举 Enum.GetValues(typeof(EnumName))
C#_宏定义
Mudrock__的博客
05-06 2846
宏定义常用于版本控制，例如在X环境下使用A代码，在Y环境下使用B代码示例代码#if!VERSION_3#else#endif#else#endif运行效果。
C#_弹出提示窗口
瞎点技能树
11-10 2859
using System.Runtime.InteropServices; /*初始化RGB增益*/ float prGain = 0; float pgGain = 0; float pbGain = 0; status = DVPCamera.dvpGetRgbGain(m_handle, ref prGain,ref pgGain, ref pbGain);//获取色彩增益 if(status!=dvpStatus.DVP_STATUS_OK) { MessageBox.Show("黑白相机不支.
C# _ => { }是什么情况
飞哥的专栏
09-01 4228
说起lambda表达式其实简单理解为一个方法，什么方法呢--是个匿名方法（就是一个没名字的方法） 第一种 () => { }; 是一个既没有参数又没有返回值的方法 第二种 x => x+2; 是一个参数为x返回值为x+2的方法 第三种 (x, y) => x + y; 是一个参数为x和y返回值为两个参数之和的的方法,当参数大于一个的时候lambda前面的参数房子一对括
C#_三层（BLL DAL Model）架构详解
热门推荐
KevinJee_
04-23 2万+
C#_三层架构详解 三层架构： 表现层（UI）、业务逻辑层（BLL）、数据访问层（DAL）再加上实体类库（Model） 表现层（UI）：一般都是窗体的设计或者网页的设计，是可以一眼就可以看到的界面。 业务逻辑层（BLL）：对传送数据进行逻辑判断分折，并进行传送正确的值。 数据访问层（DAL）：主要是存放对数据类的访问，即对数据库的添加、删除、修改、更新等基本操作。 实体类库（Model）：主要存放...
C#使用mouse_event函数模拟鼠标事件
DingDong的博客
10-26 3271
C#使用mouse_event函数模拟鼠标事件
锐浪报表C#_web
路漫漫 修远兮
07-03 3808
前言： 维护项目需要用锐浪报表；问：使用锐浪（Grid++Report ）之前的要做什么？ 答： 看清楚版本是Grid++Report 4.5，Grid++Report5.6 ，Grid++Report5.8 还是Grid++Report6.3 版本会不断迭代；任何插件都是版本的就像是jquer(如果你要支持IE 6/7/8，就选择 1.9 版,反之2.X)Version='5.6.0.5'直
C#_ProgressBar 显示进度数字
PJZero
04-16 9930
使用ProgressBar，并且通过数字的形式显示进度，一开始以为很简单啊（其实是真的很简单），于是乎一开始的代码是这样的：public partial class Form1 : Form { public Form1() { InitializeComponent(); } protected override void OnLoad(EventAr
C#_chart 控件曲线坐标值，根据鼠标移动浮动显示(六)
qq_51108184的博客
04-06 6109
效果如下：操作 设置方法如下 1.找到chart控件的series属性 2.将集合下isxvayleindexed属性设置为true 3.在鼠标移动事件下添加以下代码 chart1.Series[0].ToolTip = “X：#VALX\nY：#VALY”;
C#_Serial communication.rar_C#_C# serial
07-14
C#_Serial communication
UHFRFIDReader.rar_C#_UHF RFID_gardenweh_uhf
07-13
UHF RFID Reader Test
EncryptText_C#_
10-02
C# 利用图片加密文件
daybook_C#_
10-02
C#编写实现一个个人日记本程序源代码，实际上是一个简单的C#+SQLSERVER程序，用于演示在C#中如何使用数据库，程序实现了日期自动生成功能、添加日记内容保存到数据库的功能、选项天气状况等功能，数据库文件在...
C#—Json序列化和反序列化
最新发布
qq_3517289697的博客
07-10 861
在C#中，可以使用System.Web.Script.Serialization.JavaScriptSerializer类来序列化和反序列化JSON数据。可以使用Newtonsoft.Json库进行JSON的序列化。可以使用.NET内置的System.Text.Json库来进行JSON的序列化。
【C++】设计一套基于C++与C#的视频播放软件
kewaqi618的博客
07-08 932
功能：支持多种视频格式播放，自动检测并解码。实现：在后端VideoPlayer类中，通过调用VideoDecoder的解码功能，将解码后的视频帧传递给前端。然而，在C++/C#混合编程中，直接传递视频帧数据可能较为复杂且效率低下，因为C#无法直接处理C++中的内存分配。因此，一种常见的做法是在C++中处理视频解码，并将解码后的帧数据（如YUV或RGB格式）转换为字节流或图像文件（如BMP），然后通过文件共享、内存映射文件或网络传输等方式传递给C#前端。
Boost Security with SSH/SFTP Public
q2315702359的博客
07-08 1404
　　SocketTools .NET Edition eliminates password vulnerabilities and simplifies access management for secure file transfers and server communication.　　SocketTools .NET Edition by Catalyst Development Corp. is a development library designed to simplify adding
C#中简单Socket编程
weixin_45144862的博客
07-09 343
TCP通信服务端的通信过程是：第一步调用Socket创建套接字。第二步：调用Bind()函数将套接字绑定到指定的IP地址和端口号。第三步：调用Listen()函数监听套接字。Socket分为面向连接的套接字(TCP套接字)和面向消息的套接字(UDP 套接字)。客户端套接字通信过程是：第一步:调用Socket类创建套接字。第一步：创建套接字。第一步：创建套接字。第二步：将套接字绑定到指定IP地址和端口号。UDP通信是面向消息的通信方式。接下来，我用C#语言来进行简单的TCP通信和UDP通信。
C# __FUNCTION__
01-13
C#中没有内置的__FUNCTION__关键字来获取当前函数的名称。但是你可以使用System.Reflection命名空间中的MethodInfo类来获取当前函数的名称。下面是一个示例代码： ```csharp using System; using System.Reflection; public class MyClass { public void MyMethod() { string functionName = MethodBase.GetCurrentMethod().Name; Console.WriteLine("Current function name: " + functionName); } } public class Program { public static void Main(string[] args) { MyClass myObject = new MyClass(); myObject.MyMethod(); // 输出：Current function name: MyMethod } } ``` 在上面的示例中，我们使用MethodBase.GetCurrentMethod().Name来获取当前函数的名称，并将其打印出来。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值