【Java学习—(10)顺序表，动态数组的创建及增删改查】

前面的章节知识(点击跳转即可哦)

1 数据类型

2 类型转换

3 运算符

4 逻辑控制

5 输入输出

6 方法的使用

方法递归

7 数组的定义与使用

8 类和对象 -上

8 类和对象-下

9 时间复杂度和空间复杂度

---

10 顺序表和链表

10.1 线性表

线性表：是n个具有相同特性的数据元素的有限序列。线性表是一种在实际中广泛使用的数据结构，常见的线性表：顺序表、链表、栈、队列、字符串等。

线性表在逻辑上是线性结构，也就是连续的一条直线。但是在物理结构上不一定是连续的，线性表在物理上存储时，通常以数组和链式结构的形式存储。

所谓的线性表，就是多个相同数据类型元素逻辑上呈直线排列，逻辑上连续。就把这种结构称为线性表。

逻辑连续：就是他们的先后顺序是逻辑上的先后。物理上不一定连续。

比如，1，2，3，4 1肯定在4 的前面，但是实际存储时，4 的前面不一定是1.

顺序表

动态数组的创建及增删改查

package dynamic_array;

import java.util.Arrays;

/**
 * data         存放元素的数组
 * size         存放的元素个数
 * add方法        增加元素
 * expand方法     数组的扩容
 */
public class Data {
    //存放数据的数组data
    private int[] data;
    //数组内存储的元素个数
    private int size;

    //构造方法，初始化数组的大小
    public Data(){
        this(5);
    }
    public Data(int num){
        this.data = new int[num];
    }

    //toString 方法，查看数组内部的元素
    @Override
    public String toString() {
        String ret = "[";
        for (int i = 0; i < size; i++) {
            ret += data[i];
            if(i != size-1){
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

    //数组的扩容
    private void expand(){
        this.data = Arrays.copyOf(data,data.length*2);
        //System.out.println("扩容成功");
    }

    //数组元素增加
    public void add(int addnum){
        data[size] = addnum;
        size++;
        //判断存放的元素是否等于数组的大小
        if(size == data.length){
            expand(); //扩容
        }
    }


    //元素的查找
    //1. 查询下标为 index 的元素是多少,返回值为-1，则查询下标不在存储元素范围内
    public int findIndex(int index){
        //判断索引是否合法
        if(index < 0 || index >= size){
            //System.out.println("下标不合法");
            return -1;
        }
        return data[index];
    }
    //2. 查询数字 n 是否在数组内，在数组内的第一个n下标为多少。返回值为-1，表示没有数字n
    public int findNum(int n){
        for (int i = 0; i < size; i++) {
            if(data[i] == n){
                return i;
            }
        }
        return -1;
    }

    //数字的插入
    //在数组的第几个元素(不是索引)的位置插入数字n，
    public void insert(int location, int num){
        if(location-1 < 0 || location-1 > size-1){
            System.out.println("超出存储的范围");
            return;
        }
        for (int i = size-1; i >= location-1 ; i--) {
            data[i+1] = data[i];
        }
        data[location-1] = num;
        System.out.println("插入成功");
        size++;
        expand();
        //System.out.println(this); //打印数组
    }

    //删除操作
    //1 删除索引index位置的元素,返回删除元素的值,返回值为-1，索引不合法
    public int delIndex(int index){
        if(index < 0 || index >= size){
            //System.out.println("下标不合法");
            return -1;
        }
        int oldNum = data[index];
        for (int i = index; i < size-1; i++) {
            data[i] = data[i+1];
        }
        size--;
        System.out.println("删除成功");
        //System.out.println(this);  // 打印数组
        return oldNum;
    }
    //2 删除首元素
    public int delFirst(){
        return delIndex(0);
    }
    //3 删除尾元素
    public int delLast(){
        return delIndex(size-1);
    }
    //4 删除第一个值为num 的元素，返回是否删除成功
    public boolean delNum(int num){
        int index = findNum(num);
        if(index == -1){
            System.out.println("没有这个数");
            return false;
        }
        delIndex(index);
        return true;
    }
    //5 删除所有值为num 的元素，返回是否删除成功
    public boolean delAllNum(int num){
        boolean ret = false;
        while (findNum(num)!= -1){
            int index = findNum(num);
            for (int i = index; i < size-1; i++) {
                data[i] = data[i+1];
            }
            size--;
            ret = true;
        }
        return ret;
    }

    //修改data数组中的元素
    //1 修改索引下标的元素,返回修改前的元素
    public int setIndex(int index,int num){
        if(index < 0 || index >= size){
            //System.out.println("下标不合法");
            return -1;
        }
        int oldNum = data[index];
        data[index] = num;
        return oldNum;
    }
    //2 找到数组中的数字 n,进行修改,返回-1，说明没有这个数
    public int setNum(int oldNum,int newNum){
        int index = findNum(oldNum); //调用查找方法
        if(index != -1){
            data[index] = newNum;
            return oldNum;
        }
        return -1;
    }
    //3 修改最后一个数，
    public int setLastNum(int newNum){
        return setIndex(size-1,newNum);
    }
}

对于这步， “删除所有值为num 的元素，返回是否删除成功”
可以进行优化，使用双引用的方法来写。

    public boolean delAllNum(int num){
        if(findNum(num) == -1){
            return false;
        }
        int fir = 0;
        int sec = 0;
        while (sec < size){
            if(data[sec] != num){
                data[fir] = data[sec];
                fir++;
            }
            sec++;
        }
        size = fir;
        return true;
    }

---

要是对大家有所帮助的话，请帮我点个赞吧。