数据结构_顺序表的java实现

这篇文章讲述的是数据结构部分的顺序表的java实现，如有错误或者不当之处，还望各位大神批评指正。

顺序表的特点

• 因为物理结构和逻辑结构均连续
• 删除和添加会比较麻烦
• 顺序储存要求明确数据的规模用来分配数据空间
• 数据的存取比较简易

顺序表的基本操作

1. init:初始化顺序表
2. destroy：销毁数据表
3. clear：清空数据表中的元素
4. length：获取数据表长度
5. get：获取索引位置的元素
6. locateElem：定位元素
7. priorElem：获取元素前驱
8. nextElem：获取元素后继
9. put：顺序放入元素
10. insert：插入元素
11. replace：替换元素
12. delete：删除元素
13. isEmpty：判断顺序表是否为空
14. print：打印顺序表中的元素

顺序表的java实现

package list;
/**
 * @author 叶清逸
 * @date 2018年7月20日上午2:52:36
 * @version 1.0
 * @project dataStructure
 * 
 * ================================数据结构说明：========================================
 * 
 * 名称：顺序表
 * 
 * 特征：
 *      1. 因为物理结构和逻辑结构均连续
 *      2. 删除和添加会比较麻烦
 *      3. 顺序储存要求明确数据的规模用来分配数据空间
 *      4. 数据的存取比较简易
 * 
 * 主要方法：
 *      1. init:初始化顺序表
 *      2. destroy：销毁数据表
 *      3. clear：清空数据表中的元素
 *      4. length：获取数据表长度
 *      5. get：获取索引位置的元素
 *      6. locateElem：定位元素
 *      7. priorElem：获取元素前驱
 *      8. nextElem：获取元素后继
 *      9. put：顺序放入元素
 *      10. insert：插入元素
 *      11. replace：替换元素
 *      12. delete：删除元素
 *      13. isEmpty：判断顺序表是否为空
 *      14. print：打印顺序表中的元素
 * 
 * ======================================================================================
 */
public class SequenceList implements List{

    final int INITSIZE = 100 ;
    final int INCREAMENT = 10 ;

    private int CURRENTSIZE ;

    private int LENGTH;
    private Object ELEMENT[] ;

    /**
     * @explain init方法: 初始化顺序表
     * @throws 
     * @author 叶清逸
     * @date 2018年7月20日 下午3:59:12
     */
    public void init(){
        CURRENTSIZE = INITSIZE ;
        ELEMENT = new Object[INITSIZE] ;
        LENGTH = 0 ;
    }

    /**
     * @explain destroy方法:销毁顺序表
     * @return  void
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:23:18
     */
    public void destroy(){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*java有垃圾回收机制*/
        ELEMENT = null ;
    }
    /**
     * @explain clear方法:清空线性表
     * @return  void
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:23:57
     */
    public void clear(){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*遍历每一个元素若不为空则清除*/
        for(int i=0 ; i<LENGTH ; i++){
            if(ELEMENT[i] != null)
                ELEMENT[i] = null ;
        }
    }
    /**
     * @explain length方法:获取线性表当前长度
     * @return int 线性表长度
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:30:44
     */
    public int length(){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return -1;
        }
        return LENGTH ;
    }
    /**
     * @explain get方法:获取索引index位置的元素elem
     * @param index 索引位置
     * @return Object 返回索引位置的元素
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:32:04
     */
    public Object get(int index){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return null;
        }
        /*判断索引位置是否合法*/
        if(index>LENGTH || index <=0 ){
            System.out.println("错误：索引位置不合法");
            return null;
        }
        return ELEMENT[index-1] ;
    }
    /**
     * @explain locateElem方法:定位元素
     * @param elem 元素
     * @return int 元素的索引位置
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:33:02
     */
    public int locateElem(Object elem){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return -1;
        }
        int index = -1;
        for(int i=0 ; i<LENGTH ; i++){
            if(ELEMENT[i].equals(elem)){
                index = i+1 ;
                break ;
            }   
        }
        return index ;
    }
    /**
     * @explain priorElem方法:获取元素的前驱
     * @param elem 当前元素
     * @return Object 元素的前驱
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:33:41
     */
    public Object priorElem(Object elem){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return null;
        }
        Object prior = null ;
        /*先获取元素的索引*/
        int index = locateElem(elem) ;
        /*若为第一个元素则没有前驱*/
        if(index == 1){
            return null ;
        }
        /*若元素存在则返回前驱否则返回null*/
        if(index != -1){
            prior = ELEMENT[index-2] ; 
            /*返回前驱*/
        }else {
            System.out.println("错误:元素"+elem+"不存在！");
            return null ;
        }
        return prior ;
    }
    /**
     * @explain nextElem方法:获取元素的后继
     * @param elem 当前元素
     * @return Object 元素的后继
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:35:04
     */
    public Object nextElem(Object elem){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return null;
        }
        Object next = null ;
        /*先获取元素的索引*/
        int index = locateElem(elem) ;
        /*若为最后一个元素则没有后继*/
        if(index == LENGTH){
            return null ;
        }
        /*若元素存在则返回后继否则返回null*/
        if(index != -1){
            next = ELEMENT[index] ; 
            /*返回前驱*/
        }else {
            System.out.println("错误:元素"+elem+"不存在！");
            return null ;
        }
        return next ;
    }
    /**
     * @explain put方法:顺序放入元素
     * @param elem 元素
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:35:37
     */
    public void put(Object elem){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*当线性表满时扩充*/
        if(LENGTH == CURRENTSIZE){
            extend() ;
        }
        //寻找一个空位放入元素
        for(int i=0 ; i<CURRENTSIZE ; i++){
            if(ELEMENT[i] == null){
                ELEMENT[i] = elem ;
                LENGTH++ ;
                break ;
            }
        }
    }
    /**
     * @explain insert方法:在索引位置插入元素
     * @param index 索引位置
     * @param elem 元素
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:36:39
     */
    public void insert(int index , Object elem){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*判断索引位置是否合法*/
        if(index>LENGTH || index <=0 ){
            System.out.println("错误：索引位置不合法");
            return ;
        }
        /*若插入后越界则扩充*/
        if(LENGTH+1 > CURRENTSIZE){
            extend();
        }
        /*元素依次后移*/
        for(int i=LENGTH-1 ; i>=index-1 ;i--){
            Object temp = ELEMENT[i] ;
            ELEMENT[i] = ELEMENT[i+1] ;
            ELEMENT[i+1] = temp ;
        }
        /*将元素放到索引位*/
        ELEMENT[index-1] = elem ;
        /*顺序表长度加一*/
        LENGTH++ ;
    }
    /**
     * @explain replace方法:替换索引位置的元素
     * @param index 索引
     * @param elem 元素
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:37:05
     */
    public void replace(int index , Object elem){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*判断索引位置是否合法*/
        if(index>LENGTH || index <=0 ){
            System.out.println("错误：索引位置不合法");
            return ;
        }
        /*将index位置上的元素替换*/
        ELEMENT[index] = elem ;
    }
    /**
     * @explain delete方法:删除索引位置的元素
     * @param index 索引位置
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:37:42
     */
    public void delete(int index){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*判断索引位置是否合法*/
        if(index>LENGTH || index <=0 ){
            System.out.println("错误：索引位置不合法");
            return ;
        }
        /*若未初始化打印异常*/
        if(ELEMENT == null){
            System.out.println("错误：线性表未初始化！");
            return ;
        }
        /*将索引位置为空*/
        ELEMENT[index-1] = null ;
        /*元素一次往前移*/
        for(int i=index-1 ; i<LENGTH ;i++){
            Object temp = ELEMENT[i] ;
            ELEMENT[i] = ELEMENT[i+1] ;
            ELEMENT[i+1] = temp ;
        }
        /*表长减一*/
        LENGTH-- ;
    }
    /**
     * @explain isEmpty方法:判断顺序表是否为空
     * @return boolean 空false 非空true
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:38:12
     */
    public boolean isEmpty(){
        /*表是否存在，若不存在显示错误*/
        boolean flag = true ;
        for(Object elem : ELEMENT){
            if(elem == null){
                flag = false ;
                break ;
            }
        }
        return flag ;
    }
    /**
     * @explain print方法: 遍历顺序表
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:39:05
     */
    public void print(){
        /*表是否存在，若不存在显示错误*/
        if(ELEMENT == null){
            System.out.println("错误：表不存在");
            return ;
        }
        /*遍历*/
        for(Object elem : ELEMENT){
            if(elem != null)
            System.out.print(elem + " ");
        }
        System.out.println();
    }
    /**
     * toString方法
     */
    public String toString(){
        String str = "SequenceList:[" ;
        for(int i=0 ; i<LENGTH ; i++){
            if(i==0 && ELEMENT[i] != null){
                str = str + ELEMENT[i] ;
            }else if(ELEMENT[i] != null)
            str = str+"," + ELEMENT[i] ;

        }
        str = str+"]" ;
        return str ;
    }
    /**
     * @explain extend方法: 扩充线性表
     * @throws 无
     * @author 叶清逸
     * @date 2018年7月20日 下午3:39:43
     */
    private void extend(){
        //扩充后的线性表
        Object [] newElement = new Object[CURRENTSIZE + INCREAMENT] ;
        //复制原有元素
        for(int i=0 ; i<LENGTH ; i++){
            newElement[i] = ELEMENT[i] ;
        }
        //改变指针指向
        ELEMENT = newElement ;
        //改变现在的顺序表规模
        CURRENTSIZE = CURRENTSIZE + INCREAMENT ;
    }

}