Ｃ＃版的数据结构（对链表的操作）

我们一般只是学过C/C++的数据结构，想必学C#的学生会疑惑，为什么Ｃ＃没有数据结构呢，那我来告诉你，其实Ｃ＃也是有数据结构的，只不过我们不了解罢了，经过我半天的编程，终于把Ｃ＃的数据结构写出来了，也大大增加了我对数据结构的理解，在这里提供出来，共享学习，共同进步！

 

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

namespace 控制台程序
{
    class CSharp数据结构
    {
        public static void Main(string[] args)
        {
            Console.WriteLine("Hello");
            //ListNode list = new ListNode(10);
            Creastlist list = new Creastlist();
            list.Append(1);
            list.Append(2);
            list.Delete();//从队尾删除一个数据
            Console.WriteLine(list.ListCount);
            list.Clear();
            Console.WriteLine(list.ListCount);
            list.Append(1);
            list.Append(2);
            list.Append(4);
            list.Append(3);
            list.MovePrevious();
            list.Append(5);
            list.MovePrevious();
            Console.WriteLine(list.GetCurrentValue());
            //打印输出当前链表中的数据
            list.ShowList(list);
            list.Clear();
            Console.WriteLine("\n"+"清空后的链表节点个数为："+list.ListCount);
            Console.WriteLine("新建一个初始化好的链表：");
            String str = Console.ReadLine();
            Creastlist NewList=new Creastlist(str);
            Console.Write("当前初试换好的链表为：\n");
            NewList.ShowList(NewList);
            Console.Write("\n链表中节点的个数为：");
            Console.WriteLine(NewList.ListCount);
            Console.Read();
        }
    }
    //  结点类
    public class ListNode
    {
        public ListNode(int NewValue)
        {
            Value = NewValue;
        }

        /// <summary>
        /// 前一个节点
        /// </summary>

        public ListNode Previous;

        /// <summary>
        /// 后一个节点
        /// </summary>
 
        public ListNode Next;

        /// <summary>
        /// 值
        /// </summary>
 
        public int Value;
    }
    // 定义结点之后，开始类线性表的操作编程了.在LIST 类中,采用了，Head ,Tail,  Current，三个指针，使用Append ，
    //MoveFrist,MovePrevious，MoveNext,MoveLast ,Delete,InsertAscending,InsertUnAscending ,Clear 实现移动，添加，
    //删除,升序插入，降序插入，清空链表操作，GetCurrentValue（） 方法取得当前的值。
    public class Creastlist
    {
        public Creastlist()
        {
            //构造函数
            //初始化
            ListCountValue = 0;
            Head = null;
            Tail = null;
        }
        /// <summary>
        /// 构造一个初始化好的链表
        /// </summary>
        /// <param name="str">初始化的字符串，并以逗号或者空格隔开</param>
        public Creastlist(string str)
        {
            //构造函数
            //初始化
            char[] separator = { ',',' '};
            string[] s = str.Split(separator);
            Creastlist list = new Creastlist();
            foreach (string i in s)
            {
                int j=Convert.ToInt32(i);
                list.Append(j);
            }
            ListCountValue = s.Length;
            Tail = list.Current;
            Head = list.Head;
        }

        /// <summary>
        /// 头指针
        /// </summary>
        private ListNode Head;

        /// <summary>
        ///  尾指针
        /// </summary>
        private ListNode Tail;

        /// <summary>
        /// 当前指针
        /// </summary>
        private ListNode Current;

        /// <summary>
        /// 链表数据的个数
        /// </summary>
        private int ListCountValue;

        /// <summary>
        /// 尾部添加数据
        /// </summary>
        /// <param name="DataValue">值</param>
        public void Append(int DataValue)
        {
            ListNode NewNode = new ListNode(DataValue);

            if (IsNull())

            //如果头指针为空
            {
                Head = NewNode;
                Tail = NewNode;
            }
            else
            {
                Tail.Next = NewNode;
                NewNode.Previous = Tail;
                Tail = NewNode;
            }
            Current = NewNode;
            //链表数据个数加一
            ListCountValue += 1;
        }
        /// <summary>
        /// 删除当前的数据
        /// </summary>
        public void Delete()
        {
            //若为空链表
            if (!IsNull())
            {
                //若删除头
                if (IsBof())
                {
                    Head = Current.Next;
                    Current = Head;
                    ListCountValue -= 1;
                    return;
                }

                //若删除尾
                if (IsEof())
                {
                    Tail = Current.Previous;
                    Current = Tail;
                    ListCountValue -= 1;
                    return;
                }

                //若删除中间数据
                Current.Previous.Next = Current.Next;
                Current = Current.Previous;
                ListCountValue -= 1;
                return;
            }
        }

        /// <summary>
        /// 向后移动一个数据
        /// </summary>
        public void MoveNext()
        {
            if (!IsEof()) Current = Current.Next;
        }

        /// <summary>
        /// 向前移动一个数据
        /// </summary>
        public void MovePrevious()
        {
            if (!IsBof()) Current = Current.Previous;
        }

        /// <summary>
        /// 移动到第一个数据
        /// </summary>
        public void MoveFrist()
        {
            Current = Head;
        }

        /// <summary>
        ///  移动到最后一个数据
        /// </summary>
        public void MoveLast()
        {
            Current = Tail;
        }

        /// <summary>
        /// 判断是否为空链表
        /// </summary>
        /// <returns>返回bool值</returns>
        public bool IsNull()
        {
            if (ListCountValue == 0)
                return true;

            return false;
        }

        /// <summary>
        /// 判断是否为到达尾
        /// </summary>
        /// <returns></returns>
        public bool IsEof()
        {
            if (Current == Tail)
                return true;
            return false;
        }

        /// <summary>
        /// 判断是否为到达头部
        /// </summary>
        /// <returns></returns>
        public bool IsBof()
        {
            if (Current == Head)
                return true;

            return false;
        }
       
        /// <summary>
        /// 获取当前数据
        /// </summary>
        /// <returns>返回当前节点的值</returns>
        public int GetCurrentValue()
        {
            return Current.Value;
        }

        /// <summary>
        ///  取得链表的数据个数
        /// </summary>
        public int ListCount
        {
            get
            {
                return ListCountValue;
            }
        }

        /// <summary>
        /// 清空链表
        /// </summary>
        public void Clear()
        {
            MoveFrist();
            while (!IsNull())
            {
                //若不为空链表,从尾部删除 
                Delete();
            }
        }

        /// <summary>
        ///  在当前位置前插入数据
        /// </summary>
        /// <param name="DataValue">要插入的数据</param>
        public void Insert(int DataValue)
        {
            ListNode NewNode = new ListNode(DataValue);
            if (IsNull())
            {
                //为空表，则添加
                Append(DataValue);
                return;
            }

            if (IsBof())
            {
                //为头部插入
                NewNode.Next = Head;
                Head.Previous = NewNode;
                Head = NewNode;
                Current = Head;
                ListCountValue += 1;
                return;
            }
            //中间插入
            NewNode.Next = Current;
            NewNode.Previous = Current.Previous;
            Current.Previous.Next = NewNode;
            Current.Previous = NewNode;
            Current = NewNode;
            ListCountValue += 1;
        }

        /// <summary>
        /// 进行升序插入
        /// </summary>
        /// <param name="InsertValue"></param>
 
        public void InsertAscending(int InsertValue)
        {
            //参数：InsertValue 插入的数据
            //为空链表
            if (IsNull())
            {
                //添加
                Append(InsertValue);
                return;
            }

            //移动到头
            MoveFrist();
            if ((InsertValue < GetCurrentValue()))
            {
                //满足条件，则插入，退出
                Insert(InsertValue);
                return;
            }
            while (true)
            {
                if (InsertValue < GetCurrentValue())
                {
                    //满族条件，则插入，退出
                    Insert(InsertValue);
                    break;
                }
                if (IsEof())
                {
                    //尾部添加
                    Append(InsertValue);
                    break;
                }
                //移动到下一个指针
                MoveNext();
            }
        }

        //进行降序插入
        public void InsertUnAscending(int InsertValue)
        {
            //参数：InsertValue 插入的数据                     
            //为空链表
            if (IsNull())
            {
                //添加
                Append(InsertValue);
                return;
            }
            //移动到头
            MoveFrist();
            if (InsertValue > GetCurrentValue())
            {
                //满足条件，则插入，退出
                Insert(InsertValue);
                return;
            }
            while (true)
            {
                if (InsertValue > GetCurrentValue())
                {
                    //满族条件，则插入，退出
                    Insert(InsertValue);
                    break;
                }
                if (IsEof())
                {
                    //尾部添加
                    Append(InsertValue);
                    break;
                }
                //移动到下一个指针
                MoveNext();
            }
        }

        /// <summary>
        /// 打印链表中全部的数
        /// </summary>
        /// <param name="list">链表参数</param>
        public void ShowList(Creastlist list)
        {
            Console.WriteLine("当前链表中数据为：");
            list.MoveFrist();
            for (int i = 0; i < list.ListCount;i++ )
            {
                Console.Write(list.GetCurrentValue() + "  ");
                list.MoveNext();
            }
        }

    }

}

如有不当之处，请指正！ＱＱ：1213250243

时间： 2024-09-22 16:01:33

Ｃ＃版的数据结构（对链表的操作）的相关文章

c++ 数据结构-实现以下对单链表的操作，要求单链表一次遍历效率(数据结构c＋＋)

问题描述 实现以下对单链表的操作,要求单链表一次遍历效率(数据结构c++) double averageExceptMaxMin(SinglyList &list) ?//去掉最高分和最低分,再求平均值 解决方案 double averageExceptMaxMin(SinglyList &list){ double d = 0.0; int n = 0; double max = 0.0; double min = 0.0; Node * node = &list.head; w

C语言顺序表基本操作，刚学数据结构还不懂怎么操作？求助！！

问题描述 C语言顺序表基本操作,刚学数据结构还不懂怎么操作?求助!! 1.建立一个顺序表,要求从键盘输入10个整数,并将该顺序表的元素从屏幕显示出来. 2.用函数实现在顺序表中查找其中一个元素,如果找到,返回该元素在顺序表中的位置和该元素的值,否则提示无此元素. 3.用函数实现顺序表的插入和删除操作.由用户输入待插入元素及插入位置,将完成插入后的顺序表输出:由用户输入删除第几个元素,将完成删除后的顺序表输出. 解决方案 http://zhidao.baidu.com/link?url=n-XCi

大家觉得严蔚敏吴伟民版的数据结构C语言版怎么样？

问题描述 大家觉得严蔚敏吴伟民版的数据结构C语言版怎么样? 话说楼主以前学过数据结构C++版的,这次由于考研,需要看C语言版的,网上大家一致推荐严蔚敏吴伟民的书.于是我就买了,但是忍着愤怒我看了四五天了,真的想暴走!实在对这本书不敢恭维,首先,里面变量不定义;其次,函数参数传递用的是C++中的引用(既然书名叫C语言版,为什么要挂羊头卖狗肉呢?);第三,在第42页的用链表表示一元多项式以及运算中,函数实参用的是函数指针,但是实参都是错误的;第四,这本书算法示例和书中的内容怎么看怎么不舒服,感觉排版

linux内核数据结构之链表

1.前言 最近写代码需用到链表结构,正好公共库有关于链表的.第一眼看时,觉得有点新鲜,和我之前见到的链表结构不一样,只有前驱和后继指针,而没有数据域.后来看代码注释发现该代码来自linux内核,在linux源代码下include/Lish.h下.这个链表具备通用性,使用非常方便.只需要在结构定义一个链表结构就可以使用. 2.链表介绍 链表是非常基本的数据结构,根据链个数分为单链表.双链表,根据是否循环分为单向链表和循环链表.通常定义定义链表结构如下: typedef struct node {

浅谈PHP链表数据结构(单链表)_php实例

链表:是一个有序的列表,但是它在内存中是分散存储的,使用链表可以解决类似约瑟夫问题,排序问题,搜索问题,广义表 单向链表,双向链表,环形链表 PHP的底层是C,当一个程序运行时,内存分成五个区(堆区,栈区,全局区,常量区,代码区) 规定:基本数据类型,一般放在栈区 复合数据类型,比如对象,放在堆区 定义一个类Hero 定义成员属性排名 $no 定义成员属性姓名 $name 定义成员属性昵称 $nickname 定义成员属性 $next,是一个引用,指向下一个Hero对象 定义构造函数,传递参数:

C语言单链表常见操作汇总_C 语言

C语言的单链表是常用的数据结构之一,本文总结了单链表的常见操作,实例如下: #include<stdio.h> #include<stdlib.h> //定义单链表结构体 typedef int ElemType; typedef struct Node { ElemType data; struct Node *next; }LNode,*LinkList; //创建单链表 void Build(LinkList L) { int n; LinkList p,q; p=L; pr

java类的问题-java数据结构，线性表操作，C(X)=A(X)+B(X)多项式想加

问题描述 java数据结构,线性表操作,C(X)=A(X)+B(X)多项式想加 C(X)=A(X)+B(X)多项式想加.PolySLinkedList类增加C(X)=A(X)+B(X)多项式想加功能,算法实现不依赖于深拷贝,将A和B两条多项式单链表中的所以结点相加合并到新建的C多项式单链表,不改变A和B多项式单链表

linux内核数据结构之链表【转】

转自:http://www.cnblogs.com/Anker/archive/2013/12/15/3475643.html 1.前言 最近写代码需用到链表结构,正好公共库有关于链表的.第一眼看时,觉得有点新鲜,和我之前见到的链表结构不一样,只有前驱和后继指针,而没有数据域.后来看代码注释发现该代码来自linux内核,在linux源代码下include/Lish.h下.这个链表具备通用性,使用非常方便.只需要在结构定义一个链表结构就可以使用. 2.链表介绍 链表是非常基本的数据结构,根据链个数

顺序存储线性表-数据结构顺序表的操作（c++）

问题描述 数据结构顺序表的操作(c++) 求解答谢谢 解决方案 贴出代码而不是截图.发了帖子你难道自己不看下.这么小的字根本看不清. 解决方案二: 什么是线性表?定义:由n(n>=0)个数据类型相同的数据元素组成的有限序列.特点是:在数据元素的非空有限集合中,除第一个元素无直接前驱,最后一个元素无直接后继外,集合中其余每个元素均有唯一的直接前驱和直接后继.什么是顺序表,在这里回答一下.顺序表就是线性表的顺序存储,其特点是:物理顺序与逻辑顺序是相同的,关系线性化,结点顺序存.线性表顺序存储的表示?

数据结构 单链表-求大神给我讲讲数据结构单链表和队列

问题描述 求大神给我讲讲数据结构单链表和队列 帮我彻底分析下两种结构,感激不尽多谢大神了 解决方案 单链表和队列是两个层次的事情. 单链表是一种基本的表示一个线性表的方式,它记录下当前节点的数据和指向下一个节点的指针.因此一环一环可以得到整个数据.除了单链表,我们还有数组.双向链表.循环链表等. 队列是一种先进先出的数据结构,它高于链表一个层次,这是说,你可以用链表实现队列(当然也可以用数组或者别的).另外还有先进后出的数据结构(堆栈)等. 解决方案二: 具体你可以google下wikipedi