xbhog

数组基础:

导读:

开始放寒假,准备开一篇数据结构与算法的汇总,记录这枯燥的寒假学习;

话不多说,先从数组搞起;

希望能坚持下去!

数组的基本使用:

首先对于数组,我们需要知道它基础的规则与运用;

public static void main(String[] args) {
//        创建一个数组
        int[] num = new int[3];
//        获取数组长度
        int length1 = num.length;
        System.out.println("数组长度:"+length1);
//       为数组中的元素赋值
        num[0]=99;
        num[1]=98;
        num[2]=97;
//        遍历数组
        for (int i=0;i<length1;i++){
            System.out.printf("数组元素[%d]:%d",i,num[i]);
        }
        System.out.println();
//        创建数组的时候直接赋值
        int[] arr = {99,98,97,22};
        System.out.println("arr lenght:"+arr.length);
    }

数组的元素添加:

当了解基础的数组知识时,我们需要在数组的添加、删除、插入、查询上下功夫;

public static void main(String[] args) {
//        解决数组长度不可变的问题
        int[] arr = {9,8,7};
//        快速查看数组中的元素
        System.out.println(Arrays.toString(arr));
//        要加入的元素
        int dst = 6;
//        创建一个新的数组,长度是原来数组长度+1
        int[] newArr = new int[arr.length+1];
//        把原来数组中的数据全部添加到新的数组中
        for(int i=0;i<arr.length;i++){
            newArr[i] = arr[i];
        }
        System.out.println(Arrays.toString(newArr));
//        把目标元素放入新数组的最后
        newArr[arr.length] = dst;
//        新数组替换原来数组
        arr = newArr;
        System.out.println(Arrays.toString(arr));
    }

数组的元素删除:

public static void main(String[] args) {
//        目标数组
        int[] arr = {9,8,7,6,5,4};
//        要删除数组的下标
        int dst = 0;
        System.out.println(Arrays.toString(arr));
//        创建一个新的数组,长度为原来数组长度-1
        int[] newarr  = new int[arr.length-1];
//        赋值原数组出来要删除的那个元素以外其他的元素
        for(int i=0;i<newarr.length;i++){
//            要删除的元素之前的元素
            if(i<dst){
                newarr[i] = arr[i];
            }else{
//                要删除的元素之后的元素
                newarr[i] = arr[i+1];
            }
        }
//        新数组替换旧数组
        arr = newarr;
        System.out.println(Arrays.toString(arr));

    }

数组的元素插入:

public static void main(String[] args) {
//        目标数组
        int[] arr = {1,3,2,4,5,8};
        System.out.println(Arrays.toString(arr));
//        需要插入元素的位置
        int dst = 2;
//        插入新的元素
        int data = 99;
//        新的数组
        int[] newarr = new int [arr.length+1];

        for (int i=0;i<arr.length;i++){
            if (i <dst){
                newarr[i] = arr[i];
            }else{
                newarr[i+1] = arr[i];
            }
        }
        newarr[dst] = data;
        arr = newarr;
        System.out.println(Arrays.toString(arr));

    }

以上实例没有做过多的解释,如果有Java基础的话,还是很好理解的;

针对以上学习的知识,我们实现一个简易版的增删改查;

数组升级版:

构造函数部分:

package JavaDataStructure.arrayUpgrade;
import java.util.Arrays;
public class MyArray {
    private int[] array;
//    初始化数组
    public  MyArray() {
        array = new int[0];
    }
//    获取数组长度方法
    public int getLength(){
        return array.length;
    }
//    查看数组信息
    public void show(){
        System.out.println(Arrays.toString(array));
    }
//    向数组末尾添加数据
    public void add(int data){
//        申请一个新的数组,长度比原数组长度+1
        int[] newarr = new int[array.length+1];
//        将原数组中的数据全部保存到新的数组中
        for(int i=0;i<array.length;i++){
            newarr[i] = array[i];
        }
//        将添加的数据加到新数组的最后,原数组的长度大小刚好时最后一个数据的位置
        newarr[array.length] = data;
        array = newarr;
    }
//    查找数组中的元素下标
    public int search(int data){
        int index=-1;
        for (int i=0;i<array.length;i++){
            if(array[i]==data){
                index=i;
            }
        }
        return index;
    }
//    删除数组中的数据
    public void delete(int data){
        int index=search(data);
//        检查数组是否有数据
        if(index<0 || index>array.length-1){
//        异常提醒
            throw new RuntimeException("下标越界!");
        }
//        申请一个新的数组
        int[] newarr = new int[array.length-1];
        for (int i=0;i<newarr.length;i++){
            if (i<index){
                newarr[i] = array[i];
            }else{
//                想要删除元素的后面元素
                newarr[i] = array[i+1];
            }
        }
//        新数组替换旧数组
        array = newarr;
    }
    public void insert(int index,int data){
        int[] newarr = new int[array.length+1];
//        将原数组中的元素放入新数组中
        for (int i=0;i<array.length;i++){
//            将插入下标之前的元素放入新数组中
            if (i<index){
                newarr[i] = array[i];
            }else{
//                将插入下标之后的元素放入新数组,放之前需要留出一个位置
                newarr[i+1] = array[i];
            }

        }
//        插入新元素
        newarr[index] = data;
//        新数组替代旧数组
        array = newarr;

    }
//		替换元素
    public void set(int index,int data){
        if(index<0 || index >array.length){
            throw new RuntimeException("下标越界!");
        }
        array[index-1] = data;
    }
}

测试函数部分:

package JavaDataStructure.arrayUpgrade;
import JavaDataStructure.arrayUpgrade.MyArray;
public class TestMyarray {
    public static void main(String[] args) {
//        实例化数组对象
        MyArray ma = new MyArray();
//      向数组末尾添加数据
        ma.add(3);
        ma.add(2);
        ma.add(11);
//        显示数组中的元素
        ma.show();
//        显示查找元素的下标
//        System.out.println(ma.search(4));
//        显示当前数组大小
        System.out.println(ma.getLength());
//        删除操作
        ma.delete(2);
        ma.show();
//        插入操作
        ma.insert(0,4);
        ma.insert(2,42);
        ma.show();
//        替换指定位置的元素
        ma.set(4,33);
        ma.show();
    }
}

结束:

每天进步一点点,希望各位有所收获.....

相关文章: