从零开始编写Java中的顺序表

从零开始编写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;
		}
	}
}

至此，一个简单的顺序表我们就实现了。