迎接2012之集合和泛型(1)------线性表的顺序结构基本实现

最新推荐文章于 2024-07-20 16:50:31 发布
最新推荐文章于 2024-07-20 16:50:31 发布
阅读量263 收藏
点赞数
分类专栏： 迎接2012 文章标签： object class string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/huihuidetiantang/article/details/6942494
版权

一、非泛型实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using System.Reflection;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList ary = new ArrayList(10);
            ary.Add(3);
            ary.Add(5);
            ary.Add(4, 1);
            for (int i = 0; i < ary.count; i++)
            {
                Console.WriteLine(ary[i]);
            }
            ary.Remove(4);
            for (int i = 0; i < ary.count; i++)
            {
                Console.WriteLine(ary[i]);
            }
            ary.RemoveAt(1);
            for (int i = 0; i < ary.count; i++)
            {
                Console.WriteLine(ary[i]);
            }
        }
    }
    /// <summary>
    /// 线性表的顺序结构基本实现(非泛型)
    /// </summary>
    public class ArrayList
    {
        /// <summary>
        /// 存放元素的数组
        /// </summary>
        public object[] array;
        /// <summary>
        /// 存放实际的元素个数
        /// </summary>
        public int count;
        /// <summary>
        /// 存放线性表的容量
        /// </summary>
        public int capcity;
        /// <summary>
        /// 默认的构造函数
        /// </summary>
        public ArrayList()
        {
            this.array = new object[0];
            this.capcity = 0;
            this.count = 0;
        }
        /// <summary>
        /// 构造函数重载
        /// </summary>
        /// <param name="capcity"></param>
        public ArrayList(int capcity)
        {
            this.array = new object[capcity];
            this.capcity = capcity;
            this.count = 0;
        }
        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        private bool Empty()
        {
            return this.count == 0; //元素个数是否等于0
        }
        /// <summary>
        /// 判断是否为满
        /// </summary>
        /// <returns></returns>
        private bool Fill()
        {
            return this.count == this.capcity;//元素个数是否等于线性表的容器
        }
        /// <summary>
        /// 索引
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public object this[int index]
        {
            get
            {
                if (index < 0 || index > this.count)
                {
                    return "";
                }
                else
                {
                    return this.array[index];
                }
            }
            set
            {
                if (index < 0 || index > this.count)
                {
                    this.array[index] = "";
                }
                else
                {
                    this.array[index] = value;
                }
            }
        }
        /// <summary>
        /// 扩大容器
        /// </summary>
        private void Dilatation()
        {
            //将数组个数扩大为原来的两倍
            object[] newarray = new object[this.capcity * 2];
            for (int i = 0; i < this.array.Length; i++)
            {
                newarray[i] = this.array[i];
            }
            this.array = newarray;
        }
        /// <summary>
        /// 增加元素
        /// </summary>
        /// <param name="obj"></param>
        public void Add(object obj)
        {
            //判断是否为满，满的话扩容，最后就是添加元素
            if (Fill())
            {
                Dilatation();
            }
            this.array[count] = obj;
            this.count++;
        }
        /// <summary>
        /// 增加元素到指定的位置
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="index"></param>
        public void Add(object obj, int index)
        {
            if (Fill())
            {
                Dilatation();
            }
            if (index < 0 || index > this.count)
            {
                Console.WriteLine("插入位置不正确");
                return;
            }
            //位置后移
            for (int i = index; i < this.count; i++)
            {
                this.array[i + 1] = this.array[i];
            }
            this.array[index] = obj;
            this.count++;
        }
        /// <summary>
        /// 查找元素是否存在
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool Contains(object obj)
        {
            bool b = false;
            for (int i = 0; i < this.count; i++)
            {
                if (this.array[i].Equals(obj))
                {
                    b = true;
                    break;
                }
            }
            return b;
        }
        /// <summary>
        /// 查找元素的位置，如果不存在返回-1
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int IndexOf(object obj)
        {
            int i = -1;
            for (int j = 0; j < this.count; j++)
            {
                if (this.array[j].Equals(obj))
                {
                    i = j;
                    break;
                }
            }
            return i;
        }
        /// <summary>
        /// 删除元素
        /// </summary>
        /// <param name="obj"></param>
        public void Remove(object obj)
        {
            int index = IndexOf(obj);
            if (index != -1)
            {
                //位置前移
                for (int i = index; i < this.count - 1; i++)
                {
                    this.array[i] = this.array[i + 1];
                }
                this.count--;
            }
            else
            {
                Console.WriteLine("该元素不存在");
            }
        }
        /// <summary>
        ///  删除指定位置的元素
        /// </summary>
        /// <param name="index"></param>
        public void RemoveAt(int index)
        {
            if (this.Empty())
            {
                Console.WriteLine("元素为空");
            }
            if (index < 0 || index > this.count)
            {
                Console.WriteLine("删除位置不正确");
                return;
            }
            //位置前移
            for (int i = index; i < this.count - 1; i++)
            {
                this.array[i] = this.array[i + 1];
            }
            this.count--;
        }
    }

}

二、泛型实现

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Data;
using System.Data.SqlClient;
using System.Text.RegularExpressions;
using System.Reflection;

namespace ConsoleApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            ArrayList<int> ary = new ArrayList<int>(10);
            ary.Add(3);
            ary.Add(5);
            ary.Add(4, 1);
            for (int i = 0; i < ary.count; i++)
            {
                Console.WriteLine(ary[i]);
            }
            ary.Remove(4);
            for (int i = 0; i < ary.count; i++)
            {
                Console.WriteLine(ary[i]);
            }
            ary.RemoveAt(1);
            for (int i = 0; i < ary.count; i++)
            {
                Console.WriteLine(ary[i]);
            }
        }
    }
    /// <summary>
    /// 线性表的顺序结构基本实现(泛型)
    /// </summary>
    public class ArrayList<T>
    {
        /// <summary>
        /// 存放元素的数组
        /// </summary>
        public T[] array;
        /// <summary>
        /// 存放实际的元素个数
        /// </summary>
        public int count;
        /// <summary>
        /// 存放线性表的容量
        /// </summary>
        public int capcity;
        /// <summary>
        /// 默认的构造函数
        /// </summary>
        public ArrayList()
        {
            this.array = new T[0];
            this.capcity = 0;
            this.count = 0;
        }
        /// <summary>
        /// 构造函数重载
        /// </summary>
        /// <param name="capcity"></param>
        public ArrayList(int capcity)
        {
            this.array = new T[capcity];
            this.capcity = capcity;
            this.count = 0;
        }
        /// <summary>
        /// 判断是否为空
        /// </summary>
        /// <returns></returns>
        private bool Empty()
        {
            return this.count == 0; //元素个数是否等于0
        }
        /// <summary>
        /// 判断是否为满
        /// </summary>
        /// <returns></returns>
        private bool Fill()
        {
            return this.count == this.capcity;//元素个数是否等于线性表的容器
        }
        /// <summary>
        /// 索引
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public T this[int index]
        {
            get
            {
                if (index < 0 || index > this.count)
                {
                    new System.ArgumentOutOfRangeException();
                }
                return this.array[index];

            }
            set
            {
                if (index < 0 || index > this.count)
                {
                    new System.ArgumentOutOfRangeException();
                }
                this.array[index] = (T)value;

            }
        }
        /// <summary>
        /// 扩大容器
        /// </summary>
        private void Dilatation()
        {
            //将数组个数扩大为原来的两倍
            T[] newarray = new T[this.capcity * 2];
            for (int i = 0; i < this.array.Length; i++)
            {
                newarray[i] = this.array[i];
            }
            this.array = newarray;
        }
        /// <summary>
        /// 增加元素
        /// </summary>
        /// <param name="obj"></param>
        public void Add(T obj)
        {
            //判断是否为满，满的话扩容，最后就是添加元素
            if (Fill())
            {
                Dilatation();
            }
            this.array[count] = obj;
            this.count++;
        }
        /// <summary>
        /// 增加元素到指定的位置
        /// </summary>
        /// <param name="obj"></param>
        /// <param name="index"></param>
        public void Add(T obj, int index)
        {
            if (Fill())
            {
                Dilatation();
            }
            if (index < 0 || index > this.count)
            {
                Console.WriteLine("插入位置不正确");
                return;
            }
            //位置后移
            for (int i = index; i < this.count; i++)
            {
                this.array[i + 1] = this.array[i];
            }
            this.array[index] = obj;
            this.count++;
        }
        /// <summary>
        /// 查找元素是否存在
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public bool Contains(T obj)
        {
            bool b = false;
            for (int i = 0; i < this.count; i++)
            {
                if (this.array[i].Equals(obj))
                {
                    b = true;
                    break;
                }
            }
            return b;
        }
        /// <summary>
        /// 查找元素的位置，如果不存在返回-1
        /// </summary>
        /// <param name="obj"></param>
        /// <returns></returns>
        public int IndexOf(T obj)
        {
            int i = -1;
            for (int j = 0; j < this.count; j++)
            {
                if (this.array[j].Equals(obj))
                {
                    i = j;
                    break;
                }
            }
            return i;
        }
        /// <summary>
        /// 删除元素
        /// </summary>
        /// <param name="obj"></param>
        public void Remove(T obj)
        {
            int index = IndexOf(obj);
            if (index != -1)
            {
                //位置前移
                for (int i = index; i < this.count - 1; i++)
                {
                    this.array[i] = this.array[i + 1];
                }
                this.count--;
            }
            else
            {
                Console.WriteLine("该元素不存在");
            }
        }
        /// <summary>
        ///  删除指定位置的元素
        /// </summary>
        /// <param name="index"></param>
        public void RemoveAt(int index)
        {
            if (this.Empty())
            {
                Console.WriteLine("元素为空");
            }
            if (index < 0 || index > this.count)
            {
                Console.WriteLine("删除位置不正确");
                return;
            }
            //位置前移
            for (int i = index; i < this.count - 1; i++)
            {
                this.array[i] = this.array[i + 1];
            }
            this.count--;
        }
    }

}
huihuidetiantang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java数据结构自定义顺序表
weixin_34352492的博客
08-31 327
自定义顺序表 目录自定义顺序表一、包含功能二、具体实现过程0.0 自定义顺序表0.1 扩容0.2 重写toString1.插入元素1.1 尾插1.2 指定位置插入2.插入元素2.1 按照指定元素删除2.2 按照目标元素删除3.根据下标获取元素4.根据下标修改元素5.判断元素是否存在6.查找元素位置6.1 从前往后6.2 从后往前7.清空元素8.求长度9.判断是否为空10.测试函数10.1 测试增加函数10.2 测试删除函数10.3 测试获取/修改函数10.4 测试存在/元素位置函数10.5 测试清空/长度/
实验2内容要求-线性表的设计与实现1
08-04
实验2的主要目标是深入理解和实践线性表这一重要的数据结构，同时强化对Visual Studio项目管理和C#编程技能的运用。在这个过程中，学生将通过创建和管理项目，实现不同类型的线性表，以及进行性能比较，来巩固理论...
链表、顺序表泛型和非泛型实现
ormosia2的博客
11-19 114
顺序表和链表实现及泛型实现 就当复习，再写一遍，有空把队列和栈也改改 1、顺序表(数组) public class MyArrayList { public int[] elem; public int usedsize; public MyArrayList() { this.elem = new int[10]; this.usedsize = 0; } public MyArrayList(int cap) { t
数据结构--线性表，顺序表和ArrayList（1）
weixin_71085457的博客
06-24 920
此贴仅为个人学习笔记
数据结构--线性表之顺序表实现
吴声子夜歌的博客
01-13 657
概述 线性表是最基本、最简单、也是最常用的一种数据结构。线性表（linear list）是数据结构的一种，一个线性表是n个具有相同特性的数据元素的有限序列。 基本概念 对于同一个线性表，其每一个数据元素的值虽然不同，但必须具有相同的数据类型； 数据元素之间具有一种线性的或“一对一”的逻辑关系。 第一个数据元素没有前驱，这个数据元素被称为开始节点； 最后一个数据元素没有后继，这个数据元素被称为终...
数据结构(Java)--List&Arraylist（顺序表）
最新发布
2302_81017910的博客
07-20 867
List接口是Java集合框架中的一种接口，它代表了一个有序的、可重复的元素序列。List接口继承自Collection接口，定义了一些用于操作列表的方法。常见的List实现类有ArrayList和LinkedList。ArrayList是基于动态数组实现的，它支持快速随机访问和随机插入/删除操作，但插入/删除操作涉及数组元素的移动，性能相对较低。LinkedList则是基于双向链表实现的，它支持快速插入/删除操作，但访问元素需要从头部或尾部开始遍历链表，性能相对较低。
数据结构基础：线性表-顺序表（Java实现）
wu1111y的博客
11-09 132
顺序表（Java实现）
JavaSE精选-集合
wishcoding的博客
01-26 384
集合类的特点a. 只能存储引用数据类型：因为泛型只能传入引用的数据类型b. 可以自动地调整自己的大小数组和集合类都是容器，它们有何不同？a. 数组可以存储基本数据类型的数据，集合不可以。b. 数组的长度是固定的，集合可以自动调整自己的大小。c. 数组的效率高，相对来说集合效率比较低。d. 数组没有API，集合有丰富的API。1, 是谁的子类, 描述了什么数据结构2, 底层结构: 数组, 链表, 数组+链表, 数组(默认的初始容量, 扩容机制)
基本数据结构与算法JavaAPI【1】--线性表篇
lixxkv的博客
08-20 316
基本数据结构与算法【1】--线性表篇
【数据结构篇】线性表1 --- 顺序表、链表 （万字详解！！）
iiiiiihuang的博客
09-03 2512
前言：这篇博客我们重点讲线性表中的顺序表、链表 线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列... 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。
数据结构线性表部分C++实现-包括一些习题代码
03-10
在计算机科学中，线性表的实现通常分为两种：顺序表和链表。本压缩包中的资源主要关注C++实现的线性表，特别是与习题相关的代码实践。 1. **顺序表**： 顺序表是一种物理存储单元上连续存储的数据结构，其特点是...
数据结构实验指导书(C++)- 线性表的操作.docx
11-12
1. 顺序表的操作：学生需要设计一个静态数组存储结构的顺序表类，完成建立、删除和显示数据元素等基本操作。在最坏情况下，线性表的数据元素不超过50个。 2. 带头结点的单链表：要求设计链表类，实现将整数线性表...
线性表的顺序存储C++实现（类模板实现）
04-05
大致实现了STL中的线性表基本功能，通过对比C语言实现线性表的顺序存储可以更好的理解面向对象编程和面向过程的区别，更加深入的理解C语言和C++语言的区别。相关的文章可以在我的主页算法与数据结构专栏查看。
DSAinC++2-C++编程基础1
08-04
在学习C++编程基础时，应依次掌握基本语法、数据类型、流程控制、输入输出流、面向对象编程概念、模板和泛型编程、函数对象和Lambda表达式。然后，逐步深入到更复杂的数据结构，如线性表、栈、队列、数组、广义表、...
迎接2012之三层架构基于JQuery Ui实现增删改查完整设计
等待
11-18 5636
一、存储过程，数据库基于前几篇博文。 二、代码 (1)HTMLPage.htm 用户列表 $(document).ready(function () { $("#Btn_Add").click(function () { $("#hidediv")
迎接2012之Ajax三层联动
等待
11-21 5116
一、采用三层结构来写（可以参考前几篇博文） 二、代码 (1)数据处理层 1、AreaDataAccess.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Configuration; using System.Data;
迎接2012之基于JQuery Ui Dialog实现Ajax提交表单
等待
11-12 4481
一、代码 (1)Default.aspx页面 用户列表 $(document).ready(function () { $("#Btn_Add").click(function () { $("#hidediv").dialog({
迎接2012之三层架构简单设计
等待
11-11 594
一、数据访问层的抽象公共类 using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Data.Common; using System.Data; namespace ThreeLevelDAL { /// ///
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值