关于JAVA数据结构_线性表(通过数组实现)的学习
1.数据结构:
相互之间存在一种或多种特定关系的数据元素集合
数据元素之间的关系
1.1数据逻辑结构有四种:
集合:数据仅仅属于同一个 集合,没有其他相互关系
线性:描述一对多的关系
属性:描述一对多的关系
图形:描述一个多对多的关系
数据的逻辑结构一般采用二元组的形式定义:
数据结构=(D,S)
D:数据元素的集合
S: D元素之间的关系的集合
数据的物理结构:逻辑结构在计算机中的存储位置
顺序存储:
链式存储:
1.2 抽象数据类型 ADT
使用三元组表示:ADT=(D,S,P)
D是数据对象 S是D上的关系,P是D上的操
可以对应一个java类,数据对象与数据关系可以通过类的成员变量;哎存储表示,数据操作可以使用方法来实现
算法有五个特性
输入:一个或多个输入
输出:至少一个输出
有穷性:算法中指令的个数是有限的,
确定性:特定的合法的输入,输出唯一
可行性:算法能够实现,并且在有限的时间内完成
算法设计要求:
正确性:没有语法错误
可读性:算法另一个目的是为了交流,方便阅读
健壮性:对于不合理的要求,也能给出合理的提示信息
时间效率高与存储空间小
1.3时间复杂度
渐近时间复杂度,简称时间复杂度,
T(n)=O(f(n)),表示时间规模n的变化情况,确定T(n)的数量级
1.4 空间复杂度
为了求解某一问题,在执行操作期间所需要的存储空间大小,不包含用来输入的空间
1,线性表
数据结构的四种逻辑结构:集合,线性,树形,网状
linearity=(D,R)
1.1 线性表的抽象数据类型
ADT List{
数据对象:
数据关系:
数据操作:
getSize():返回线性表元素的个数
isEmpty():判断线性表是否为空,线性为空返回true.
insert(i,e):在线性表的i索引位置插入元素e
contains(e):在线性表中判断是否存在元素e,存在返回true,
indexOf(e):返回e在线性表中的索引值,不存在返回-1
remove(e):删除线性表中第一个与e相同的元素,删除成功返回删除的元素
remove(i):删除线性表中指定索引值得元素,返回删除的元素
replace(i,e):吧线性表中索引值为i的元素替换为e
get(i):返回线性表中索引值为i的元素
insertBefore(p,e):在线性表中元素p的前面插入元素e
insertAfter(p,e)后面插入元素e
}
1.2 List接口
使用Java中的接口来表示ADT中的操作,
练习:
1 package demo1;
2
3 public interface MyList {
4
5 int getSize();//返回线性表中元素的个数
6 boolean isEmpty();//判断线性表是否为空
7 void insert(int i,Object e);//在线性表的i索引值添加元素e
8 boolean contains(Object e);//判断线性表中元素e的索引值
9 int indexOf(Object e);//返回线性表中元素e的索引值
10 Object remove(Object e);//删除线性表第一个与e相同的元素,并返回该元素
11 Object remove(int i);//删除线性表第一个与i相同的元素,并返回该元素
12 Object replace(int i,Object e);//使用元素e代替i,并返回就得元素
13 Object get(int i);//返回索引值为i的元素
14 boolean insertBefore(Object p,Object e);//在线性表元素p前面插入元素e
15 boolean insertAfter(Object p,Object e);//在线性表元素p后面插入元素e
16
17
18 }
1 package demo1;
2
3 /**
4 * 通过数组实现线性表
5 * @author ASUS
6 *
7 */
8 public class MyArrayList implements MyList {
9 //定义数组
10 private Object[] elements;
11 private static final int DEFAULT_CAPACITY=16;
12 private int size;//保存数据元素个数
13
14
15 //构造方法
16 public MyArrayList() {
17 elements=new Object[DEFAULT_CAPACITY];
18
19 }
20 public MyArrayList(int initialCapacity){
21 elements = new Object[initialCapacity];
22 }
23
24
25
26 @Override
27 //返回元素的个数
28 public int getSize() {
29
30 return size;
31 }
32
33 @Override
34 public boolean isEmpty() {
35 //判断线性表是否为空
36 return size==0;
37 }
38
39 @Override
40
41 public void insert(int i, Object e) {
42 //在线性表的i位置插入元素e
43 if(i<0||i>size){
44 throw new IndexOutOfBoundsException(i+"越界");
45
46 }
47 //如果数组已满,对数组扩容
48 if(size>=elements.length){
49 expandSpace();
50 }
51 //从i开始,把元素依次后移
52 for(int j=size;j>i;j--){
53 elements[j]=elements[j-1];
54
55 }
56 //把元素e存储到i的位置
57 elements[i]=e;
58 //元素个数加一
59 size++;
60
61 }
62
63 //数组扩容
64 private void expandSpace(){
65 //定义一个更大的数组,默认两倍
66 Object[] newElements=new Object[elements.length*2];
67
68 //把原来数组内容复制到新的数组
69 for(int i=0;i<elements.length;i++){
70 newElements[i]=elements[i];
71 }
72 //让原来的数组名指向新的数组
73 elements = newElements;
74
75 }
76 //判断当前线性表中是否包含元素e
77 @Override
78 public boolean contains(Object e) {
79
80 return indexOf(e)>=0;
81 }
82
83 //返回元素e在线性表中第一次的索引值,不存在返回-1
84 @Override
85 public int indexOf(Object e) {
86
87 //遍历数组
88 if(e==null){
89 //如果线性表中用户添加了null
90 for(int i=0;i<size;i++){
91 return i;
92 }
93 }else{
94 for(int i=0;i<size;i++){
95 if(e.equals((elements[i]))){
96 return i;
97
98 }
99 }
100 }
101
102 return -1;
103 }
104
105 //在线性表中删除第一个与e相同的元素
106 @Override
107 public Object remove(Object e) {
108
109 //获得e在线性表中的索引值
110 int index=indexOf(e);
111 if(index<0){
112 return null;//不存在
113
114 }
115 return remove(index);
116 }
117
118 //删除指定索引的元素
119 @Override
120 public Object remove(int i) {
121
122 //判断i是否越界
123 if(i<0||i>=size){
124 throw new IndexOutOfBoundsException(i+"越界");
125
126 }
127 //把要删除的元素保存起来
128 Object old=elements[i];
129 //把i+1开始的元素依次前移
130 for(int j=i;j<size-1;j++){
131 elements[j]=elements[j+1];
132 }
133
134 //把最后的元素置为null
135 elements[size-1]=null;
136 //修改元素的个数
137 size--;
138 return old;
139 }
140
141 //把索引值为i的元素换为e
142 @Override
143 public Object replace(int i, Object e) {
144 //判断索引值是否越界
145 //判断i是否越界
146 if(i<0||i>=size){
147 throw new IndexOutOfBoundsException(i+"越界");
148
149 }
150 //保存原来
151 Object old =elements[i];
152 //替换
153 elements[i]=e;
154 //把越来的返回
155
156 return old;
157 }
158
159 //返回指定索引对应的元素
160 @Override
161 public Object get(int i) {
162 //判断i是否越界
163 if(i<0||i>=size){
164 throw new IndexOutOfBoundsException(i+"越界");
165
166 }
167 return elements[i];
168 }
169
170 //在线性元素p前面加上元素e
171 @Override
172 public boolean insertBefore(Object p, Object e) {
173
174 //获取p的位置
175 int index=indexOf(p);
176 if(index<0){
177 return false;
178 }
179 insert(index,e);
180 return true;
181 }
182
183 //在线性元素后面插入元素e
184 @Override
185 public boolean insertAfter(Object p, Object e) {
186
187 int index = indexOf(p);
188 if(index<0){
189 return false;
190 }
191 insert(index+1,e);
192 return true;
193 }
194
195 //重写toString方法
196 @Override
197 public String toString() {
198 //把线性表中每个元素连接起来,遍历数组中的每个元素
199
200 StringBuilder sb=new StringBuilder();
201 sb.append("[");
202 for(int i=0;i<size;i++){
203 sb.append(elements[i]);
204 if(i<size-1){
205 sb.append(",");
206 }
207 }
208 sb.append("]");
209 return sb.toString();
210 }
211
212
213 }
1 package demo1;
2 /**
3 * 测试
4 * @author ASUS
5 *
6 */
7 public class MyArraylistTest {
8
9 public static void main(String[] args) {
10
11 //创建一个MyArrayList对象
12 MyArrayList list1 = new MyArrayList();
13
14 //判断是否为空
15 System.out.println(list1.isEmpty()); //true
16 System.out.println(list1.getSize()); //0
17
18 //添加元素
19 list1.insert(0, "aa");
20 list1.insert(1, "bb");
21 list1.insert(2, "cc");
22 System.out.println(list1.isEmpty()); //false
23 System.out.println(list1.getSize()); //3
24
25 //把线性表内容输出
26 System.out.println(list1);
27 System.out.println("--------------------------");
28 //5.返回索引
29 System.out.println(list1.indexOf("cc"));
30 System.out.println("--------------------------");
31 //判断是否存在
32 System.out.println(list1.contains("xx"));
33 System.out.println("--------------------------");
34 //删除
35 list1.remove("aa");
36 System.out.println(list1);
37 list1.remove(0);
38 System.out.println(list1);
39 System.out.println("--------------------------");
40 //添加
41 list1.insert(0, "xx");
42 list1.insert(1, "yy");
43 list1.insert(2, "zz");
44 System.out.println(list1);
45 System.out.println("--------------------------");
46 //替换
47 list1.replace(1, "YY");
48 System.out.println(list1);
49 System.out.println("--------------------------");
50 //得到索引对应元素值
51 System.out.println(list1.get(2));
52 //在线性元素p前面加上元素e
53 list1.insertBefore("xx", "ff");
54 System.out.println(list1);
55 //在线性元素p后面加上元素e
56 list1.insertAfter("xx", "RR");
57 System.out.println(list1);
58
59 }
60
61 }
运行结果:
