Java中一个基于数组的顺序表的增删查改

已于 2022-02-14 12:37:27 修改
阅读量250 收藏 1
点赞数
分类专栏： #java学习 文章标签： java 开发语言 后端
于 2022-02-13 20:41:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_46235384/article/details/122913663
版权

目录

定义一个数组

增  

在头部插入

在尾部插入

根据索引插入

给数组扩容

测试

删

删除头部元素

删除尾部元素

根据索引删除元素

测试

改

根据索引修改，返回修改前的元素值

测试 

查

根据元素值查询

根据索引查询

根据元素值查找对应的索引下标

测试 

toString()方法输出

全部代码

 

定义一个数组

public class MyArray {
    //数组存储元素
    private int[] data;
    //当前数组实际存储的元素个数
    private int size;

    /**
     * 根据传入的数组大小来开辟数组空间
     * @param capacity 传入数组的大小
     */
    public MyArray(int capacity){
        data = new int[capacity];
    }
}

增  

  • 在头部插入

 /**
     * 在数组的头部插入元素
     * @param val 传入的元素值
     */
    public void addFirst(int val){
        if (size == data.length){
            grow();
        }
        for (int i = size-1; i >= 0 ; i--) {
            data[i+1] = data[i];
        }
        data[0] = val;
        size++;
    }

  • 在尾部插入

 /**
     * 在数组的尾部插入元素
     * @param val 传入的元素值
     */
    public void addLast(int val){
        //先要判断数组是否满
        if(size == data.length){
            grow();
        }
        data[size] = val;
        size++;
    }

  • 根据索引插入

 /**
     * 根据索引来插入元素
     * @param index 索引
     * @param val 传入的元素
     */
    public void addIndex(int index,int val) {
        if (size == data.length) {
            grow();
        }
        if (index < 0 || index > size) {
            System.err.println("插入错误！");
            return;
        }
        if (index == 0) {
            addFirst(val);
            return;//如果没有return的话，会插入两次
        }
        if (index == size) {
            addLast(val);
        } else {
            for (int i = size - 1; i >= index; i--) {
                data[i + 1] = data[i];
            }
            data[index] = val;
            size++;
        }
    }

  • 给数组扩容

 private void grow(){
        int[] newData = Arrays.copyOf(this.data,this.data.length << 1);
        this.data =newData;
    }

  • 测试

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray(3);
        myArray.addLast(1);
        myArray.addLast(3);
        myArray.addLast(5);
        myArray.addLast(7);
        //[1,3,5,7]
        System.out.println(myArray);
        myArray.addFirst(10);
        //[10,1,3,5,7]
        System.out.println(myArray);
        myArray.addIndex(3,8);
        myArray.addIndex(0,9);
        myArray.addIndex(6,33);
        //[9,10,1,3,8,5,33,7]
        System.out.println(myArray);
    }
}

删

  • 删除头部元素

    /**
     * 删除头部元素
     */
    public void removeFirst(){
        for (int i = 0; i <= size-1 ; i++) {
            data[i] = data[i+1];
        }
        size--;
    }

  • 删除尾部元素

    /**
     * 删除尾部元素
     */
    public void removeLast(){

        removeIndex(size-1);
    }

  • 根据索引删除元素

/**
     * 根据索引删除元素
     * @param index
     */
    public void removeIndex(int index){
        if(index < 0 || index >= size){
            System.out.println("索引非法！");
            return;
        }
        for (int i = index; i < size ; i++) {
            data[i] = data[i+1];
        }
        size--;
    }

  • 测试

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray(3);
        myArray.addLast(1);
        myArray.addLast(3);
        myArray.addLast(5);
        myArray.addLast(7);
        //[1,3,5,7]
        System.out.println(myArray);
        myArray.addFirst(10);
        //[10,1,3,5,7]
        System.out.println(myArray);
        myArray.addIndex(3,8);
        myArray.addIndex(0,9);
        myArray.addIndex(6,33);
        //[9,10,1,3,8,5,33,7]
        System.out.println(myArray);

        myArray.removeIndex(0);
        myArray.removeIndex(2);
        myArray.removeIndex(5);
        //[10,1,8,5,33]
        System.out.println(myArray);
        myArray.removeFirst();
        myArray.removeLast();
        //[1,8,5]
        System.out.println(myArray);
    }
}

 

改

  • 根据索引修改，返回修改前的元素值

    /**
     * 根据索引修改，返回修改前的元素值
     * @param index
     * @param newVal
     * @return
     */
    public int set(int index,int newVal){
        if(index < 0 || index > size-1){
            System.out.println("索引非法！");
            return -1;
        }
        int oldVal = data[index];
        data[index] = newVal;
        return oldVal;
    }

  • 测试 

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray(3);

        myArray.addLast(1);
        myArray.addLast(3);
        myArray.addLast(5);
        myArray.addLast(7);
        //[1,3,5,7]
        System.out.println(myArray);
        myArray.addFirst(10);
        //[10,1,3,5,7]
        System.out.println(myArray);
        myArray.addIndex(3,8);
        myArray.addIndex(0,9);
        myArray.addIndex(6,33);
        //[9,10,1,3,8,5,33,7]
        System.out.println(myArray);

        myArray.removeIndex(0);
        myArray.removeIndex(2);
        myArray.removeIndex(5);
        //[10,1,8,5,33]
        System.out.println(myArray);
        myArray.removeFirst();
        myArray.removeLast();
        //[1,8,5]
        System.out.println(myArray);

        myArray.set(0,3);
        myArray.set(1,6);
        myArray.set(2,8);
        //[3,6,8]
        System.out.println(myArray);
    }
}

 

查

  • 根据元素值查询

/**
     * 根据元素值查询
     * @param val
     * @return
     */
    public boolean contains(int val){
        int index =getByVal(val);
        if(index == -1){
            return false;
        }
        return true;
    }

  • 根据索引查询

    /**
     * 根据索引查询
     * @param index
     * @return
     */
    public int getVal(int index){
        if(index < 0 || index > size-1){
            System.out.println("索引非法！");
        }
        return data[index];
    }

  • 根据元素值查找对应的索引下标

/**
     * 根据元素值查找对应的索引下标
     * @param val 输入的元素值
     * @return
     */
    public int getByVal(int val){
        for (int i = 0; i < size; i++) {
            if (data[i] == val){
                return i;
            }
        }
        System.out.println("该元素不存在！");
        return -1;//该元素不存在
    }

  • 测试 

/**
 * @author happy
 */
public class Test {
    public static void main(String[] args) {
        MyArray myArray = new MyArray(3);

        myArray.addLast(1);
        myArray.addLast(3);
        myArray.addLast(5);
        myArray.addLast(7);
        //[1,3,5,7]
        System.out.println(myArray);
        myArray.addFirst(10);
        //[10,1,3,5,7]
        System.out.println(myArray);
        myArray.addIndex(3,8);
        myArray.addIndex(0,9);
        myArray.addIndex(6,33);
        //[9,10,1,3,8,5,33,7]
        System.out.println(myArray);

        myArray.removeIndex(0);
        myArray.removeIndex(2);
        myArray.removeIndex(5);
        //[10,1,8,5,33]
        System.out.println(myArray);
        myArray.removeFirst();
        myArray.removeLast();
        //[1,8,5]
        System.out.println(myArray);

        myArray.set(0,3);
        myArray.set(1,6);
        myArray.set(2,8);
        //[3,6,8]
        System.out.println(myArray);

        //false
        //8
        //0
        System.out.println(myArray.contains(2));
        System.out.println(myArray.getVal(2));
        System.out.println(myArray.getByVal(3));
    }
}

 

toString()方法输出

public String toString() {
        String ret = "[";
        for (int i = 0; i < size; i++) {
            ret += data[i];
            if (i != size - 1) {
                ret += ",";
            }
        }
        ret += "]";
        return ret;
    }

全部代码

import java.util.Arrays;

/**
 * @author happy
 * 基于数组的顺序表
 */

public class MyArray {
    //数组存储元素
    private int[] data;
    //当前数组实际存储的元素个数
    private int size;

    /**
     * 根据传入的数组大小来开辟数组空间
     * @param capacity 传入数组的大小
     */
    public MyArray(int capacity){
        data = new int[capacity];
    }

    /**
     * 在数组的头部插入元素
     * @param val 传入的元素值
     */
    public void addFirst(int val){
        if (size == data.length){
            grow();
        }
        for (int i = size-1; i >= 0 ; i--) {
            data[i+1] = data[i];
        }
        data[0] = val;
        size++;
    }

    /**
     * 根据索引来插入元素
     * @param index 索引
     * @param val 传入的元素
     */
    public void addIndex(int index,int val) {
        if (size == data.length) {
            grow();
        }
        if (index < 0 || index > size) {
            System.err.println("插入错误！");
            return;
        }
        if (index == 0) {
            addFirst(val);
            return;//如果没有return的话，会插入两次
        }
        if (index == size) {
            addLast(val);
        } else {
            for (int i = size - 1; i >= index; i--) {
                data[i + 1] = data[i];
            }
            data[index] = val;
            size++;
        }
    }

    /**
     * 在数组的尾部插入元素
     * @param val 传入的元素值
     */
    public void addLast(int val){
        //先要判断数组是否满
        if(size == data.length){
            grow();
        }
        data[size] = val;
        size++;
    }

    /**
     * 删除头部元素
     */
    public void removeFirst(){
        for (int i = 0; i <= size-1 ; i++) {
            data[i] = data[i+1];
        }
        size--;
    }

    /**
     * 删除尾部元素
     */
    public void removeLast(){

        removeIndex(size-1);
    }

    /**
     * 根据索引删除元素
     * @param index
     */
    public void removeIndex(int index){
        if(index < 0 || index >= size){
            System.out.println("索引非法！");
            return;
        }
        for (int i = index; i < size ; i++) {
            data[i] = data[i+1];
        }
        size--;
        data[size] = 0;
    }

    /**
     * 根据索引修改，返回修改前的元素值
     * @param index
     * @param newVal
     * @return
     */
    public int set(int index,int newVal){
        if(index < 0 || index > size-1){
            System.out.println("索引非法！");
            return -1;
        }
        int oldVal = data[index];
        data[index] = newVal;
        return oldVal;
    }

    /**
     * 根据元素值查找对应的索引下标
     * @param val 输入的元素值
     * @return
     */
    public int getByVal(int val){
        for (int i = 0; i < size; i++) {
            if (data[i] == val){
                return i;
            }
        }
        return -1;//该元素不存在
    }

    /**
     * 根据元素值查询
     * @param val
     * @return
     */
    public boolean contains(int val){
        int index =getByVal(val);//
        if(index == -1){
            return false;
        }
        return true;
    }

    /**
     * 根据索引查询
     * @param index
     * @return
     */
    public int getVal(int index){
        if(index < 0 || index > size-1){
            System.out.println("索引非法！");
        }
        return data[index];
    }

    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 grow(){
        int[] newData = Arrays.copyOf(this.data,this.data.length << 1);
        this.data =newData;
    }

}

 

学习java的张三
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

学习java的张三

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值