线性表顺序存储结构

Posted 2021-02-22 duan2

　　线性表的顺序存储是用一组地址连续的存储单元依次存储线性表的数据元素。假设线性
表的每个数据元素需占用K个存储单元，并以元素所占的第一个存储单元的地址作为数据元
素的存储地址。则线性表中序号为i的数据元素的存储地址LOC(a i )与序号为i+1 的数据元素
的存储地址LOC(a i+1 )之间的关系为
LOC(a i+1 ) = LOC(a i ) + K
通常来说，线性表的i号元素a i 的存储地址为
LOC(a i ) = LOC(a 0 ) + i×K
其中LOC(a 0 )为 0 号元素a 0 的存储地址，通常称为线性表的起始地址。
线性表的这种机内表示称作线性表的顺序存储。它的特点是，以数据元素在机内存储地
址相邻来表示线性表中数据元素之间的逻辑关系。每一个数据元素的存储地址都和线性表的
起始地址相差一个与数据元素在线性表中的序号成正比的常数。由此，只要确定了线性表的
起始地址，线性表中的任何一个数据元素都可以随机存取，因此线性表的顺序存储结构是一
种随机的存储结构。

　　由于高级语言中的数组具也有随机存储的特性，因此在抽象数据类型的实现中都是使用
数组来描述数据结构的顺序存储结构。我们看到线性表中的数据元素在依次存
放到数组中的时候，线性表中序号为 i 的数据元素对应的数组下标也为 i，即数据元素在线
性表中的序号与数据元素在数组中的下标相同。
在这里需要注意的是，如果线性表中的数据元素是对象时，数组存放的是对象的引用，
即线性表中所有数据元素的对象引用是存放在一组连续的地址空间中。如图 3-2 所示

 

 

 

 

 

 

　　在数组中添加数据元素，通常是在数组中下标为 i (0 ≤ i ≤ n)的位置添加数据元素，而将
原来下标从 i 开始的数组中所有后续元素依次后移。整个操作过程可以通过图 3-3 说明。

 

 

 

使用 Java 语言实现整个操作过程的关键语句是
for (int j=n; j>i; j--)
a[j] = a[j-1];
a[i] = e;

 

　　与在数组中添加数据元素相对的是在数组中删除数据元素，与添加类似，删除操作也通
常是删除数组中下标为 i (0 ≤ i < n)的元素，然后将数组中下标从 i+1 开始的所有后续元素依
次前移。删除操作过程也可以通过图 3-4 说明

 

 

 

 

 

 

使用 Java 语言实现整个操作过程的关键语句是
for (int j=i; j<n-1; j++)
a[j] = a[j+1];

 

 

 

 

List接口：

 1 **
 2  * 线性表
 3  */
 4 public interface List {
 5     /**
 6      *线性表的长度
 7      */
 8     public int size();
 9 
10     /**
11      * 判断线性表是否为空
12      */
13     public boolean isEmpty();
14     /**
15      * 判断线性表中是否包含某个元素
16      */
17     public boolean contains(Object element);
18     /**
19      * 判断线性表中是否包含某个元素
20      */
21     public int indexOf(Object element);
22 
23     /**
24      *在表中插入元素
25      */
26     public void add(Object element);
27 
28     /**
29      *在索引处插入元素
30      */
31     public void insert(int index,Object element) throws IndexOutOfBoundsException;
32     /**
33      *删除线性表中第一个与 e 相同的元素
34      */
35     public boolean remove(Object element);
36     /**
37      *在表中移除序号为i的某个元素
38      */
39     public Object remove(int i)throws IndexOutOfBoundsException;
40     /**
41      *返回线性表中序号为i的元素
42      */
43     public Object get(int i)throws IndexOutOfBoundsException;
44 
45 
46 
47 }

 

 

顺序存储结构实现线性表

 1 public class ListArray implements List {
 2     private final int LEN = 8;    //数组的默认大小
 3     private int size;           //线性表中数据元素的个数
 4     private Object[] elements;  //数据元素数组
 5 
 6     public ListArray() {
 7         size = 0;
 8         elements = new Object[LEN];
 9     }
10 
11 
12     @Override
13     public int size() {
14         return size;
15     }
16 
17     @Override
18     public boolean isEmpty() {
19         return size == 0;
20     }
21 
22     @Override
23     public boolean contains(Object element) {
24         for (int i = 0; i < size; i++) {
25             if (elements[i].equals(element))
26                 return true;
27         }
28         return false;
29     }
30 
31     @Override
32     public int indexOf(Object element) {
33         for (int i = 0; i < size; i++) {
34             if (elements[i].equals(element))
35                 return i;
36         }
37         return -1;
38     }
39 
40     @Override
41     public void add(Object element) {
42         if (size >= elements.length)
43             expandSpace();
44         elements[++size]=element;
45     }
46 
47     @Override
48     public void insert(int index, Object element) throws IndexOutOfBoundsException {
49         if (index < 0 || index > size)
50             throw new IndexOutOfBoundsException();
51         if (size >= elements.length)
52             expandSpace();
53         for (int j = size; j > index; j--)
54             elements[j] = elements[j - 1];
55         elements[index] = element;
56         size++;
57         return;
58 
59     }
60 
61     private void expandSpace() {
62         Object[] a = new Object[elements.length * 2];
63         for (int i = 0; i < elements.length; i++) {
64             a[i] = elements[i];
65             elements = a;
66         }
67     }
68 
69     @Override
70     public boolean remove(Object element) {
71         int i = indexOf(element);
72         if (i<0)return false;
73         remove(i);
74         return true;
75     }
76 
77     @Override
78     public Object remove(int index) throws IndexOutOfBoundsException {
79         if (index < 0 || index > size)
80             throw new IndexOutOfBoundsException();
81         Object obj=elements[index];
82         for (int j =index; j<size-1; j++)
83             elements[j] = elements[j+1];
84         elements[--size] = null;
85         return obj;
86 
87     }
88 
89     @Override
90     public Object get(int index) throws IndexOutOfBoundsException {
91         if (index < 0 || index > size)
92             throw new IndexOutOfBoundsException();
93         return elements[index];
94     }
95 }