数据结构之数组(java语言中的常见代码操作)

简介：

计算机中一种用来连续储存相同类型数据的数据结构，可以完成增删改查等操作。接下来将会给出该数据结构相关操作的手动实现(java语言实现)和利用Java语言刷题过程中的常用操作。

数据结构的实现：

package DataStructures.array_;

/**
 * @author:
 * @data:
 * @description:
 */
public class GenericArray <T>{
    private T[] data;
    private int size;

    //根据传入容量，构造Array(带参构造)
    public GenericArray(int capacity) {
        data = (T[]) new Object[capacity];
        size = 0;
    }

    //无参构造方法，默认数组容量为10
    public GenericArray() {
        this(10);
    }

    //获取数组容量
    public int getCapacity() {
        return data.length;
    }

    //获取当前元素个数
    public int count() {
        return size;
    }

    //判断数组是否为空
    public boolean isEmpty() {
        return size == 0;
    }

    //修改index位置的元素
    public void set(int index, T e) {
        checkIndex(index);
        data[index] = e;
    }

    //获取对应index位置的元素
    public T get(int index) {
        checkIndex(index);
        return data[index];
    }

    //查看数组是否包含元素e
    public boolean contains(T e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return true;
            }
        }
        return false;
    }

    //获取对应元素的下标，否则返回-1
    public int find(T e) {
        for (int i = 0; i < size; i++) {
            if (data[i].equals(e)) {
                return i;
            }
        }
        return -1;
    }

    //在index位置处插入元素e，时间复杂度O(m + n)
    public void add(int index, T e) {
        checkIndexForAdd(index);
        //如果当前元素个数等于数组容量，则将数组扩容2倍
        if (size == 2 * data.length) {
            resize(2 * data.length);
        }
        
        //index位置后的元素先整体后移再插入
        for (int i = size - 1; i >= index; i--) {
            data[i + 1] = data[i];
        }
        //插入
        data[index] = e;
        //当前元素个数加1
        size++;
    }
    
    //数组头插入元素
    public void addFirst(T e) {
        add(0,e);
    }
    
    //数组的尾插入元素
    public void addLast(T e) {
        add(size,e);
    }
    
    //删除index位置的元素，并返回
    public T remove(int index) {
        checkIndexForAdd(index);
        //先记录删除的元素
        T result = data[index];
        //先将index后的元素整体向前移动一位
        for (int i = index + 1; i < size; i++) {
            data[i - 1] = data[i];
        }
        size--;
        //此时data数组size索引处为ko
        data[size] = null;
        
        //缩容
        if (size == data.length / 4 && data.length / 2 != 0) {
            resize(data.length / 2);
        }
        return result;
    }
    
    //删除第一个元素
    public T removeFirst() {
        return remove(0);
    }

    //删除末尾元素
    public T removeLast() {
        return remove(size - 1);
    }
    
    //从数组中删除指定元素
    public void removeElement(T e) {
        int index = find(e);
        if (index != -1) {
            remove(index);
        }
    }
    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append(String.format("Array size = %d, capacity = %d \n",size, data.length));
        builder.append('[');
        for (int i = 0; i < size; i++) {
            builder.append(data[i]);
            if (i != size - 1) {
                builder.append(", ");
            }
        }
        builder.append(']');
        return builder.toString();
    }
    //扩容方法，时间复杂度O(N)
    private void resize(int capacity) {
        T[] newData = (T[]) new Object[capacity];
        //数组值的拷贝
        for (int i = 0; i < size; i++) {
            newData[i] = data[i];
        }
        //指向新的数组
        data = newData;
    }
    private void checkIndex(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Add failed! Require index >= 0 and index <= size!");
        }
    }

    private void checkIndexForAdd(int index) {
        if (index < 0 || index > size) {
            throw new IllegalArgumentException("Remove failed! Require index >= 0 and index <= size!");
        }
    }
}

刷题中的常用操作：

package DataStructures.array_;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

/**
 * @author: ln
 * @data:
 * @description:
 */
public class ArrayTest {
    public static void main(String[] args) {
        // Four solutions to create an array in Java
        // Take [1,2,3] as example
        // Solution 1
        int[] a = {1,2,3};
        System.out.println("a " + Arrays.toString(a));

        // Solution 2
        int[] b = new int[]{1,2,3};
        System.out.println("b " + Arrays.toString(b));

        // Solution 3
        int[] c = new int[3];
        for (int i = 0; i < a.length; i++) {
            c[i] = i + 1;
        }
        System.out.println("c " + Arrays.toString(c));

        // Solution 4
        ArrayList<Integer> arr = new ArrayList<>();
        for (int i = 0 ; i < 3; i++) {
            arr.add(i+1);
        }
        // [1,2,3]
        System.out.println("arr: " + arr.toString());

        // Add element
        // Time Complexity: O(1)
        arr.add(99);
        // [1,2,3,88,99]
        System.out.println("arr: " + arr.toString());


        // Access element
        // Time Complexity: O(1)
        int c1 = c[1];
        int arr1 = arr.get(1);
        // 1
        System.out.println("c1: " + c1);
        System.out.println("arr1: " + arr1);

        // Update element
        // Time Complexity: O(1)
        c[1] = 11;
        arr.set(1,11);
        // 1 -> 11
        System.out.println("c1: " + c[1]);
        System.out.println("arr1: " + arr.get(1));

        // Remove element
        // Time Complexity: O(N)
        arr.remove(3);
        System.out.println("arr1: " + arr.get(1));

        // The length of an array
        // Time Complexity: O(1)
        int cSize = c.length;
        int arrSize = arr.size();
        System.out.println("c length: " + cSize);
        System.out.println("arr length: " + arrSize);

        // Iterate an array
        // Iterate c
        for (int i = 0; i < c.length; i++) {
            int current = c[i];
            System.out.println("c at index " + i + ": " + current);
        }

        // Iterate arr
        for (int i = 0; i < arr.size(); i++) {
            int current = arr.get(i);
            System.out.println("arr at index " + i + ": " + current);
        }

        // Find an element
        // Find an element in c
        for (int i = 0; i < c.length; i++) {
            if (c[i] == 99) {
                System.out.println("We found 99 in c!");
            }
        }

        // Find an element in arr
        boolean is99 = arr.contains(99);
        System.out.println("Are we found 99 in arr?" + is99);

        // Sort an array by built-in lib
        c = new int[]{2,3,1};
        arr = new ArrayList<>();
        arr.add(2);
        arr.add(3);
        arr.add(1);
        //[2,3,1]
        System.out.println("c: " + Arrays.toString(c));
        System.out.println("arr " + arr.toString());
        // from small to big
        // Time Complexity: O(NlogN)
        Arrays.sort(c);
        //[1,2,3]
        System.out.println("c: " + Arrays.toString(c));
        System.out.println("arr: " + arr.toString());
        // from big to small
        // Time Complexity: O(NlogN)
        // For c, you can read an array in reverse
        // Arrays.sort(T[], Collections.reverseOrder());
        //For arr
        Collections.sort(arr,Collections.reverseOrder());
        //[3,2,1]
        System.out.println("arr: " + arr);
    }
}