从零开始编写Java中的顺序表
Java中的数据结构-----1.动态数组实现的顺序表
定义List接口
//线性表接口,支持泛型
public interface List<E> {
public int getSize(); //获取表中实际元素个数
public boolean isEmpty(); //判断是否为空
public void add(int index,E e); //按下标插入元素
public void addFirst(E e); //在头部插入元素
public void addLast(E e); //在尾部插入元素
public E remove(int index); //按下标删除元素
public E removeFirst(); //删除第一位元素
public E removeLast(); //删除最后一位元素
public void removeElement(E e); //删除元素e
public void clear(); //清空表
public E get(int index); //获取指定下标元素
public E getFirst(); //获取第一位元素
public E getLast(); //获取最后一位元素
public int find(E e); //获取元素e的下标
public boolean contains(E e); //判断元素e是否在表中
public void set(int index,E e);//修改指定下标元素为e
}
接下来我们创建顺序表实现List接口:
public class ArrayList <E> implements List<E>{
private E[] data; //容器-用来存储元素
private int size; //当前表内实际元素个数
public static final int DEFAULT_CAPACITY = 10; //定义常量存放容器默认大小
public ArrayList() { //默认构造函数中创建一个容量为10的列表
this(DEFAULT_CAPACITY);
}
public ArrayList(int capacity) { //构造函数中创建一个容量为capacity的列表
if(capacity<0){
capacity=DEFAULT_CAPACITY;
}
data = (E[]) new Object[capacity];
size = 0;
}
@Override
public int getSize() {
return size;
}
@Override
public boolean isEmpty() {
return size==0;
}
@Override
public void add(int index, E e) {
if(index<0||index>size) {
throw new IllegalArgumentException("数组下标错误");
}
if(size==data.length) {
resize(data.length*2); //当前容器已满,则重置容量
}
for(int i = size;i>index;i--) {
data[i] = data[i-1];
}
data[index] = e;
size++;
}
@Override
public void addFirst(E e) {
add(0,e);
}
@Override
public void addLast(E e) {
add(size,e);
}
@Override
public E remove(int index) {
if(index<0||index>=size) {
throw new IllegalArgumentException("下标错误");
}
size--;
E res = null;
if(size<=data.length/4) {
resize(data.length/2); //容器内空余过多则重置容器
}
res=data[index];
for(int i = index;i<size-1;i++) {
data[i] = data[i+1];
}
return res;
}
@Override
public E removeFirst() {
return remove(0);
}
@Override
public E removeLast() {
return remove(size-1);
}
@Override
public void removeElement(E e) {
int index = find(e);
if(index!=-1) {
remove(index);
}
}
@Override
public void clear() {
E[] date = (E[]) new Object[DEFAULT_CAPACITY];
size=0;
}
@Override
public E get(int index) {
if(index<0||index>=size||isEmpty()) {
throw new IllegalArgumentException("找不到元素");
}
return data[index];
}
@Override
public E getFirst() {
return get(0);
}
@Override
public E getLast() {
return get(size-1);
}
@Override
public int find(E e) {
if(isEmpty()) {
return -1;
}
for(int i =0;i<size;i++) {
if(data[i]==e) {
return i;
}
}
return -1;
}
@Override
public boolean contains(E e) {
return find(e)!=-1;
}
@Override
public void set(int index, E e) {
if(index<0||index>=size) {
throw new IllegalArgumentException("下标错误");
}
data[index]=e;
}
private void resize(int newLen) { //重置容器
E[] newData = (E[]) new Object[newLen];
for(int i = 0;i<Math.min(data.length, newData.length);i++) {
newData[i] = data[i];
}
data = newData;
}
public void swap(int i,int j) { //交换下标 i 与 j 的元素
if(i<0||i>=size||j<0||j>=size) {
throw new IllegalArgumentException("下标错误");
}
E swap = data[i];
data[i] = data[j];
data[j] = swap;
}
public String toString() {
StringBuilder sb = new StringBuilder();
if(isEmpty()) {
return "ArrayList: []"+size+"/"+data.length;
}else {
for(int i = 0 ;i<size;i++) {
if(i==size-1) {
sb.append(data[i]+" ]");
}else {
sb.append(data[i]+" ,");
}
}
return "ArrayList: ["+sb.toString()+size+"/"+data.length;
}
}
}
至此,一个简单的顺序表我们就实现了。