算法大法之--顺序表

要点

顺序表是在计算机内存中以数组的形式保存的线性表，是指使用一组地址连续的存储单元依次存储数据元素的线性结构。

顺序表的存储结构可表示如下：

/**
 * 简单线性表的数组实现 -- 顺序表
 * Created by www.javamanual.cn on 2017/7/11
 */
public class MyArrayList {
    private static final int DEFAULT_SIZE = 10;
    private int size = 0; // 容量大小
    private Object[] value; // 存放元素的容器

    /**
     * 初始化大小，默认10 ； JDK1.8中 ArrayList 实现的默认大小也是10
     */
    public MyArrayList(){
        value = new Object[DEFAULT_SIZE];
    }
    /**
     * 指定初始化容器大小
     * @param length
     */
    public MyArrayList(int length){
        if(length > 0)
            value = new Object[length];
        else
            value = new Object[DEFAULT_SIZE];
    }
}

基本算法

---

插入数据元素

在顺序表的第 index(0≤index≤size)个位置上插入新的元素e。

如果 index值不正确，则返回false；

否则，讲顺序表中原来第 index个元素及以后元素均后移一个位置，腾出一个空位置插入新元素，并且顺序表长度增1。

    // 添加元素 将数据添加到指定位置
    boolean add(Object data , int index){
        // 判断位置是否合法
        if(index < 0 || index > size)
            return false;
        // 将value[index]及后面的元素都向后移动一个位置
        for(int i = size-1 ; i >= index ; i--){
            value[i+1] = value[i];
        }
        // 全部移动完之后，将数据插入到index位置
        value[index] = data;
        size++;
        return true;
    }

    // 添加元素 默认添加到尾部
    void add(Object data){
        if(data == null) return;
        if(value.length == size){
            // 数组存满了，重构数组
            Object[] newValue = new Object[value.length * 2]; // 扩充到原来的二倍
            for (int i = 0 ; i < value.length ; i++) {
                newValue[i] = value[i];
            }
            value = newValue;
            System.out.println("数组存满了，重构数组。当前线性表大小："+value.length);
        }
        // 未满，直接放到尾部
        value[size++] = data;
    }




删除数据元素
删除顺序表中的第 index(0≤index≤size-1)个元素。
如果 index值不正确，则返回null；
否则，将顺序表中的第 index个元素以后的元素均向前移动一个位置，这样覆盖了原来的第
 index个元素，并且顺序表长度减1。

    // 清空表
    void clear(){
       if(size > 0){
           for (int i = 0 ; i<size ; i++ ){
               value[i] = null;
           }
           size = 0;
       }
    }

    // 删除指定位置的元素
    Object delete(int index){
        if(index<0 && index > size){
            System.err.println("没有那么多元素 当前线性表中元素个数为："+size);
            return null;
        }
        Object data = value[index];
        for (int i = index ; i<size ; i++){
            value[i] = value[i+1];
        }
        value[--size] = null;
        return data;
    }

    // 删除指定的元素
    Object delete(Object data){
        int index = findIndex(data);
        if(index > 0) return delete(index);
        return data;
    }




参考代码

 
 

以下为本人实现的顺序表的基本操作。欢迎指正。本人的编译环境为JDK1.8，Java语言。


[顺序表操作]




[1] 初始化一个顺序表

   /**
     * 初始化大小，默认10 ； JDK1.8中 ArrayList 实现的默认大小也是10
     */
    public MyArrayList(){
        value = new Object[DEFAULT_SIZE];
    }
    /**
     * 指定初始化容器大小
     * @param length
     */
    public MyArrayList(int length){
        if(length > 0)
            value = new Object[length];
        else
            value = new Object[DEFAULT_SIZE];
    }





[2] 根据数组 elems 构建一个顺序表

    /**
     * 根据数组elems[]创建一个顺序表
     * @param elems
     * @return
     */
    public MyArrayList(Object elems[]){
        if(elems == null || elems.length == 0)
            value = new Object[DEFAULT_SIZE];
        else
            value = new Object[elems.length];
        for (int i = 0 ; i < elems.length ; i++){
            value[size++] = elems[i];
        }
    }





[3] add(Object data , int index),在顺序表中第 index 个位置插入元素 data

    // 添加元素 将数据添加到指定位置
    boolean add(Object data , int index){
        // 判断位置是否合法
        if(index < 0 || index > size)
            return false;
        // 将value[index]及后面的元素都向后移动一个位置
        for(int i = size-1 ; i >= index ; i--){
            value[i+1] = value[i];
        }
        // 全部移动完之后，将数据插入到index位置
        value[index] = data;
        size++;
        return true;
    }



[4] Object delete(int index),在顺序表中移除第 index 个元素，并返回其值

    // 删除指定位置的元素
    Object delete(int index){
        if(index<0 && index > size){
            System.err.println("没有那么多元素 当前线性表中元素个数为："+size);
            return null;
        }
        Object data = value[index];
        for (int i = index ; i<size ; i++){
            value[i] = value[i+1];
        }
        value[--size] = null;
        return data;
    }



[5] Objecr findData(int index),获取顺序表上位置为 index 的元素，并返回其值

    // 获取指定位置的数据
    Object findData(int index){
        // 起始位置是0
        if(index >= size || index < 0){
            System.err.println("数组越界了");
            return null;
        }
        return value[index];
    }





[6] int findIndex(Object data),获取元素 data在顺序表上第一次出现的位置，如果不存在返回 -1

    // 获取元素所在表中的位置
    int findIndex(Object data){
        for(int i = 0 ; i< size ; i++){
            if(value[1] != null && value[i].equals(data))
                return i;
        }
        return -1;
    }





[7] printList, 打印整个顺序表

    // 打印表中的数据
    void printList(){
        for (int i =0 ; i<size ; i++ ) {
            System.out.print(value[i] +" , ");
        }
        System.out.println();
    }