数据结构：数组

静态数组

数组是一种线性数据结构，其中所有元素按顺序排列。它是存储在连续内存位置的相同数据类型元素的集合。

初始化

public class array {
    private t[] self;
    private int size;
    @suppresswarnings("unchecked")
    public array(int size) {
        if (size <= 0) {
            throw new illegalargumentexception("invalid array size (must be positive): " + size);
        } else {
            this.size = size;
            this.self = (t[]) new object[size];
        }
    }
}

在核心数组类中，我们将存储数组的大小和数组初始化的一般框架。在构造函数中，我们要求数组的大小并创建一个对象并将其类型转换为我们想要的数组。

设置方法

public void set(t item, int index) {
        if (index >= this.size || index < 0) {
            throw new indexoutofboundsexception("index out of bounds: " + index);
        } else {
            this.self[index] = item;
        }
    }

此方法要求将一个项目存储在数组中，并要求存储哪个项目的索引。

获取方法

public t get(int index) {
        if (index >= this.size || index < 0) {
            throw new indexoutofboundsexception("index out of bounds");
        } else {
            return self[index];
        }
    }

get 方法请求索引并从该索引检索项目。

打印方式

public void print() {
        for (int i = 0; i < size; i++) {
            system.out.println(this.self[i]+" ");
        }
    }

print 方法只是将数组的所有成员打印在一行中，每个项目之间用空格分隔。

排序数组

数组，但具有对元素本身进行排序的功能。

初始化

public class sortedarray> {
    private t[] array;
    private int size;
    private final int maxsize;
    @suppresswarnings("unchecked")
    public sortedarray(int maxsize) {
        if (maxsize <= 0) {
            throw new illegalargumentexception("invalid array max size (must be positive): " + maxsize);
        }
        this.array = (t[]) new comparable[maxsize];
        this.size = 0;
        this.maxsize = maxsize;
    }
}

在排序数组类中，我们将存储数组的大小，并要求数组的最大大小以及数组初始化的一般框架。在构造函数中，我们要求数组的最大大小并创建一个对象并将其类型转换为我们想要的数组。

吸气剂

public int length() {
        return this.size;
    }
 public int maxlength() {
        return this.maxsize;
    }
 public t get(int index) {
        if (index < 0 || index >= this.size) {
            throw new indexoutofboundsexception("index out of 
 bounds: " + index);
        }
        return this.array[index];
    }

插入方式

private int findinsertionposition(t item) {
        int left = 0;
        int right = size - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            int cmp = item.compareto(this.array[mid]);
            if (cmp < 0) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return left;
    }
public void insert(t item) {
        if (this.size >= this.maxsize) {
            throw new illegalstateexception("the array is already full");
        }

        int position = findinsertionposition(item);

        for (int i = size; i > position; i--) {
            this.array[i] = this.array[i - 1];
        }
        this.array[position] = item;
        size++;
    }

insert 方法以排序的形式将项目插入到其位置。

删除方法

    public void delete(t item) {
        int index = binarysearch(item);
        if (index == -1) {
            throw new illegalargumentexception("unable to delete element " + item + ": the entry is not in the array");
        }

        for (int i = index; i < size - 1; i++) {
            this.array[i] = this.array[i + 1];
        }
        this.array[size - 1] = null;
        size--;
    }

检索方法

private int binarysearch(t target) {
        int left = 0;
        int right = size - 1;
        while (left <= right) {
            int mid = (left + right) / 2;
            int cmp = target.compareto(this.array[mid]);
            if (cmp == 0) {
                return mid;
            } else if (cmp < 0) {
                right = mid - 1;
            } else {
                left = mid + 1;
            }
        }
        return -1;
    }
public integer find(t target) {
        int index = binarysearch(target);
        return index == -1 ? null : index;
    }

遍历法

public void traverse(callback callback) {
        for (int i = 0; i < this.size; i++) {
            callback.call(this.array[i]);
        }
    }

回调接口

public interface callback {
        void call(t item);
    }

遍历中回调接口的使用

public class uppercasecallback implements unsortedarray.callback {
    @override
    public void call(string item) {
        system.out.println(item.touppercase());
    }
}

未排序的数组

和上面几乎一样
初始化和 getter 是相同的。

插入方式

public void insert(t item) {
        if (this.size >= this.maxsize) {
            throw new illegalstateexception("the array is already full");
        } else {
            this.self[this.size] = item;
            this.size++;
        }
    }

删除方法也是一样

搜寻方式

public integer find(t target) {
        for (int i = 0; i < this.size; i++) {
            if (this.self[i].equals(target)) {
                return i;
            }
        }
        return null;
    }

动态数组

动态数组就像数组列表或列表。

初始化

public class dynamicarray {
    private t[] array;
    private int size;
    private int capacity;

    @suppresswarnings("unchecked")
    public dynamicarray(int initialcapacity) {
        if (initialcapacity <= 0) {
            throw new illegalargumentexception("invalid initial capacity: " + initialcapacity);
        }
        this.capacity = initialc
apacity;
        this.array = (t[]) new object[initialcapacity];
        this.size = 0;
    }
}

插入方式

private void resize(int newcapacity) {
        @suppresswarnings("unchecked")
        t[] newarray = (t[]) new object[newcapacity];
        for (int i = 0; i < size; i++) {
            newarray[i] = array[i];
        }
        array = newarray;
        capacity = newcapacity;
    }
    public void insert(t item) {
        if (size >= capacity) {
            resize(2 * capacity);
        }
        array[size++] = item;
    }

删除方法

public void delete(T item) {
        int index = find(item);
        if (index == -1) {
            throw new IllegalArgumentException("Item not found: " + item);
        }

        for (int i = index; i < size - 1; i++) {
            array[i] = array[i + 1];
        }
        array[--size] = null;
        if (capacity > 1 && size <= capacity / 4) {
            resize(capacity / 2);
        }
    }

其他都一样。
希望这有助于使用数组。祝你好运！