顺序线性表的代码实现

Posted 2020-09-14 闲情偶寄

1、采用一个数组实现一个顺序线性表中添加元素、删除元素等基本操作

  1 package com.ietree.basic.datastructure.Sequence;
  2 
  3 import java.util.Arrays;
  4 
  5 /**
  6  * 顺序线性表
  7  * 
  8  * @param <T>
  9  * @author Dylan
 10  */
 11 public class SequenceList<T> {
 12 
 13     private final int DEFAULT_SIZE = 16;
 14     // 保存数组的长度
 15     private int capacity;
 16     // 定义一个数组用于保存顺序线性表的元素
 17     private Object[] elementData;
 18     // 保存顺序表中元素的当前个数
 19     private int size = 0;
 20     
 21     // 以默认数组长度创建顺序线性表
 22     public SequenceList() {
 23         capacity = DEFAULT_SIZE;
 24         elementData = new Object[capacity];
 25     }
 26     
 27     // 以一个初始化元素创建顺序线性表
 28     public SequenceList(T element) {
 29         this();
 30         elementData[0] = element;
 31         size++;
 32     }
 33     
 34     /**
 35      * 以指定长度的数组来创建顺序线性表
 36      * @param element 指定顺序线性表中第一个元素
 37      * @param initSize 指定顺序线性表底层数组的长度
 38      */
 39     public SequenceList(T element, int initSize) {
 40         capacity = 1;
 41         // 把capacity设为大于initSize的最小的2的n次方
 42         while (capacity < initSize) {
 43             capacity <<= 1;
 44         }
 45         elementData = new Object[capacity];
 46         elementData[0] = element;
 47         size++;
 48     }
 49     
 50     // 获取顺序线性表的大小
 51     public int length() {
 52         return size;
 53     }
 54     
 55     // 获取顺序线性表中索引为i处的元素
 56     public T get(int i) {
 57         if (i < 0 || i > size - 1) {
 58             throw new IndexOutOfBoundsException("线性表索引越界");
 59         }
 60         return (T) elementData[i];
 61     }
 62     
 63     // 查找顺序线性表中指定元素的索引
 64     public int locate(T element) {
 65         for (int i = 0; i < size; i++) {
 66             if (elementData[i].equals(element)) {
 67                 return i;
 68             }
 69         }
 70         return -1;
 71     }
 72     
 73     // 向顺序线性表的指定位置插入一个元素
 74     public void insert(T element, int index) {
 75         if (index < 0 || index > size) {
 76             throw new IndexOutOfBoundsException("线性表索引越界");
 77         }
 78         ensureCapacity(size + 1);
 79         // 将指定索引处之后的所有元素向后移动一格
 80         System.arraycopy(elementData, index, elementData, index + 1, size - index);
 81         elementData[index] = element;
 82         size++;
 83     }
 84     
 85     // 在插入元素之前需要确保顺序线性表的长度大于插入之后顺序线性表的长度
 86     private void ensureCapacity(int minCapacity) {
 87         
 88         // 如果数组的原有长度小于目前所需的长度
 89         if (minCapacity > capacity) {
 90             // 不断地将capacity * 2，直到capacity大于minCapacity
 91             while (capacity < minCapacity) {
 92                 capacity <<= 1;
 93             }
 94             elementData = Arrays.copyOf(elementData, capacity);
 95         }
 96     }
 97     
 98     // 在线性顺序表的开始处添加一个元素
 99     public void add(T element) {
100         insert(element, size);
101     }
102     
103     // 删除顺序线性表中指定索引处的元素
104     public T delete(int index) {
105         if (index < 0 || index > size - 1) {
106             throw new IndexOutOfBoundsException("线性表索引越界");
107         }
108         T oldValue = (T) elementData[index];
109         int numMoved = size - index - 1;
110         if (numMoved > 0) {
111             System.arraycopy(elementData, index + 1, elementData, index, numMoved);
112         }
113         // 清空最后一个元素
114         elementData[--size] = null;
115         return oldValue;
116     }
117     
118     // 删除顺序线性表中最后一个元素
119     public T remove() {
120         return delete(size - 1);
121     }
122     
123     // 判断顺序线性表是否为空表
124     public boolean empty() {
125         return size == 0;
126     }
127     
128     // 清空线性表
129     public void clear() {
130         Arrays.fill(elementData, null);
131         size = 0;
132     }
133 
134     public String toString() {
135         if (size == 0) {
136             return "[]";
137         } else {
138             StringBuilder sb = new StringBuilder("[");
139             for (int i = 0; i < size; i++) {
140                 sb.append(elementData[i].toString() + ",");
141             }
142             int len = sb.length();
143             return sb.delete(len - 2, len).append("]").toString();
144         }
145     }
146 
147 }

测试模拟线性表的基本操作：

 1 package com.ietree.basic.datastructure.Sequence;
 2 
 3 /**
 4  * 测试类
 5  * 
 6  * @author Dylan
 7  */
 8 public class SequenceListTest {
 9     
10     public static void main(String[] args) {
11         SequenceList<String> list = new SequenceList<String>();
12         list.add("aaa");
13         list.add("bbb");
14         list.add("ccc");
15         list.add("ddd");
16         list.insert("eee", 1);
17         System.out.println(list);
18         list.delete(2);
19         System.out.println(list);
20         System.out.println("ccc在顺序线性表中的位置：" + list.locate("ccc"));
21     }
22 }

程序输出：

[aaa,eee,bbb,ccc,dd]
[aaa,eee,ccc,dd]
ccc在顺序线性表中的位置：2