【Java数据结构】实现顺序表

1. import java.util.Arrays;
2. 
3. public class SqList {
4. 
5. private static final int DEFAULTSIZE=10;//默认数组长度
6. 
7. private int[] elem=new int[DEFAULTSIZE];//数组
8. 
9. private int usedSize;
10. 
11. /**
12.      * getSize()获取有效的长度
13.      * @return
14.      */
15. public int getSize(){
16. 
17. return usedSize;
18. 
19.     }
20. 
21. /**
22.      * isFull()判断顺序表是否为满
23.      * @return
24.      */
25. public boolean isFull(){
26. 
27. return usedSize==DEFAULTSIZE;
28.     }
29. 
30. /**
31.      * isEmpty()判断顺序表是否为空
32.      * @return
33.      */
34. public boolean isEmpty(){
35. return usedSize==0;
36.     }
37. /**
38.      * disPlay()打印顺序表
39.      */
40. public void disPlay(){
41. 
42. for (int i = 0; i <getSize() ; i++) {
43. 
44.             System.out.print(this.elem[i]+" ");
45. 
46.         }
47.         System.out.println();
48.     }
49. 
50. /**
51.      * add()在顺序表末尾增加元素
52.      * @param data
53.      */
54. public void add(int data){
55. //1、判满
56. if(isFull()){
57. //2、扩容
58. this.elem=Arrays.copyOf(this.elem,2*this.elem.length);
59.         }
60. //3、加入
61. this.elem[usedSize]=data;
62. //4、usedSize++
63.         usedSize++;
64.     }
65. 
66. /**
67.      * add()在顺序表的指定位置添加元素
68.      * @param pos  位置 如果pos位置不合法就会抛出一个PosWrongFulException
69.      * @param data 元素
70.      */
71. public void add(int pos,int data)throws PosWrongFulException{
72. //1、判满
73. if(isFull()){
74.             System.out.println("顺序表已满！");
75. this.elem=Arrays.copyOf(this.elem,2*this.elem.length);
76.         }
77. //2、判断位置是否合理（在合理范围内且不能间隔元素）
78. if(pos<0||pos>usedSize){
79. 
80.             System.out.println("pos位置不合法");
81. throw new  PosWrongFulException("pos位置不合法！");
82. 
83.         }
84. //3、移动位置
85. for (int i =usedSize-1; i>=pos; i--) {
86. this.elem[i+1]=this.elem[i];
87.         }
88. 
89. //4、添加元素
90. this.elem[pos]=data;
91. //5、usedSize++
92.         usedSize++;
93.     }
94. 
95. /**
96.      * indexOf(获取第一次出现指定元素的下标)
97.      * @param data 指定元素
98.      * @return
99.      */
100. 
101. public int indexOf(int data)throws EmptyException{
102. //1、判空
103. if(isEmpty()){
104.             System.out.println("顺序表为空");
105. throw new  EmptyException("顺序表为空！");
106.         }
107. //2、查找
108. for (int i = 0; i < getSize(); i++) {
109. 
110. if(this.elem[i]==data){
111. return i;
112.             }
113.         }
114. return -1;
115. 
116. 
117.     }
118. 
119. /**
120.      * valueOf (int pos)获取指定下标的元素
121.      * @param pos
122.      * @return
123.      */
124. public int valueOf (int pos)throws PosWrongFulException,EmptyException{
125. //1、判空
126. if(isEmpty()){
127.             System.out.println("顺序表为空");
128. throw new  EmptyException("顺序表为空！");
129.         }
130. //2、判断位置是否合理
131. if(pos<0||pos>usedSize){
132. 
133.             System.out.println("pos位置不合法");
134. throw new  PosWrongFulException("pos位置不合法！");
135. 
136.         }
137. //3、获取该元素
138. return this.elem[pos];
139. 
140.     }
141. 
142. /**
143.      * setValue(int pos,int value)设置指定位置的元素
144.      * @param pos
145.      * @param value
146.      */
147. public void setValue(int pos,int value)throws PosWrongFulException{
148. //1、判断位置是否合法
149. if(pos<0||pos>usedSize){
150. 
151.             System.out.println("pos位置不合法");
152. throw new  PosWrongFulException("pos位置不合法！");
153. 
154.         }
155. //2、设置位置的值
156. this.elem[pos]=value;
157.     }
158. 
159. /**
160.      * deletePos(int pos)删除指定位置的元素
161.      * @param pos
162.      */
163. public void deletePos(int pos)throws EmptyException,PosWrongFulException{
164. //1、判空
165. if(isEmpty()){
166.             System.out.println("顺序表为空");
167. throw new  EmptyException("顺序表为空！");
168.         }
169. //2、判断位置是否合法
170. if(pos<0||pos>usedSize){
171. 
172.             System.out.println("pos位置不合法");
173. throw new  PosWrongFulException("pos位置不合法！");
174. 
175.         }
176. 
177. //3、移动
178. for (int i =pos; i<usedSize-1; i++) {
179. 
180. this.elem[i]=this.elem[i+1];
181. 
182.         }
183. //4、usedSize--
184. 
185.         usedSize--;
186.     }
187. 
188. 
189. /**
190.      *  delete(int value)删除第一次出现的value
191.      * @param value
192.      */
193. public void delete(int value) throws EmptyException{
194. //1、判空
195. if(isEmpty()){
196.             System.out.println("顺序表为空");
197. throw new  EmptyException("顺序表为空！");
198.         }
199. //2、找位置
200. 
201. int index=this.indexOf(value);
202. //3、移动
203. for (int i =index; i<usedSize-1; i++) {
204. 
205. this.elem[i]=this.elem[i+1];
206. 
207.         }
208. //4、usedSize--
209. 
210.         usedSize--;
211.     }
212. 
213. 
214. /**
215.      * clear()清空顺序表
216.      */
217. public void clear(){
218.         usedSize=0;
219.     }
220. 
221. 
222. 
223. }

1. public class EmptyException extends RuntimeException{
2. public EmptyException() {
3.     }
4. 
5. public EmptyException(String message) {
6. super(message);
7.     }
8. }

1. public class PosWrongFulException extends RuntimeException{
2. public PosWrongFulException() {
3.     }
4. 
5. public PosWrongFulException(String message) {
6. super(message);
7.     }
8. }

1. public class Test {
2. public static void main(String[] args) {
3. 
4.         SqList sqList=new SqList();
5.         sqList.add(1);
6.         sqList.add(2);
7.         sqList.add(3);
8.         sqList.disPlay();
9. try{
10.             sqList.add(1,10);
11.         }catch (PosWrongFulException e){
12. 
13.             e.printStackTrace();
14. 
15.         }
16.         sqList.disPlay();
17. 
18. try{
19.             System.out.println(sqList.indexOf(1));
20.         }catch (EmptyException e){
21.             e.printStackTrace();
22.         }
23. 
24. try{
25.             System.out.println(sqList.valueOf(1));
26.         }catch (PosWrongFulException e){
27.             e.printStackTrace();
28.         }
29. 
30. try {
31.             sqList.setValue(0,99);
32.         }catch (PosWrongFulException e){
33.             e.printStackTrace();
34.         }
35. 
36.         sqList.disPlay();
37. try{
38.             sqList.deletePos(3);
39.         }catch (PosWrongFulException e){
40.             e.printStackTrace();
41.         }
42. 
43.         sqList.disPlay();
44. try {
45.             sqList.delete(2);
46.         }catch (EmptyException e){
47.             e.printStackTrace();
48.         }
49.         sqList.disPlay();
50. 
51.         sqList.clear();
52. 
53.     }
54. }