线性表的顺序存储结构（java版）

请参考原文：http://hjj20040849.iteye.com/blog/1816838

在说线性表的顺序存储结构之前，首先要讲一下必要的定义。

线性表的定义 ：零个或多个数据元素的有限序列

线性表的顺序存储结构 ：用一段地址连续的存储单元依次存储线性表的数据元素。

 

在了解这两个必要的定义之后，我们就来看一下他的代码实现吧，在本文中，由于我个人比较熟悉Java，所以就用Java来进行代码实现了，当然，如果条件允许的话，还是比较建议读者通过C或者C++来进行代码实现。

 

第一步：我们先定义一个接口，代码如下

Java代码  

1. package com.stucture.sqlList;  
2.   
3. /** 
4.  * 线性表顺序存储结构的接口 
5.  * 指的是用一段地址连续的存储单元一次存储线性表的数据元素 
6.  * @ClassName: ISeqList  
7.  * @author 小学徒 
8.  * @date 2013-2-27 
9.  */  
10. public interface ISeqList<T> {  
11.       
12.     /** 
13.      * 获得元素 
14.      * @param i 需要获得的第i个元素 
15.      * @return  
16.      */  
17.     public T getElem(int i);  
18.       
19.   
20.     /** 
21.      * 插入元素 
22.      * @param i 元素的插入位置 
23.      * @param t 需要插入的元素 
24.      * @return  是否成功插入 
25.      */  
26.     public boolean insertElem(int i, T t);  
27.       
28.     /** 
29.      * 删除元素 
30.      * @param i 需要删除元素的位置 
31.      * @return 
32.      */  
33.     public T deleteElem(int i);  
34. }  

 

第二步，实现该接口中必要的方法，代码如下：

Java代码  

1. package com.stucture.sqlList;  
2.   
3. /** 
4.  * 线性表顺序存储结构 
5.  * 指的是用一段地址连续的存储单元一次存储线性表的数据元素 
6.  * @ClassName: SeqList  
7.  * @author 小学徒 
8.  * @date 2013-2-27 
9.  */  
10. public class SeqList<T> implements ISeqList<T> {  
11.     public static final int MAXSIZE = 20;   //存储空间的初始化配量  
12.       
13.     private T[] data;   //数组存储数据元素  
14.     private int length; //线性表当前长度         
15.       
16.     public SeqList() {  
17.         data = (T[]) new Object[MAXSIZE];  
18.     }  
19.       
20.     // 获得元素  
21.     public T getElem(int i) {  
22.         if(i < 0 || i >MAXSIZE) {  
23.             return null;  
24.         }  
25.         T t = data[i - 1];  
26.         return t;  
27.     }  
28.   
29.     // 插入元素  
30.     public boolean insertElem(int i, T t) {  
31.         if(length == MAXSIZE) { //线性表已经满了  
32.             System.out.println("该线性表已经满了");  
33.             return false;  
34.         }  
35.           
36.         if(i < 1 || i > MAXSIZE) {    //插入位置不在范围内  
37.             System.out.println("该位置不合法");  
38.             return false;  
39.         }  
40.           
41.         if(i < length) { //插入位置不在表尾  
42.               
43.             for(int j = length; j >= i; j--) {   //将要插入位置后数据元素向后移动一位  
44.                 data[j] = data[j - 1];  
45.             }  
46.         }  
47.         data[i - 1] = t;    //插入新元素  
48.         length++;   //线性表长度增加  
49.         return true;  
50.     }  
51.       
52.     //删除元素  
53.     public T deleteElem(int i) {  
54.           
55.         if(length == 0) {   //"线性表为空"  
56.             System.out.println("线性表为空");  
57.             return null;   
58.         }  
59.   
60.         if(i < 1 || i > length) { //删除位置不在范围内  
61.             System.out.println("该位置不合法");  
62.             return null;  
63.         }  
64.         T t = data[i -1];  
65.         for(int j = (i - 1); j <= (length - 1); j++) {  
66.             data[j] = data[j+1];  
67.         }  
68.         length--;//线性表长度减少  
69.         return t;  
70.           
71.     }  
72.       
73.     public T[] getData() {  
74.         return data;  
75.     }  
76.   
77.     public void setData(T[] data) {  
78.         this.data = data;  
79.     }  
80.   
81.     public int getLength() {  
82.         return length;  
83.     }  
84.   
85.     public void setLength(int length) {  
86.         if(length < 0 || length > MAXSIZE) {  //删除位置不在范围内  
87.             System.out.println("长度不合法");  
88.         }  
89.         this.length = length;  
90.     }  
91.       
92. }  

 

第三步，既然我们已经通过Java代码实现了线性表的顺序存储结构，我们下面就写一个比较完善的代码测试，在下面的代码中，我是通过随机数来生成一些必要的数据来测试的，只要多运行几遍，还是能够测试比较完善的，不过封装的可能有点不太好，如果读者看了以后有什么更好的建议，还希望能够指出，谢谢，好啦，废话不多说，继续上代码：

Java代码  

1. package com.stucture.sqlList;  
2.   
3. import java.util.Random;  
4.   
5. public class SeqListTest {  
6.     final int MAX = 25;  
7.     Random r = new Random();  
8.     SeqList<Integer> seqList;  
9.       
10.     public SeqListTest() {  
11.         initSeqList();  
12.     }  
13.       
14.     //创建一个线性表顺序存储结构  
15.     public void initSeqList() {  
16.   
17.         seqList = new SeqList<Integer>();  
18. //      int length = (int) Math.random();   //只能产生0.0 - 1.0之间的double随机数  
19.         int length = Math.abs(r.nextInt(MAX));  //使用Random随机产生一个25左右的值,使用Math.abs()函数来取绝对值    
20.         System.out.println("产生的数组长度为 ：" + length);  
21.           
22.         if(length > SeqList.MAXSIZE) {  
23.             System.out.println("该长度不合法");  
24.         }  
25.           
26.         for (int i = 1; i <= length; i++) {  //为生成的数组赋值，同时也测试了插入值的方法  
27.             int j =r.nextInt(MAX);  
28.             System.out.print(j + " ");  
29.               
30.             if(!seqList.insertElem(i, j)) {  
31.                 System.exit(0);   
32.             }  
33.         }  
34.         System.out.println("\n原始数组是 ：");  
35.         display(seqList);  
36.     }  
37.       
38.     //测试删除方法  
39.     public void deleteElem() {  
40.         int i = r.nextInt(MAX);  
41.         System.out.println("\n\n删除的位置是：" + i);  
42.         Integer deleteNumber = seqList.deleteElem(i);  
43.           
44.         if( deleteNumber == null) {  
45.             System.exit(0);  
46.         } else {  
47.             System.out.println("删除的元素是 ： " + deleteNumber);  
48.             System.out.println("删除元素后数组是 ：");  
49.             display(seqList);  
50.         }  
51.     }  
52.       
53.     //测试随机插入方法  
54.     public void insertByRandom() {  
55.         int i = r.nextInt(MAX);  
56.         System.out.println("\n\n随机插入位置是 ：" + i);  
57.         int elem = r.nextInt(MAX);  
58.         System.out.println("随机插入数据是 ：" + elem);  
59.         seqList.insertElem(i, elem);  
60.         System.out.println("随机插入数据后数组是 ：");  
61.         display(seqList);  
62.     }  
63.       
64.     //数据展示  
65.     public  void display(SeqList seqList) {  
66.         for (int i = 1; i < seqList.getData().length; i++) {  
67.               
68.             if(seqList.getElem(i) != null) {  
69.                 System.out.print(seqList.getElem(i) + " ");  
70.             }  
71.               
72.         }  
73.         System.out.println("数组的长度为 ：" + seqList.getLength());  
74.     }  
75.       
76.     //获取元素  
77.     public void getElem() {  
78.         int i = r.nextInt(MAX);  
79.         System.out.println("\n获取位置为 ：" + i);  
80.         System.out.println("获取到的元素为 : " + seqList.getElem(i));  
81.           
82.           
83.     }  
84.       
85.     public static void main(String[] args) {  
86.         SeqListTest s = new SeqListTest();  
87.         s.insertByRandom();  
88.         s.deleteElem();  
89.         s.getElem();  
90.     }  
91. }  

 下面个钟情况的运行结果我就不完全列出啦，我只列出其中一个测试结果，剩下的大家自己实践啦，毕竟实践是认知的源泉嘛。

运行结果代码  

1. 产生的数组长度为 ：15  
2. 9 8 22 23 18 0 6 0 19 1 7 24 11 10 18   
3. 原始数组是 ：  
4. 9 8 22 23 18 0 6 0 19 1 7 24 11 10 18 数组的长度为 ：15  
5.   
6.   
7. 随机插入位置是 ：21  
8. 随机插入数据是 ：5  
9. 该位置不合法  
10. 随机插入数据后数组是 ：  
11. 9 8 22 23 18 0 6 0 19 1 7 24 11 10 18 数组的长度为 ：15  
12.   
13.   
14. 删除的位置是：1  
15. 删除的元素是 ： 9  
16. 删除元素后数组是 ：  
17. 8 22 23 18 0 6 0 19 1 7 24 11 10 18 数组的长度为 ：14  
18.   
19. 获取位置为 ：7  
20. 获取到的元素为 : 0