01.线性表 ArrayList

  1   public class MyArrayList
  2     {
  3         //容量
  4         private const int _defaultCapacity = 4;
  5         //存放数组元素
  6         private object[] _items;
  7         //数组大小
  8         private int _size;
  9         //元素个数为0的数组状态
 10         private static readonly object[] emptyArray = new object[0];
 11
 12         public MyArrayList()
 13         {
 14             this._items = emptyArray;
 15         }
 16
 17         public MyArrayList( int capacity)
 18         {
 19             if (capacity<0)
 20             {
 21                 throw new ArgumentOutOfRangeException("capacity","ArrayList的容量不可为负数!");
 22             }
 23             this._items = new object[capacity];
 24         }
 25
 26         //索引器
 27         public virtual object this[int index]
 28         {
 29             get
 30             {
 31                 if (index<0||index>=this._size)
 32                 {
 33                     throw new ArgumentOutOfRangeException("index","索引超出范围!");
 34                 }
 35                 return this._items[index];
 36             }
 37
 38             set
 39             {
 40                 if (index < 0 || index >= this._size)
 41                 {
 42                     throw new ArgumentOutOfRangeException("index", "索引超出范围!");
 43                 }
 44                 this._items[index] = value;
 45             }
 46
 47         }
 48
 49         //当前数组元素个数
 50         public virtual int Count
 51         {
 52             get {return this._size ;}
 53         }
 54
 55         //数组的容量
 56         public virtual int Capacity
 57         {
 58             get { return this._items.Length; }
 59             set
 60             {
 61                 if (value!=this._items.Length)
 62                 {
 63                     if (value<this._size)
 64                     {
 65                         throw new ArgumentOutOfRangeException("value","容量太小");
 66                     }
 67                     if (value > 0)
 68                     {//开辟新内存空间存储元素
 69                         object[] dest = new object[value];
 70                         if (this._size > 0)
 71                         {//搬动元素
 72                             Array.Copy(this._items, 0, dest, 0, this._size);
 73                         }
 74                         this._items = dest;
 75                     }
 76                     else//数组最小的空间为4
 77                     {
 78                         this._items=new object[_defaultCapacity];
 79                     }
 80                 }
 81             }
 82         }
 83
 84         //元素的添加
 85         public virtual int Add(object value)
 86         {//当空间已满
 87             if (this._size==this._items.Length)
 88             {
 89                 this.EnsureCapacity(this._size+1);
 90             }
 91             this._items[this._size] = value;
 92             return this._size++;
 93         }
 94
 95         //扩容
 96         private void EnsureCapacity(int p)
 97         {
 98             if (this._items.Length<p)
 99             {//空间加倍
100                 int num = (this._items.Length == 0) ? _defaultCapacity : (this._items.Length * 2);
101                 if (num < p)
102                 {
103                     num = p;
104                 }
105                 this.Capacity = num;
106             }
107         }
108
109         //指定位置插入元素
110         public virtual void Insert( int index,object value)
111         {
112             if (index<0||index>this._size)
113             {
114                 throw new ArgumentOutOfRangeException("index","索引超出范围!");
115             }
116             if (this._size==this._items.Length)
117             {
118                 this.EnsureCapacity(this._size + 1);
119             }
120             if (index<this._size)
121             {
122                 Array.Copy(this._items, index, this._items, index + 1, this._size - index);
123             }
124             this._items[index] = value;
125             this._size++;
126         }
127
128         //移除指定索引的元素
129         public virtual void Remove(int index)
130         {
131             if (index < 0 || index > this._size)
132             {
133                 throw new ArgumentOutOfRangeException("index", "索引超出范围!");
134             }
135             this._size--;
136             if (index<this._size)
137             {
138                 Array.Copy(this._items,index+1,this._items,index,this._size-index);
139             }
140             this._items[this._size]=null;
141         }
142
143         //裁剪空间
144         public virtual void TrimToSize()
145         {
146             this.Capacity = this._size;
147         }
148     }

时间: 2024-10-10 03:28:29

01.线性表 ArrayList的相关文章

01 线性表

一.线性表之顺序存储---顺序表 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 // 数据结构 6 #define MAX 100 7 typedef struct 8 { 9 int buf[MAX]; 10 int length; 11 }seqList; 12 13 // 创建一个顺序表,并初始化 14 seqList *seqList_init(void) 15 { 16

01线性表顺序存储_List

#include "stdio.h" #include "stdlib.h" #include "io.h" #include "math.h" #include "time.h" #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define MAXSIZE 20 /* 存储空间初始分配量 */ typedef int Status;

[大话数据机构 01]线性表

1.线性表 先看定义: 线性表:零个或多个数据元素的有限序列 从定义可以看出,关键在于有限序列一词. 有限,表示元素的个数不是无穷无尽的,是有穷的,和算法的特性就吻合了. 序列,表示元素之间是有序的,那么,除了首尾两元素,其他元素都可以且只能找到一个前驱和一个后继,第一个元素无前驱,最后一个无后继 来自为知笔记(Wiz)

数据结构与算法之----线性表

01线性表 1.线性表的判断方式就是元素有且只有一个直接前驱和直接后继,元素可以为空,此时叫做空表 2.抽象数据类型标准格式 ADT 抽象数据类型名 DATA 数据元素之间逻辑关系的定义 Operation 操作 endADT 3.操作伪代码 Operation InitList(*L): 初始化操作,建立一个空的线性表L ListEmpty(L): 判断线性表是否为空表,如果为空返回true,否则返回false ClearList(*L): 将线性表清空(实际情况不是删除元素,而是将内存中的元

Java学习笔记(2)----散列集/线性表/队列/集合/图(Set,List,Queue,Collection,Map)

1. Java集合框架中的所有实例类都实现了Cloneable和Seriablizable接口.所以,它们的实例都是可复制和可序列化的. 2. 规则集存储的是不重复的元素.若要在集合中存储重复的元素,就需要使用线性表.线性表不仅可以存储重复的元素,而且允许用户指定存储的位置.用户可以通过下标来访问线性表中的元素. 3. Java集合支持三种类型的规则集:散列集HashSet.链式散列集LinkedHashSet和树形集TreeSet.HashSet以一个不可预知的顺序存储元素:LinkedHas

数据结构笔记01:线性表之顺序存储结构(ArrayList)

一般使用数组(C语言中的数组采用顺序存储方式.即连续地址存储)来描述. 优点:在于随机访问元素. 缺点:插入和和删除的时候,需要移动大量的元素. c语言实现代码:ArrayList 1 // Test.cpp : Defines the entry point for the console application. 2 // 3 4 #include "stdafx.h" 5 #include <stdio.h> 6 #include "stdlib.h&quo

集合线性表--List之ArrayList

集合操作——线性表 List: add().remove().subList().list.toArray().array.asList(). List排序:  Collections.sort(list);    Comparable. comparator ListList接口是Collection的子接口,用于定义线性表数据结构:可以将List理解为存放对象的数组,只不过其元素个数可以动态的增加或减少.并且List是可重复集 ArrayList和LinkedList List接口的两个常见

线性表之何时使用ArrayList、LinkedList?

前言 线性表不仅可以存储重复的元素,而且可以指定元素存储的位置并根据下表访问元素. List接口的两个具体实现:数组线性表类ArrayList.链表类LinkedList. ArrayList ArrayList使用数组存储元素,这个数组是动态创建的.如果元素个数超过了数组的容量,就会创建一个更大的数组,并将当前数组中的所有元素都复制到新数组中.另外需要注意的是,ArrayList容量可能根据元素的增加而自动增大,但是不能自动减少.可以使用trimToSize()将数组容量减少到线性表大小. L

Java数据结构-线性表之顺序表ArrayList

线性表的顺序存储结构,也称为顺序表,指用一段连续的存储单元依次存储线性表中的数据元素. 根据顺序表的特性,我们用数组来实现顺序表,下面是我通过数组实现的Java版本的顺序表. package com.phn.datestructure; /** * @author 潘海南 * @Email [email protected] * @TODO 顺序表 * @date 2015年7月16日 */ public class FOArrayList<E> { // 顺序表长度 private int