数据结构之数组
Array一些操作函数：
//自定义一个E型的泛型数组
public class Array<E> {
private E data[];
private int size;
/**
* 构造函数
* @param capacity 传入数组容量
*/
public Array(int capacity){
data=(E[])new Object[capacity];//先new一个Object的数组，在强制转换成E型的数组
size=0;
}
/**
* 无参数的构造函数，默认数组容量为capacity 10
*/
public Array(){
this(10);
}
/**
* 获取数组中的元素个数
* @return
*/
public int getSize(){
return size;
}
/**
* 获取数组容量
* @return
*/
public int getCapacity(){
return data.length;
}
/**
* 向所有元素后添加一个元素e
* @param e 添加的元素
*/
public void addLast(E e){
add(size,e );
}
/**
* 在所有元素最前面添加一个元素e
* @param e
*/
public void addFirst(E e){
add(0,e );
}
/**
* 在index位置添加一个新元素e
* @param index 位置
* @param e 新元素
*/
public void add(int index,E e) {
//添加位置不在数组内，抛出异常
if (index < 0 || index > size) {
throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
}
//扩容
if(size == data.length)
resize(2 * data.length);
//依次从最后的位置开始往后移，直到index
for (int i = size - 1; i >= index; i--) {
data[i + 1] = data[i];
}
//添加到index位置
data[index] = e;
size++;
}
/**
* 重写toStrong函数
* @return
*/
@Override
public String toString(){
StringBuilder res=new StringBuilder();
res.append(String.format("Array: size = %d , capacity = %d\n", size, data.length));
res.append('[');
for(int i=0;i<size;i++){
res.append(data[i]);
if(i!=size-1){
res.append(", ");
}
}
res.append("]");
return res.toString();
}
/**
* 获取index索引位置的元素
* @param index
* @return
*/
E get(int index){
//位置不在数组内，抛出异常
if (index < 0 || index > size) {
throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
}
return data[index];
}
/**
* 修改索引位置的元素值
* @param index
* @param e
*/
void set(int index,E e){
//位置不在数组内，抛出异常
if (index < 0 || index > size) {
throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
}
data[index]=e;
}
/**
* 查找数组中是否有元素e
* @param e
* @return
*/
public boolean contains(E e){
for(int i=0;i<size;i++){
//两个类之间的值的比较用equals
if(data[i].equals(e)){
return true;
}
}
return false;
}
/**
* 查找数组中元素所在的索引，如果不存在，返回-1
* @param e
* @return
*/
public int find(E e){
for(int i=0;i<size;i++){
if(data[i].equals(e)){
return i;
}
}
return -1;
}
/**
* 从数组中删除index位置的元素
* @param index
* @return
*/
public E remove(int index) {
//数组已空，抛出异常
if (size == 0) {
throw new IllegalArgumentException("AddLast is failed");
}
//位置不在数组内，抛出异常
if (index < 0 || index > size) {
throw new IllegalArgumentException("AddLast is failed,Required index>=0 && index<=size");
}
//保存要删除的元素
E ret = data[index];
//从index+1开始，依次往前移
for (int i = index + 1; i < size; i++) {
data[index] = data[i];
}
size--;
//当size为容量的1/4时才进行缩容，防止复杂度的震荡
if(size==data.length/4 && data.length/2!=0){
resize(data.length/2);
}
return ret;
}
/**
* 删除第一个元素
* @return
*/
public E removeFirst(){
return remove(0);
}
/**
* 删除最后一个元素
* @return
*/
public E removeLast(){
return remove(size-1);
}
/**
* 从数组中删除元素e
* @param e
*/
public void removeElement(E e){
int index=find(e);
if(index!=-1){
remove(index);
}
}
/**
* 动态数组的定义修改
* @param newCapacity 新容量
*/
private void resize(int newCapacity){
E[] newData=(E[])new Object[newCapacity];//创建一个新数组
for(int i=0;i<size;i++){
newData[i]=data[i];
}
data=newData;//将新数组赋值给原来的数组
}
}
测试函数
public class Main {
public static void main(String[] args) {
Array<Integer> arr = new Array<>();//创建一个整型数组
for (int i = 0; i < 10; i++){
arr.addLast(i);
}
System.out.println(arr);
arr.add(0, 100);
System.out.println(arr);
arr.addFirst(-1);
System.out.println(arr);
// [-1, 0, 100, 1, 2, 3, 4, 5, 6, 7, 8, 9]
arr.remove(2);
System.out.println(arr);
arr.removeElement(4);
System.out.println(arr);
arr.removeFirst();
System.out.println(arr);
}
}
测试结果
Array: size = 10 , capacity = 10
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size = 11 , capacity = 20
[100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size = 12 , capacity = 20
[-1, 100, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
Array: size = 11 , capacity = 20
[-1, 100, 9, 1, 2, 3, 4, 5, 6, 7, 8]
Array: size = 10 , capacity = 20
[-1, 100, 9, 1, 2, 3, 8, 5, 6, 7]
Array: size = 9 , capacity = 20
[7, 100, 9, 1, 2, 3, 8, 5, 6]