线性表的Java实现

线性表是一种可以在任意位置插入和删除元素，由n个同类型元素组成的线性结构。主要包括顺序表，单链表，循环单链表，双向链表和仿真链表。应用比较广泛的是顺序表和单链表。

下面是线性表的接口，主要操作包括插入元素，删除元素，取得元素，得到线性表元素个数，判断线性表是否为空。

package com.nishizhen.list;
 
public interface List {
    public void insert(int i,Object obj)throws Exception;
    public void delete(int i)throws Exception;
    public Object getData(int i)throws Exception;
    public int size();
    public boolean isEmpty();
}

顺序表：
顺序表插入一个元素需要移动元素的平均次数为n/2次，删除一个元素需要移动元素次数为(n-1)/2，所以顺序表的时间复杂度为O（n）。
顺序表的实现如下:

package com.nishizhen.list;
 
public class SeqList implements List{
    final int defaultSize = 10;
    int maxSize;//顺序表的最大长度
    int size;//线性表当前长度
    Object[] listArray;//存储线性表元素的数组
   
   
    public SeqList(int size){
       initiate(size);
    }
   
    public SeqList(){
       initiate(defaultSize);
    }
   
    public void initiate(int sz){
       maxSize = sz;
       size = 0;
       listArray = new Object[sz];
    }
   
   
    public void insert(int i,Object obj)throws Exception{
       if(size == maxSize){
           throw new Exception("顺序表已满，不能再插入元素。");
       }
       if(i<0 || i>maxSize){
           throw new Exception("参数有误。");
       }
       else{
           for(int j=size;j>=i;j--){
              listArray[j] = listArray[j-1];
           }
          
           listArray[i] = obj;
           size++;
       }
    }
   
   
    public void delete(int i)throws Exception{
       if(size == 0){
           throw new Exception("顺序表为空，无法进行删除元素操作。");
       }
      
       if(i<0 || i>=size){
           throw new Exception("参数出错。");//数组下标不能小于0或者大于size，因为size及其以后的元素为空。
       }
       else{
           for(int j=size-1;j>=i;j--){
              listArray[j-1] = listArray[j];
           }
           listArray[listArray.length-1] = "";
           size--;
       }
    }
   
   
    public Object getData(int i)throws Exception{
       if(size == 0){
           throw new Exception("顺序表为空，无法返回元素。");
       }
      
       if(1<0 || i>=size){
           throw new Exception("参数出错。");//数组下标不能小于0或者大于size，因为size及其以后的元素为空。
       }
       else{
           return listArray[i];
       }
    }
   
   
    public int size(){
       return listArray.length;
    }
   
   
    public boolean isEmpty(){
       boolean flag = false;
       if(listArray.length==0){
           flag = true;
       }
       return flag;
    }
}

单链表：
指针是指一个数据元素逻辑意义上的存储位置，链式存储机构是基于指针实现的，每一个节点由一个数据元素和一个指针构成。链式存储结构是用指针把相互关联的元素链接起来。
在单链表中，每个节点只有一个直接只想后继元素的指针，而双向链表中每个节点有两个指针，一个只想后继节点一个只想前驱节点。
单链表的实现
节点类：

package com.nishizhen.list;
 
public class Node {
    Object element;
    Node next;
   
   
    Node(Node nextval){
       next = nextval;
    }
   
   
    Node(Object obj,Node nextval){
       element = obj;
       next = nextval;
    }
   
   
    public Node getNext(){
       return next;
    }
   
   
    public void setNext(Node nextval){
       next = nextval;
    }
   
   
    public Object getElement(){
       return element;
    }
   
    public void setElement(Object obj){
       element = obj;
    }
   
    public String toString(){
       return element.toString();
    }
}
单链表类：
package com.nishizhen.list;
 
public class LinList implements List{
    Node head;//头指针
    Node current;//当前操作的节点位置
    int size;//数据元素个数
   
    LinList(){
       head = current = new Node(null);
       size = 0;
    }
   
    public void index(int i) throws Exception{
       if(i<-1 || i>size-1){
           throw new Exception("参数出错");
       }
       if(i==-1){
           return;
       }
       current = head.next;
       int j = 0;
       while((current !=null)&&j<i){
           current = current.next;
           j++;
       }
    }
   
    public void insert(int i,Object obj)throws Exception{
       if(1<0 || i>=size){
           throw new Exception("参数错误");
       }
      
       index(i-1);
       current.setNext(new Node(obj,current.next));
       size++;
    }
   
    public void delete(int i)throws Exception{
       if(size==0){
           throw new Exception("链表已空");
       }
       if(1<0 || i>=size){
           throw new Exception("参数错误");
       }
      
       index(i-1);
       Object obj = current.next.getElement();
       current.setNext(current.next.next);
       size--;
    }
   
    public Object getData(int i)throws Exception{
       if(1<0 || i>=size){
           throw new Exception("参数错误");
       }
       index(i);
       return current.getElement();
    }
   
    public int size(){
       return size;
    }
   
    public boolean isEmpty(){
       return size == 0;
    }
}