线性表实现

最新推荐文章于 2024-07-12 19:30:00 发布
最新推荐文章于 2024-07-12 19:30:00 发布
阅读量351 收藏
点赞数
分类专栏： C# 文章标签： exception null insert delete less class
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wind_and_cloud/article/details/6673285
版权 
using System;
using System.Collections.Generic;
using System.Text;

namespace Linear
{
    interface IDsLinear<T>
    {
        void Clear();
        bool IsEmpty();
        void Append(T element);
        void Insert(T element,int position);
        void Delete(int i);
        T GetElement(int i);
        int FindValue(T element);
        int PreElement(T element,ref T preEle);
        int NextElement(T element,ref T nextEle);
    }
}


//顺序表

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

namespace Linear
{
    /// <summary>
    /// 顺序表
    /// </summary>
    /// <typeparam name="T">设置顺序表存储的类型</typeparam>
    public class SeqList<T> : IDsLinear<T>
    {
        private int maxSize;
        private T[] data;
        private int lastPoint;

        /// <summary>
        /// 初始化顺序表
        /// </summary>
        /// <param name="maxSize">指定顺序表中最大的存储空间,当maxSize=0时，默认为100</param>
        public SeqList(int maxSize)
        {
            if (maxSize < 0)
            {
                maxSize = 100;
            }
            this.maxSize = maxSize;
            lastPoint = -1;
            data = new T[maxSize];
        }

        public SeqList() : this(100)
        {
        }

        public T this[int index]
        {
            get
            {
                return data[index];
            }

            set
            {
                data[index] = value;
            }
        }

        /// <summary>
        /// 返回线性表的最大长度
        /// </summary>
        public int MaxLenth
        {
            get
            {
                return maxSize;
            }
        }

        /// <summary>
        /// 判断线性表是否为满
        /// </summary>
        /// <returns></returns>
        public bool IsFull()
        {
            return (lastPoint == (maxSize - 1));
        }

        /// <summary>
        /// 判断线性表是否为空
        /// </summary>
        /// <returns></returns>
        public bool IsEmpty()
        {
            return (lastPoint==-1);
        }

        /// <summary>
        /// 返回线性表的长度
        /// </summary>
        /// <returns></returns>
        public int GetLength()
        {
            if (IsEmpty())
                return 0;
            else
                return (lastPoint + 1);
        }

        /// <summary>
        /// 清除线性表的元素
        /// </summary>
        public void Clear()
        {
            lastPoint = -1;
        }

        /// <summary>
        /// 将指定元素追回到线性表的尾部
        /// </summary>
        /// <param name="element">要追回的元素</param>
        public void Append(T element)
        {
            if(IsFull())
                throw new InvalidOperationException("SeqList is full");
            data[++lastPoint] = element;
        }

        /// <summary>
        /// 在指定下标处插入新元素
        /// </summary>
        /// <param name="element">要插入的元素</param>
        /// <param name="position">要插入的位置</param>
        /// <exception cref="">ArgumentOutOfRangeException</exception>
        /// <exception cref="">InvalidOperationException</exception>
        public void Insert(T element, int position)
        {
            if (position < 0 || position > lastPoint + 2)
                throw new ArgumentOutOfRangeException("position", "the insert position out of rang");

           if(IsFull())
                throw new InvalidOperationException("SeqList is full");

            for (int i = lastPoint; i >= position; i--)
            {
                data[i + 1] = data[i];
            }

            data[position] = element;
            ++lastPoint;
        }

        /// <summary>
        /// 删除指定下标的元素
        /// </summary>
        /// <param name="position">要删除的元素下标</param>
        /// <exception>ArgumentOutOfRangeException</exception>
        public void Delete(int position)
        {
            if (position < 0 || position > lastPoint)
                throw new ArgumentOutOfRangeException("position", "the delete position out of rang");

            for (int i = position; i < lastPoint+1; i++)
            {
                data[i] = data[i + 1];
            }
            --lastPoint;
        }

        /// <summary>
        /// 返回指定下标的元素
        /// </summary>
        /// <param name="position">要返回的元素下标</param>
        /// <returns>返回元素的值</returns>
        /// <exception cref="">ArgumentOutOfRangException</exception>
        public T GetElement(int position)
        {
            if (position < 0 || position > lastPoint)
                throw new ArgumentOutOfRangeException("position", "the get position out of rang");
            return data[position];
        }

        /// <summary>
        /// 返回指定元素的下标
        /// </summary>
        /// <param name="element">要返回其下标的元素</param>
        /// <returns> -1表示没找到</returns>
        public int FindValue(T element)
        {
            if (!IsEmpty())
            {
                for (int i = 0; i <= lastPoint; i++)
                {
                    if (data[i].Equals( element))
                        return i;
                }
            }
            return -1;
        }

        /// <summary>
        /// 返回指定元素的前驱的下标
        /// </summary>
        /// <param name="element">要返回其前驱的下标的元素</param>
        /// <returns>-1表示没找到</returns>
        public int PreElement(T element,ref T preEle)
        {
            if (IsEmpty())
                return -1;

            for (int i = 0; i <= lastPoint; i++)
            {
                if (data[i].Equals(element))
                {
                    preEle = data[i - 1];
                    return (i - 1);
                }
            }
            return -1;
        }

        /// <summary>
        /// 返回指定元素的后继的下标
        /// </summary>
        /// <param name="element">要返回其后继的下标的元素</param>
        /// <returns>-1表示没找到</returns>
        public int NextElement(T element,ref T nextEle)
        {
            if (IsEmpty())
                return -1;

            for (int i = 0; i <= lastPoint; i++)
            {
                if (data[i].Equals( element))
                {
                    nextEle = data[i + 1];
                    return (i + 1);
                }
            }

            return -1;
        }
    }
}


//单链表

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

namespace Linear
{
    /// <summary>
    /// 链表结点类
    /// </summary>
    /// <typeparam name="T">链表结点的类型</typeparam>
    public class LinkNode<T>
    {
        public T data;
        public LinkNode<T> next;
    }

    /// <summary>
    /// 没有头结点的单链表
    /// </summary>
    /// <typeparam name="T">设置单链表存储的类型</typeparam>
    public class LinkList<T> : IDsLinear<T>
    {
        public LinkNode<T> H;             //开始结点
        private LinkNode<T> p;             //尾结点
        private int len;

        /// <summary>
        /// 数据域
        /// </summary>
        public T Data
        {
            get { return H.data; }
            set { H.data = value; }
        }

        /// <summary>
        /// 指针域
        /// </summary>
        public LinkNode<T> Next
        {
            get { return H.next; }
            set { H.next = value; }
        }

        /// <summary>
        /// 链表的长度
        /// </summary>
        public int LENGTH
        {
            get { return len; }
        }

        #region 构造函数

        public LinkList()
        {
            H = null;
            p = null;
            len = 0;
        }

        public LinkList(T data)
        {
            this.H = new LinkNode<T>();
            this.H.data = data;
            ++len;
            p = H;
        }

        #endregion

        #region IDsList<T> 成员

        public void Clear()
        {
            H = null;
            p = null;
            len = 0;
        }

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

        /// <summary>
        /// 在尾部追加结点
        /// </summary>
        /// <param name="element">要追加的元素</param>
        public void Append(T element)
        {
            LinkNode<T> s = new LinkNode<T>();
            s.data = element;
            ++len;

            if (H == null)
            {
                H = s;
                p = H;
                return;
            }

            p.next = s;
            p = s;
        }

        /// <summary>
        /// 插入结点
        /// </summary>
        /// <param name="element">要插入的数据</param>
        /// <param name="position">数据的位置，从1开始</param>
        public void Insert(T element, int position)
        {
            if (H == null)
                throw new Exception("The LinkList is not exist");

            if (position <= 0)
                throw new ArgumentException("The LinkList argument less than zero");

            if (position > len + 1) // position指定在几个元素前插入数据
                throw new ArgumentException("The LinkList argument out of range");

            LinkNode<T> ln = H;

            LinkNode<T> temp = new LinkNode<T>();
            temp.data = element;


            if (position == 1)
            {
                temp.next = H;
                H = temp;
            }
            else
            {
                for (int k = 0; k < position - 2; k++)
                    ln = ln.next;
                LinkNode<T> next = ln.next;
                ln.next = temp;
                temp.next = next;
            }

            if (position == len + 1)
                p = temp;

            ++len;
        }

        /// <summary>
        /// 删除指定位置的数据
        /// </summary>
        /// <param name="i">数据的位置,从1开始</param>
        public void Delete(int i)
        {
            if (H == null)
                throw new Exception("The LinkList is not exist");

            if (i <= 0)
                throw new ArgumentException("The LinkList argument less than zero");

            if (i > len)
                throw new ArgumentException("The position in LinkList out of range");

            LinkNode<T> ln = H;

            if (i == 1)
            {
                ln = ln.next;
                H = ln;
            }
            else
            {
                int j = 0;
                while (j < i - 2)
                {
                    ln = ln.next;
                    j++;
                }

                if (ln.next.next != null)
                    ln.next = ln.next.next;
                else
                    ln.next = null;

                if (i == len)
                    p = ln;
            }
            --len;
        }

        /// <summary>
        /// 取指定位置的数据
        /// </summary>
        /// <param name="i">数据的位置</param>
        /// <returns>返回取到的数据</returns>
        public T GetElement(int i)
        {
            if (H == null)
                throw new Exception("The LinkList is not exist");

            if (IsEmpty())
                throw new Exception("The LinkList is empty");

            if (i < 0)
                throw new ArgumentException("The LinkList argument less than zero");

            if (i > len)
                throw new ArgumentException("The position in LinkList out of range");

            LinkNode<T> ln = H;
            if (i == 0)
                return ln.data;

            for (int k = 0; k < i - 1; k++)
                ln = ln.next;

            return ln.data;
        }

        /// <summary>
        /// 查找指定数据的位置
        /// </summary>
        /// <param name="element">要查找的数据</param>
        /// <returns>返回指定数据的位置，失败返回-1</returns>
        public int FindValue(T element)
        {
            if (H == null)
                throw new Exception("The LinkList is not exist");

            if (IsEmpty())
                throw new Exception("The LinkList is empty");

            LinkNode<T> ln = H;
            int result = -1;

            for (int k = 0; k < len; k++)
            {
                if (ln.data.Equals(element))
                {
                    result = k;
                    break;
                }
                ln = ln.next;
            }

            return result;
        }

        /// <summary>
        /// 查找指定数据的后继
        /// </summary>
        /// <param name="element">要查找的数据</param>
        /// <param name="nextEle">要查找数据的后继</param>
        /// <returns>返回查找数据后缀的索引，不存在则返回-1</returns>
        public int NextElement(T element, ref T nextEle)
        {
            if (H == null)
                throw new Exception("The LinkList is not exist");

            if (IsEmpty())
                throw new Exception("The LinkList is empty");

            LinkNode<T> ln = H;
            int result = -1;
            for (int k = 0; k < len; k++)
            {
                if (ln.data.Equals(element))
                {
                    if (ln.next != null)
                    {
                        nextEle = ln.next.data;
                        result = k + 1;
                    }
                    break;
                }

                if (ln.next != null)
                    ln = ln.next;
            }

            return result;
        }

        /// <summary>
        /// 
        /// </summary>
        /// <param name="element"></param>
        /// <param name="preEle"></param>
        /// <returns></returns>
        public int PreElement(T element, ref T preEle)
        {
            if (H == null)
                throw new Exception("The LinkList is not exist");

            if (IsEmpty())
                throw new Exception("The LinkList is empty");

            LinkNode<T> ln = H;
            int result = -1;
            for (int k = 0; k < len; k++)
            {
                if (k == 0 && ln.data.Equals(element))
                    return result;

                if (ln.next != null)
                {
                    if (ln.next.data.Equals(element))
                    {
                        preEle = ln.data;
                        result = k;
                        break;
                    }

                    ln = ln.next;
                }
            }

            return result;
        }

        #endregion

        public void Display(LinkNode<T> p)
        {
            do
            {
                if (p.next != null)
                    Console.Write(p.data.ToString() + "->");
                else
                    Console.WriteLine(p.data.ToString());
                p = p.next;
            } while (p != null);
        }

        public void ResvLinklist(LinkNode<T> head)
        {
            LinkNode<T> d = H;

            if (d == null || d.next == null)
                return ;

            //前指针      尾指针      当前元素
            LinkNode<T> pre = null, rear = null, temp = null;

            while (d.next != null)
            {
                rear = d.next;
                pre = d;
                pre.next = temp;
                d = rear.next;
                rear.next = pre;

                if (rear != null)
                    temp = rear;
            }

            d.next = temp;
            H = d;
        }
    }
}



wind_and_cloud
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表之栈
sinat_38205774的博客
09-02 92
目录 1.什么是栈 2.栈的存储结构 顺序存储结构（本节所展示的方式） 链式存储结构 3.栈的应用 递归 四则运算表达式 4.入栈操作 5.出栈操作 6.打印栈的内容 7.主函数 1.什么是栈 栈是限定在表尾进行插入和删除操作的线性表 2.栈的存储结构 顺序存储结构（本节所展示的方式） 链式存储结构 3.栈的应用 递...
线性表
chen
06-03 1697
线性表ADT定义如下： ADT 线性表 (List) Data Operation void initList(L); //创建并初始化一个空线性表，如果成功返回true，修改表传指针 bool listEmpty(L); //判断一个线性表是否为空，不修改表传值 void clearList(L); //清空一个线性表，成功返回true bool getElem(L,i,e); /
数据结构线性表实现学生信息管理系统
热门推荐
qq_44024359的博客
10-22 2万+
数据结构线性表实现学生信息管理系统 方法一：顺序表实现 #include <stdio.h> #include <iostream> #include <stdlib.h> #include <string.h> #define MAXSIZE 1000 #define OVERFLOW -1 using namespace std; type...
基于链式存储结构的线性表实现-数据结构（C语言）
kim的博客
04-04 2058
实验名称: 基于链式存储结构的线性表实现 目录 一、实验目的 二、实验环境安装设置 三、实验任务 四、程序框架 五、程序完整代码 六、程序测试 一、实验目的 加深对线性表的概念、基本运算的理解； 熟练掌握线性表的逻辑结构与物理结构的关系； 物理结构采用链式存储结构,熟练掌握链式存储结构各种基本运算的实现。 二、实验环境安装设置 1. 启动DevCPP在E：建立工作区MyCpp，所有的程序源码都存放在该文件夹下。 三、实验任务 认真研读框架程序，根据提供的实验框架（框架
斗地主发牌程序——线性表实现
11-09
用线性表实现斗地主发牌程序，本人水平低劣，可供数据结构初学者参考，如有错误可留言指出
利用线性表实现一个一元多项式
12-07
可以使用链表实现，也可以使用顺序表实现 具体要求如下： 能够实现一元多项式的输入和输出 能够进行一元多项式相加 能够进行一元多项式相减 能够计算一元多项式在x处的值 能够计算一元多项式的导数（选作） ...
用线性表实现一个一元多项式Polynomial
11-22
该源程序是数据结构的代码实现：用线性表实现一个一元多项式Polynomial
线性表实现一个多项式.rar
03-30
在这个特定的实验“线性表实现一个多项式”中，我们关注的是如何利用线性表来存储和操作数学中的多项式。这篇实验报告详细阐述了如何通过线性表来有效地实现多项式的加法、减法和乘法等基本运算。 首先，我们要理解...
[leetcode]subarray-product-less-than-k 乘积小于K的子数组
xiaocong1990的博客
07-10 173
【代码】[leetcode]subarray-product-less-than-k 乘积小于K的子数组。
WIN10开机突然，过一会就自动重启蓝屏DRIVER_IRQL_NOT_LESS_OR_EQUAL
玩人工智能的辣条哥的博客
07-12 268
Win10 专业版DELL7080。
分包合同计量单.docx
07-13
分包合同计量单.docx
树莓派简介PPT课件.ppt
07-13
树莓派简介PPT课件.ppt
项目债务盘点明细表.docx
07-13
项目债务盘点明细表.docx
全网最热Python3入门+进阶 更快上手实际开发
最新发布
07-13
网最热Python3入门+进阶 更快上手实际开发 第1章 Python入门导学.mp4 239.6MB 第9章 高级部分：面向对象 第8章 Python函数 第7章 包、模块、函数与变量作用域 第6章 分支、循环、条件与枚举 第5章 变量与运算符 第4章 Python中表示“组”的概念与定义 第3章 理解什么是写代码与Python的基本类型 第2章 Python环境安装 第1章 Python入门导学 第14章 Pythonic与Python杂记 第13章 实战：原生爬虫 第12章 函数式编程： 匿名函数、高阶函数、装饰器
管理干部培训计划PPT模板
07-13
【作品名称】：管理干部培训计划PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
黑色风格年终总结汇报PPT模板
07-13
【作品名称】：黑色风格年终总结汇报PPT模板 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。
Java实训教程 Java软件开发实战 Java类库 第4章 集合操作 共31页.pptx
07-13
【课程大纲】 完整教程：https://download.csdn.net/download/qq_27595745/89538425 Java软件开发实战 Java类库 第1章 Object类 共29页.pptx Java软件开发实战 Java类库 第2章 字符串处理 共49页.pptx Java软件开发实战 Java类库 第3章 包装器类等 共40页.pptx Java软件开发实战 Java类库 第4章 集合操作 共31页.pptx Java软件开发实战 Java类库 第5章 io操作 共35页.pptx Java软件开发实战 Java类库 第6章 其它综合 共38页.pptx Java软件开发实战 Java类库 第7章 JDBC 共113页.pptx
线性表实现集合的交并
11-23
以下是使用线性表实现集合的交并的Python代码： ```python class Node: def __init__(self, data): self.data = data self.next = None class LinkedList: def __init__(self): self.head = None def ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值