C#算法与数据结构之线性结构

最新推荐文章于 2021-09-02 21:16:54 发布
最新推荐文章于 2021-09-02 21:16:54 发布
阅读量89 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/redkop/p/7724985.html
版权

线性结构是什么？

　　线性结构是一种数据结构，它有一对一的关系，就像一个长对，一个接一个，特点是，除第一个元素和最后一个元素外，其它元素前后只有一个元素。

　　简单示例1：

       

static void Main(string[] args)
{
//使用BCL中的List线性表
List<string> strList = new List<string>();
strList.Add("123");
strList.Add("456");
strList.Add("789");
Console.WriteLine(strList[1]);
Console.WriteLine(strList.Count);
strList.Remove("123"); //去除某一元素
Console.WriteLine(strList[1]);
Console.WriteLine(strList.Count);

}

　　输出为：456

　　　　　　3　　

　　　　　　789

　　　　　　2

线性表实现方式

    　　　　顺序表：连续排放

　　　　    单链表：

　　　　　　双向链表

　　　　　　循环链表

自设一个List<>:

首先创建一个接口，然后实现接口得所有方法，完程自建List功能：

  class SeqList<T>:IListDS<T>
    {
        private T[] data;     //存储数据
        private int count = 0;

        public SeqList(int size)         
        {
            data = new T[size];
            count = 0;
        }
        public SeqList():this(10)      //默认构造函数10
        {

        }
        public void Add(T item)        //添加物件
        {
            if(count == data.Length)
            {
                Console.WriteLine("空间已存满");
            }
            else
            {
                data[count] = item;
                count++;
            }
        }
        //取得数据个数

        public int GetLength()           //得到长度
        {
            return count;
        }

        public T GetEle(int index)         //返回索引
        {
            if(index>=0&&index<=count-1)
            {
                return data[index];
            }
            else
            {
                Console.WriteLine("索引不存在");
                return default(T);
            }
        }
        public void Clear()
        {
            count = 0;
        }
        public bool IsEmpty()
        {
            return count == 0;
        }
        public void Insert(T item,int index)
        {
            
            for(int i=count-1;i>=count;i--)
            {
                data[i + 1] = data[i];
            }
            data[index] = item;
            count++;
        }
        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]
        {
            get { return GetEle(index); }
        }
        public int Locate(T value)
        {
            for(int i=0;i<count;i++)
            {
                if(data[i].Equals(value))
                {
                    return i;
                }
            }
            return -1;
        }
           
    }

测试：

  static void Main(string[] args)
        {
            SeqList<string> seqList = new SeqList<string>();
            seqList.Add("123");
            seqList.Add("456");
            seqList.Add("789");
            Console.WriteLine(seqList.GetEle(1));
            Console.WriteLine(seqList[1]);
            seqList.Insert("666",1);
            for(int i=0;i<seqList.GetLength();i++)
            {
                Console.WriteLine(seqList[i] + ".");
            }
            seqList.Clear();
            Console.WriteLine(seqList.GetLength());
            Console.ReadKey();



        }

结果：

456
456
123.
666.
456.
789.
0              结果OK，功能实现

单链表：     data     next                      示图:        

 

 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)
        {
            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; }
        }
        
        
    }
class LinkList<T>:IListDS<T>
    {
        private Node<T> head;
        public LinkList()
        {
            head = null;
        }
        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 Insert(T item, int index)
        {
            Node<T> newNode = new Node<T>(item);
            if(index==0)
            {
                newNode.Next = head;
            }
            else
            {
                Node<T> temp = head;
                for(int i=1;i<index-1;i++)
                {
                    temp = temp.Next;
                }
                Node<T> preNode = temp;
                Node<T> currentNode = temp;
                preNode.Next = newNode;
                newNode.Next = currentNode;
            }
        }
        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;
                data = currentNode.Data;
                Node<T> nextNode = temp.Next.Next;
                preNode.Next = nextNode;
                
            }
            return data;
        }
        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 Clear()
        {
            head = null;
        }
        public bool IsEmpty()
        {
            return head == null;
        }
        public T this[int index]
        {
            get
            {
                Node<T> temp = head;
                for(int i=1;i<=index-1;i++)
                {
                    temp = temp.Next;
                }
                return temp.Data;
            }
        }
        public T GetEle(int index)
        {
            return this[index];
        }
        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;
            }
        }
    }

 

转载于:https://www.cnblogs.com/redkop/p/7724985.html

weixin_34128237
关注
C#数据结构之线性结构
王利威的博客
08-06 450
线性结构是最简单，最基本，最常用的数据结构。 特点是：数据元素之间存在一对一的线性关系。一对一的关系指位置关系。 线性结构（List）由n个相同类型的数据元素构成的有限序列。常用的 数组，泛型 都是线性结构。 线性结构的基本操作：List<T> int GetLength(); //求长度 void Clear(); //清空 bool isEmoty(); //是否为...
3. C#数据结构与算法 -- 线性结构（线性表，栈，队列，循环队列）
weixin_34162228的博客
06-04 161
1. 数据结构数据结构是计算机存储、组织数据的方式。常见的数据结构分类方式如下图：常用的线性结构有：线性表，栈，队列，循环队列。线性表：是在内存中数据的一种组织、存储的方式。线性表顺序存储结构：用数组（连续存放的）来存储的线性表就是顺序表；线性表链式存储结构: 存储在链表上:单链表，双链表，循环链表.栈和队列：...
13. C#数据结构与算法 -- 线性结构
weixin_34119545的博客
06-19 112
本文中，我们讨论了三个部分的内容：什么是线性结构，线性结构有哪些特点 .详细介绍了一个最简单线性结构顺序表，并且通过源代码进行一些的分析.最后还举了一个例子，让我们更好的理解顺序表.第一部分：什么是线性结构，线性结构有哪些特点什么是线性结构，线性结构是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)， 线性结构的特点是结构中的数据元素之间存在一对...
C#数据结构学习：线性结构之顺序表
LIN943168247的博客
12-30 426
什么是线性表 上篇我们提及到了单向链表的具体功能和实现，这次我们来学习一下线性表之顺序表的功能与实现。 通过前面问题的启示： ①同一个问题可以有不同的存储方法。 ②这一类问题都是有序线性序列的组织和管理。 我们就把这类有序线性序列称作为线性表，数据结构最常见的存储方式要么是数组存储，要么是链表存储 总结一下 线性表：由同类型数据元素构成有序序列的线性结构 ①表中元素个数为线性表的长度 ②线性表没有...
C#高级--常用数据结构
李宥的博客
09-02 9030
C#高级–常用数据结构 零、文章目录 一、常见的数据结构 1、集合[Set] 2、线性结构 3、树形结构 4、图形结构 二、Array/ArrayList/List 内存上连续存储，节约空间，可以索引访问，读取快，增删慢 1、Array 元素类型是一样的，定长 int[] list = new int[3]; list[0] = 123; string[] stringArray = new string[] { "123", "234" }; for (int i = 0; i < list.Le
C#常用数据结构和算法总结
09-02
数据结构和算法是编程的基础，尤其在C#这样的高级编程语言中，理解它们的重要性不言而喻。本文将深入探讨这些关键概念。 首先，数据是信息的载体，它可以是数值、图像、音频等各种形式，是计算机能识别、处理和存储...
10个C#常用的算法与数据结构例子
最新发布
01-05
算法是解决问题的一系列步骤。...查找算法：用于在数据结构中查找特定元素的算法，如线性查找、二分查找等。在C#中，可以使用List<T>.Contains()方法或Dictionary, TValue>.ContainsKey()方法来查找元素。
C#数据结构与算法（PPT+源码）
04-13
在IT领域，掌握数据结构与算法是至关重要的，特别是对于使用C#编程语言的开发者来说。数据结构是存储和组织数据的方式，而算法是解决问题或执行任务的特定步骤。本资源包提供了C#语言实现的数据结构与算法的PPT演示...
【数据结构】使用Java实现顺序表类 SeqList
qq_41427568的博客
04-17 6588
目录线性表介绍顺序表介绍Java->顺序表APIJava->顺序表代码 线性表介绍 数据结构中的线性存储结构分为两大类：顺序存储和链式存储，顺序存储对应的是顺序表，链式存储对应的是链表。这篇文章主要介绍如何使用Java实现一个顺序表。 顺序表介绍 顺序表： 把线性表的元素按照一定逻辑顺序依次放在一组地址连续的存储单元里，用这种方式存储的线性表简称为 顺序表。而链表中的元素是没有放在一组...
数据结构C#版笔记--顺序表(SeqList)
weixin_34388207的博客
10-17 101
线性结构(Linear Stucture)是数据结构(Data Structure)中最基本的结构，其特征用图形表示如下： 即：每个元素前面有且只有一个元素(称为“前驱”)，同样后面有且只有一个元素(称为"后继")--注：起始元素的前驱认为是空，末尾元素的后继认为也是空，这样在概念上就不冲突了。 线性表(List)是线性结构的一种典型实现，它又可以分为：顺序表(SeqList)和链表(Li...
顺序表(Seqlist)&链表(List)的基础操作
热门推荐
Xiao__Tian__的博客
06-05 1万+
顺序表和链表是数据结构的基础结构之一，同样也是面试的基础。初学者对于Seqlist和List的增删改查的基础练习，为其后的Tree，HashTable，Binary Linked List，Trigeminal linked list等数据结构打下坚实的基础。
C# IEnumerable to List 的转换
weixin_30273763的博客
12-05 8083
一、使用Linq using System.Linq; Example: IEnumerable<int> enumerable = Enumerable.Range(1, 300); List<int> asList = enumerable.ToList(); 二、使用new List构造函数 扩展方法： public static L...
数据结构2 - 线性表
weixin_34117211的博客
11-06 145
1.顺序表 只考虑线性表的基本操作，所以以C#接口的形式表示线性表，接口中的方法成员表示基本操作。 1.1 公共接口 public interface IListDS&lt;T&gt; { T this[int index] { get; } //索引器 int GetLength(); //求长度 voi...
C# 数据结构- 线性表的几种实现
路漫漫其修远兮
05-31 2366
什么是线性表 线性表是最简单、最基本、最常用的数据结构。线性表是线性结构的抽象(Abstract)，线性结构的特点是结构中的数据元素之间存在一对一的线性关系。这种一对一的关系指的是数据元素之间的位置关系，即： （ 1）除第一个位置的数据元素外，其它数据元素位置的前面都只有一个数据元素； （ 2）除最后一个位置的数据元素外，其它数据元素位置的后面都只有一个元素。也就是说，数据元素是一个接一个的排列。...
泛型——泛型的继承性
蓝亚之舟的博客
05-03 1498
1、泛型的类型参数声明格式如下，用于限定泛型的特性。其中，[ ]表示可选项，多个父类以&amp;分割类型变量 [extends 父类型列表] //其中父类型列表中可以有多个2、虽然Object是String的父类，但是SeqList&lt;Object&gt;却不是SeqList&lt;String&gt;的父类，那么SeqList&lt;String&gt;的父类是谁呢？     ...
Java中怎么把list集合循环出来的值放进数组中
weixin_34205076的博客
04-19 8519
1,将数组的长度定义成集合的长度 List<ElemeterInfo> eleSeqList = elemeterMapper.getEleSeqByterminaluuid(terminaluuid);String[] eleseqArray = new String[eleSeqList.size()]; 　　2，循环集合 int i = 0; ...
使用顺序表类SeqList求解约瑟夫环问题
雪夜&流星的专栏
10-24 2871
约瑟夫环（约瑟夫问题）是一个数学的应用问题：已知n个人（以编号1，2，3...n分别表示）围坐在一张圆桌周围。从编号为k的人开始报数，数到m的那个人出列；他的下一个人又从1开始报数，数到m的那个人又出列；依此规律重复下去，直到圆桌周围的人全部出列。 顺序表类SeqList参考：http://www.cnblogs.com/tanlon/p/4026655.html   约瑟夫环运
C#程序员的数据结构与算法实战指南
"本书详细介绍了数据结构与算法在C#语言中的应用，旨在帮助C#程序员理解和掌握基础数据结构与算法。" 数据结构与算法是计算机科学的基础，对于任何专业程序员来说，尤其是C#开发者，深入理解这些概念至关重要。C#...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值