数据结构（JAVA）顺序表

---

#1024程序员节｜征文#

1. 线性表

线性表（linear list）是n个具有相同特性的数据元素的有限序列。 线性表在逻辑上是线性结构，也就说是连续的一条直线。但是在物理结构上并不一定是连续的。

2.顺序表

顺序表是用一段物理地址连续的存储单元依次存储数据元素的线性结构，
一般情况下采用数组存储。在数组上完成数据的增删查改。

2.1 顺序表接口实现

我们自己先来实现顺序表（以int类型为例）

public class ArrayList {
    
    
    private int[] elem;
    private int usedSize;
    // 默认构造方法
    public ArrayList(){
    
    }
    // 将顺序表的底层容量设置为initcapacity
    public ArrayList(int initcapacity){
    
    }
    // 新增元素,默认在数组最后新增
    public void add(int data) {
    
    }
    // 在 pos 位置新增元素
    public void add(int pos, int data) {
    
    }
    // 判定是否包含某个元素
    public boolean contains(int toFind) {
    
     return true; }
    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
    
     return -1; }
    // 获取 pos 位置的元素
    public int get(int pos) {
    
     return -1; }
    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
    
    }
    //删除第一次出现的关键字key
    public void remove(int toRemove) {
    
    }
    // 获取顺序表长度
    public int size() {
    
     return 0; }
    // 清空顺序表
    public void clear() {
    
    }
}
//下标不合法异常  下面要使用到
public class PosIllegal extends RuntimeException {
    
    
    public PosIllegal() {
    
    

    }
    public PosIllegal(String msg) {
    
    
        super(msg);
    }
}
//空异常  下面要使用到
public class EmptyException extends RuntimeException{
    
    
    public EmptyException() {
    
    

    }
    public EmptyException(String msg) {
    
    
        super(msg);
    }
}

2.1.1默认构造方法

我们先开辟10个数组空间。

    private static final int DEFALUT_SIZE = 10;
    // 默认构造方法
    public ArrayList() {
    
    
        this.elem = new int[DEFALUT_SIZE];
    }

2.1.2将顺序表的底层容量设置为initcapacity

传入参数，实现数组长度。

    // 将顺序表的底层容量设置为initcapacity
    public  ArrayList(int initcapacity){
    
    
        this.elem = new int[initcapacity];
    }

2.1.3尾插
传入尾插的数据，并实行插入。
注意事项：

1. 顺序表是否已满，如果已满就扩容。
2. 元素加一（usedSize++）。

    //判断顺序表是否满了
    private boolean isFull() {
    
    
        return usedSize == elem.length;
    }
    //顺序表扩容
    private void grow() {
    
    
        this.elem = Arrays.copyOf(elem,2*elem.length);
    }
    // 新增元素,默认在数组最后新增
    public void add(int data) {
    
    
        //判满 + 扩容
        if(isFull()) {
    
    
            grow();
        }
        this.elem[this.usedSize] = data;
        usedSize++;
    }

2.1.4在pos位置插入
传入pos下标和data数据，并在pos位置插入。
注意事项：

1. 顺序表是否已满，如果已满就扩容。
2. 元素加一（usedSize++）。
3. 判断pos下标是否合法。
4. 一定要从末尾开始遍历到pos位置，如果从pos位置开始遍历会数据覆盖。

    //判断下标是否合法
    private void getPosIsLegitimate (int pos) throws PosIllegal{
    
    
        if (pos < 0 || pos >= usedSize) {
    
    
            throw new PosIllegal("Pos不合法");
        }
    }
    // 在 pos 位置新增元素
    public void add(int pos, int data) {
    
    
        try{
    
    
            getPosIsLegitimate(pos);
            //判满 + 扩容
            if(isFull()) {
    
    
                grow();
            }
            for(int i = elem.length-1;i > pos;i--) {
    
    
                this.elem[i+1] = elem[i];
            }
            this.elem[pos] = data;
            usedSize++;
        }catch(PosIllegal e) {
    
    
            System.out.println("pos下标不合法");
            e.printStackTrace();
        }
    }

2.1.5判定是否包含某个元素
遍历数组，观察数组中是否包含传入的参数（toFind），如果有返回true，否则返回法false。

    // 判定是否包含某个元素
    public boolean contains(int toFind) {
    
    
        for(int i = 0;i < elem.length;i++) {
    
    
            if(this.elem[i] == toFind) {
    
    
                return true;
            }
        }
        return false;
    }

2.1.6查找某个元素对应的位置
遍历数组，观察数组中是否包含传入的参数（toFind），如果有返回下标 i，否则返回法 -1。

    // 查找某个元素对应的位置
    public int indexOf(int toFind) {
    
    
        for(int i = 0;i < elem.length;i++) {
    
    
            if(this.elem[i] == toFind) {
    
    
                return i;
            }
        }
        return -1;
    }

2.1.7获取 pos 位置的元素
查找pos下标，并返回下标pos的值。
注意事项：

1. 检查顺序表是否为空。
2. 判断pos下标是否合法。

    //判断顺序表是否为空
    private void checkEmpty() {
    
    
        if(isEmpty()) {
    
    
            throw new EmptyException("顺序表为空!!!");
        }
    }

    // 获取 pos 位置的元素
    public int get(int pos) {
    
    
        try {
    
    
            checkEmpty();
            getPosIsLegitimate(pos);
            return elem[pos];
        }catch (PosIllegal e) {
    
    
            e.printStackTrace();
        }catch (EmptyException e) {
    
    
            e.printStackTrace();
        }
        return -1;
    }

2.1.8给 pos 位置的元素设为 value
将pos下标的元素更改为value。
注意事项：

1. 检查顺序表是否为空。
2. 判断下标是否合法。

    // 给 pos 位置的元素设为 value
    public void set(int pos, int value) {
    
    
        try {
    
    
            checkEmpty();
            getPosIsLegitimate(pos);
            elem[pos] = value;
        }catch (PosIllegal e) {
    
    
            e.printStackTrace();
        }catch (EmptyException e) {
    
    
            e.printStackTrace();
        }
    }

2.1.9删除第一次出现的关键字key
将第一次出现的关键字key删除。
注意事项：

1. 检查顺序表是否为空。
2. 判断下标是否合法。
3. 元素减一（usedSize–）。

    //删除第一次出现的关键字key
    public void remove(int toRemove) {
    
    
        try {
    
    
            checkEmpty();
            int pos = indexOf(toRemove);
            if(pos == -1) {
    
    
                return;
            }
            else {
    
    
                for(int i = pos;i < elem.length-1;i++) {
    
    
                    elem[i] = elem[i+1];
                }
                usedSize--;
            }
        }catch (EmptyException e) {
    
    
            e.printStackTrace();
        }
    }

2.1.10 获取顺序表长度
获取顺序表长度就是获取顺序表元素的个数，即usedSize。

    // 获取顺序表长度
    public int size() {
    
    
        return usedSize;
    }

2.1.11清空顺序表
将所用元素置为零，并将usedSize置为零。
注意事项：

1. 顺序表源码是存储泛型的，源码清空顺序表，是将所用元素置为空，而这里我们以整形为例，所以置为零。

    // 清空顺序表
    public void clear() {
    
    
        for(int i = 0;i < elem.length;i++) {
    
    
            elem[i] = 0;
        }
        this.usedSize = 0;
    }

3. ArrayList

在JAVA 中的ArrayList类表示顺序表。

说明：

1. ArrayList实现了RandomAccess接口，表明ArrayList支持随机访问
2. ArrayList实现了Cloneable接口，表明ArrayList是可以clone的
3. ArrayList实现了Serializable接口，表明ArrayList是支持序列化的
4. ArrayList底层是一段连续的空间，并且可以动态扩容，是一个动态类型的顺序表

3.1ArrayList的构造方法

ArrayList的三种构造方法如下：

3.2ArrayList的常用方法

ArrayList的常用方法如下:

4.ArrayList的优缺点

4.1优点

给定下标，查询速度很快。

4.2缺点

1. 插入，删除速度慢。
2. 扩容，会造成空间浪费。