Java数据结构-顺序表与ArrayList

猫大仙ovo

已于 2024-07-10 19:07:33 修改

阅读量707

点赞数 21

文章标签：数据结构

于 2024-07-10 19:05:18 首次发布

本文链接：https://blog.csdn.net/daweidi/article/details/140327044

版权

顺序表

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

数据表，其实就是一个数组。

数据表的实现

首先，创建一个接口，里面包含了顺序表中的方法。

public interface LList {
    // 新增元素,默认在数组最后新增
    void add(int data);
    // 在 pos 位置新增元素
    void add(int pos, int data);
    // 判定是否包含某个元素
    boolean contains(int toFind);
    // 查找某个元素对应的位置
    int indexOf(int toFind);
    // 获取 pos 位置的元素
    int get(int pos);
    // 给 pos 位置的元素设为 value -> 更新
    void set(int pos, int value);
    //删除第一次出现的关键字key
    void remove(int toRemove);
    // 获取顺序表长度
    int size();
    // 清空顺序表
    void clear();
    
    // 打印顺序表，
    // 注意：该方法并不是顺序表中的方法，为了方便看测试结果给出的
    void display();

    boolean isFull();
}

然后，创建一个类并调用该接口，重写接口中的方法

public class MyArrayList implements LList{
    //创建数组并进行初始化
    public int[] arr;
    public int usedSize;
    public MyArrayList(){
        this.arr = new int[10];
    }
    @Override
    public void add(int data) {
        
    }

    @Override
    public void add(int pos, int data) {

    }

    @Override
    public boolean contains(int toFind) {
        return false;
    }

    @Override
    public int indexOf(int toFind) {
        return 0;
    }

    @Override
    public int get(int pos) {
        return 0;
    }

    @Override
    public void set(int pos, int value) {

    }

    @Override
    public void remove(int toRemove) {

    }

    @Override
    public int size() {
        return 0;
    }

    @Override
    public void clear() {

    }

    @Override
    public void display() {

    }

    @Override
    public boolean isFull() {
        return false;
    }
}

然后依次实现方法：

（1）新增方法：

首先调用 isFull() 方法判断数组是否满了，如果满了则进行扩容操作，然后将数据放到数组最后位置上（即usedSize位置），最后将usedSize++；

isFull方法：

public boolean isFull() {
        //数组长度和useSize大小相等则表示数组已满
        return arr.length==usedSize;
    }

add方法：

public void add(int data) {
        if(isFull()){
            //扩容
            arr = Arrays.copyOf(arr,2*arr.length);
        }
        this.arr[usedSize++] = data;
    }

在pos位置add：

首先检查pos位置合法性：

public class PosNotLegalException extends RuntimeException{
    public PosNotLegalException(){

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

public void checkPosofAdd(int pos) throws PosNotLegalException{
        if(pos<0||pos>usedSize){
            throw new PosNotLegalException("pos位置不合法");
        }
    }

public void add(int pos, int data) {
        //判断pos是否合法
        try{
            checkPosofAdd(pos);
        }catch (PosNotLegalException e){
            e.printStackTrace();
        }
        //判断是否需要扩容
        if(isFull()){
            //扩容
            arr = Arrays.copyOf(arr,2*arr.length);
        }
        //将pos位置后的数据都往后挪一位
        for (int i = usedSize-1; i >= pos; i++) {
            arr[i+1] = arr[i];
        }
        //在pos位置插入元素
        this.arr[pos] = data;
        usedSize++;
    }

（2）查找方法：

// 判定是否包含某个元素
    @Override
    public boolean contains(int toFind) {
        //遍历数组查找
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==toFind){
                return true;
            }
        }
        return false;
    }
    // 查找某个元素对应的位置
    @Override
    public int indexOf(int toFind) {
        //遍历数组查找
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]==toFind){
                return i;
            }
        }
        return -1;
    }

（3）获取 pos 位置的元素:

public int get(int pos) {
        try{
            checkPosGetSet(pos);
        }catch(PosNotLegalException e){
            e.printStackTrace();
        }
        return arr[pos];
    }
    private void checkPosGetSet(int pos) throws PosNotLegalException{
        if(pos<0||pos>=usedSize){
            throw new PosNotLegalException("get/set,pos位置不合法");
        }
    }

（4）修改pos位置元素

public void set(int pos, int value) {
        try{
            checkPosGetSet(pos);
        }catch(PosNotLegalException e){
            e.printStackTrace();
        }
        arr[pos] = value;
    }

（5）删除第一次出现的关键字key

public void remove(int toRemove) {
        //查找是否存在要删除的数据，有则获取下标
        int ret = indexOf(toRemove);
        if(ret==-1){
            System.out.println("要删除的数据不存在");
            return;
        }
        //将ret后面的数据往前移动一位，覆盖掉ret位置
        for (int i = ret; i < arr.length-1; i++) {
            arr[i] = arr[i+1];
        }
        usedSize--;
    }

（6）获取顺序表长度清空顺序表

public int size() {
        return usedSize;
    }
public void clear() {
        usedSize=0;
    }

ArrayList

ArrayList是Java中提供的一种动态数组实现的顺序表。它是基于数组实现的，可以通过索引直接访问元素，同时具备动态扩容的特性，允许在运行时自动调整容量。

ArrayList的主要特点有：

动态扩容：ArrayList内部会维护一个数组，当元素个数超过当前数组容量时，会自动进行扩容。扩容时会创建一个更大的数组，并将原数组中的元素复制到新数组中。
线性访问：通过索引访问元素的时间复杂度为O(1)，即可实现快速随机访问。
支持元素的添加和删除：ArrayList提供了丰富的API方法，可以方便地进行元素的添加、删除和修改操作，如add()、remove()、set()等。
支持泛型：ArrayList是泛型类，可以存储任意类型的元素，也可以在声明时指定特定的元素类型，增加了类型安全性。
不支持基本数据类型：ArrayList只能存储对象类型，不支持基本数据类型。如果需要存储基本数据类型，可以使用其对应的包装类。

ArrayList的构造

方法	解释
ArrayList()	创建一个空的ArrayList对象，默认初始容量为10。
ArrayList(int initialCapacity)	创建一个空的ArrayList对象，并指定初始容量
ArrayList(Collection<? extends E> c)	创建一个ArrayList对象，并将指定集合中的元素添加到该ArrayList中

// 创建一个空的ArrayList对象
ArrayList<String> list1 = new ArrayList<>();

// 创建一个初始容量为20的ArrayList对象
ArrayList<Integer> list2 = new ArrayList<>(20);

// 创建一个ArrayList对象，并将指定集合中的元素添加到该ArrayList中
List<Integer> list33= new ArrayList<>();
list33.add("1");
list33.add("2");
ArrayList<String> list3 = new ArrayList<>(list33);

注意：避免省略类型，否则：任意类型的元素都可以存放，使用时将是一场灾难。

ArrayList常用方法

方法	解释
boolean add(E e)	尾插 e
void add(int index, E element)	将 e 插入到 index 位置
boolean addAll(Collection c)	尾插 c 中的元素
E remove(int index)	删除 index 位置元素
boolean remove(Object o)	删除遇到的第一个 o
E get(int index)	获取下标 index 位置元素
E set(int index, E element)	将下标 index 位置元素设置为 element
void clear()	清空
boolean contains(Object o)	判断 o 是否在线性表中
int indexOf(Object o)	返回第一个 o 所在下标
int lastIndexOf(Object o)	返回最后一个 o 的下标
List subList(int fromIndex, int toIndex)	截取部分 list
toArray()	将列表转换为数组