线性表的顺序存储之java实现

线性表有两种存储结构：顺序存储结构和链式存储结构。用顺序存储结构实现的线性表称为顺序表，用链式存储结构实现的线性表是链式表。

顺序表是用一组连续的存储单元顺序存放线性表的数据元素，数据元素在内存的物理存储次序与他们在线性表中的逻辑次序是一致的，即数据元素a_i与其前驱a_i-1以及后继元素a_i+1的位置相邻。

在高级程序设计语言中，我们使用数组来存储顺序表，因为数组在物理结构上属于一组连续存储单元。

  1 package com.zbt.seqlList;
  2 
  3 public class SeqLinearList {
  4 
  5     /**
  6      * 顺序表的java实现
  7      * 
  8      * @param args
  9      */
 10 
 11     private static int table[];// 使用一位数组来存储
 12     private static int n; // 记载顺序表长度
 13 
 14     public static void main(String[] args) {
 15         SeqLinearList sl = new SeqLinearList(10);
 16         // // System.out.println(table.length);
 17         // // System.out.println(sl.isEmpty());
 18         sl.setElement(1, 5);
 19         sl.setElement(2, 4);
 20         sl.setElement(3, 3);
 21         sl.setElement(4, 2);
 22         sl.setElement(5, 1);
 23         sl.setElement(6, 1);
 24         sl.printElement();
 25         sl.setElement(6, 10);
 26         sl.printElement();
 27         // sl.insertElement(7, 11);
 28         // sl.printElement();
 29         // sl.deleElement(7);
 30         // sl.printElement();
 31         // sl.deleElement(1);
 32         // sl.printElement();
 33         // System.out.println(sl.findElement(5));
 34         sl.deleElement(1);
 35         sl.printElement();
 36     }
 37 
 38     /**
 39      * 顺序表的初始化 为顺序表分配n个存储单元；顺序表初始长度为0；
 40      * 
 41      * @param n
 42      */
 43     public SeqLinearList(int n) {
 44         table = new int[n];
 45         this.n = 0;
 46     }
 47 
 48     /**
 49      * 判断顺序表是否为空
 50      * 
 51      * @return
 52      */
 53     public boolean isEmpty() {
 54         return n == 0;
 55     }
 56 
 57     /**
 58      * 判断顺序表是否为满
 59      * 
 60      * @return
 61      */
 62     public boolean isFull() {
 63         return n >= table.length;
 64     }
 65 
 66     /**
 67      * 获取顺序表长度
 68      * 
 69      * @return
 70      */
 71     public int getLength() {
 72         return n;
 73     }
 74 
 75     /**
 76      * 获得顺序表的第i个元素
 77      * 
 78      * @param i
 79      * @return
 80      */
 81     public int getElement(int i) {
 82         if (i > 0 && i <= n)
 83             return table[i - 1];
 84         else
 85             return -1;
 86     }
 87 
 88     /**
 89      * 设置顺序表第i位置元素值
 90      * 
 91      * @param i
 92      */
 93     public void setElement(int i, int k) {
 94         try {
 95             if (i > 0 && i <= (n + 1)) {
 96                 table[i - 1] = k;
 97                 if (i == n + 1)
 98                     n++;
 99             }
100         } catch (Exception e) {
101             System.out.println("您设置的第" + i + "个元素数组越界");
102         }
103         // else
104         // System.out.println("第" + i + "个元素数组越界");
105     }
106 
107     /**
108      * 打印顺序表
109      */
110     public void printElement() {
111         for (int i = 0; i < n; i++) {
112             System.out.print(table[i] + " ");
113         }
114         System.out.println("
");
115     }
116 
117     /**
118      * 查找元素
119      * 
120      * @param k
121      * @return
122      */
123     public boolean findElement(int k) {
124         boolean flag = false;
125         for (int i = 0; i < n; i++) {
126             if (table[i] == k)
127                 flag = true;
128         }
129         return flag;
130     }
131 
132     /**
133      * 在第i个位置插入元素k
134      * 
135      * @param i
136      * @param k
137      */
138     public void insertElement(int i, int k) {
139         if (!isFull()) {
140             if (i <= 0)
141                 i = 1;
142             if (i > n)
143                 i = n + 1;
144             for (int j = n; j > i - 1; j--) {
145                 table[j] = table[j - 1];
146             }
147             table[i - 1] = k;
148             n++;
149         } else
150             System.out.println("数组已满，无法插入K值");
151     }
152 
153     /**
154      * 删除第i位置元素
155      */
156     public void deleElement(int i) {
157         if (!isEmpty()) {
158 
159             if (i <= 0 || i > n) {
160                 System.out.println("输入不合法");
161                 return;
162             }
163 
164             for (int j = i - 1; j < n; j++) {
165                 table[j] = table[j + 1];
166             }
167             n--;
168 
169         } else
170             System.out.println("顺序表为空");
171     }
172 }