1 class InitList{
 2     
 3     private int length;              //顺序表长度，表示顺序表中的元素个数
 4     
 5     private int [] list;             //数组，顺序表主体
 6     
 7     public InitList(int max){        //构造函数，用来初始化顺序表时定义顺序表的最大长度
 8         this.list = new int[max];
 9         this.length = 0;
10     }
11 }

1 public void clearList() {
2     this.length = 0;            //由于是用length属性来表示顺序表中的元素个数，所以清空顺序表只需将length置零即可
3 }

1 public boolean listEmpty() {
2     if(this.length == 0) {         //通过判断length属性是否为零，即可判断顺序表是否为空
3         return true;
4     }else {
5         return false;
6     }
7 }

1 public int listLength() {
2     return this.length;         　　//同上返回length值即可
3 }

 1 public int [] getElem(int site) {
 2 
 3     int [] ret = new int[1];                    //用来存储获取的值
 4 
 5     if(site < 1 || site > this.length) {        //检测输入的位置是否合法
 6         return null;
 7     }
 8 
 9     ret[0] = this.list[site - 1];               //获取指定位置的值
10     return ret;
11 }

1 public int locateElem(int value) {
2 
3     for (int i = 0; i < this.length; i++) {   //遍历顺序表
4         if(this.list[i] == value) {           //逐值比较，如果相同，返回此元素所在位置
5             return i + 1;
6         }
7     }
8     return 0;                                 //如未找到，返回零
9 }

 1 public int [] priorElem(int value) {
 2 
 3     int [] ret = new int[this.length];           //定义一个与顺序表同等长度的数组，用来存储找到的直接前驱
 4     int in = 1;                　　　　　　　　　　 //从数组的第二个位置开始存储找到的直接前驱，第一个空间用来存储找到的直接前驱的个数
 5 
 6     for(int i = 1; i < this.length; i++) {    　 //遍历顺序表
 7         if(this.list[i] == value) {         　　 //逐值比较，如果相等，存储其直接前驱到数组中
 8             ret[in] = this.list[i - 1];
 9             in++;
10         }
11     }
12 
13     if(in != 1) {        　　　　　　　　　　　　　 //判断是否找到了直接前驱
14         ret[0] = in - 1; 　　　　　　　　　　　    //将直接前驱的个数存入数组中
15         return ret;
16     }else {
17         return null;
18     }
19 }

 1 public int [] nextElem(int value) {      　　  //代码逻辑同直接前驱，此处不再赘述
 2 
 3     int [] ret = new int[this.length];
 4     int in = 1;
 5 
 6     for(int i = 0; i < this.length - 1; i++) {
 7         if(this.list[i] == value) {
 8             ret[in] = this.list[i + 1];
 9             in++;
10         }
11     }
12 
13     if(in != 1) {
14         ret[0] = in - 1;
15         return ret;
16     }else {
17         return null;
18     }
19 }

 1 public int listInsert(int site,int value) {
 2 
 3     if(site < 1 || site > this.length + 1) {  　　　　　　 //判断输入的位置是否合法
 4         return -1;
 5     }else if(this.length == this.list.length) {   　　　　//判断顺序表是否已满
 6         return -2;
 7     }
 8 
 9     for(int i = this.length - 1; i >= site - 1; i--) {   //从顺序表的最后一个元素开始，逐个向后移动一位，直到要插入元素的位置，为要插入的元素腾出空间
10         this.list[i+1] = this.list[i];
11     }
12 
13     this.list[site - 1] = value;  　　　　　　　　　　　　　　//插入元素
14     this.length++; 　　　　　　　　　　　　　　　　　　　　　　 //顺序表长度加一
15     return 0;
16 }

 1 public boolean listDelete(int site) {
 2     if(site < 1 || site > this.length) {   　　　　　　　　//判断输入的位置是否合法
 3         return false;
 4     }else if(site == this.length) {        　　　　　　　　//如果要删除的是最后一个元素，直接将顺序表长度减一即可
 5         this.length--;
 6         return true;
 7     }else {
 8         for (int i = site - 1; i < this.length; i++) {  //从要删除元素的位置开始，将后面的元素逐个向前移动一位，填补删除元素后的空缺
 9             this.list[i] = this.list[i + 1];
10         }
11         this.length--; 　　　　　　　　　　　　　　　　　　　 //顺序表长度减一
12         return true;
13     }
14 }

public String traverseList() {  　　　　　　　　　　//遍历顺序表并输出

    String s = "";  　　　　　　　　　　　　　　　　  //用来存储顺序表中的值

    for (int i = 0; i < this.length; i++) { 　　 //遍历顺序表，存入字符串中
        s += this.list[i] + "、";
    }

    if(s.length() == 0) {  　　　　　　　　　　　　 //如果顺序表为空，直接返回空字符串
        return s;
    }

    return s.substring(0,s.length() - 1); 　　　 //删去最后一个顿号
}