顺序存储结构-java实现

列表–整型

/***
 * 列表
 */
class MyList{ 
	Integer[] vals = null;
	int size = 0;
	public MyList() {
		vals = new Integer[10];
	}

	public MyList(int size) {
		this.vals = new Integer[size];
	}
	
	/***
	 * 获取长度
	 */
	public int length() {
		return size;
	}
	
	/***
	 * 判断是否为空
	 * @return
	 */
	public Boolean isEmpty() {
		if(size == 0) {
			return Boolean.TRUE;
		}
		return Boolean.FALSE;
	}
	
	/***
	 * add
	 */
	public void add(int val) {
		if(vals.length == size) {
			//扩容
			int newSize = size << 1;
			Integer[] newVals = new Integer[newSize];
			System.arraycopy(vals, 0, newVals, 0,size);
			vals = newVals;
		}
		vals[size++] = val;
	}
	
	
	/***
	 * delete
	 */
	public Integer delete(int index) {
		if(index >= size) {
			throw new RuntimeException("长度过长");
		}
		
		Integer oldValue = vals[index];

        int move = size - index -1;  //计算出数组后面需要移动多少位
        
        /***
         * 从源数组vals 的index+1开始复制move位到vals中从index开始覆盖  --总共覆盖move位
         */
        System.arraycopy(vals, index+1, vals, index, move); 
        vals[--size] = null; //清除多的最后一位
        return oldValue;
		
	}
	
	/**
	 * get(index)
	 */
	public Integer get(int index) {
		if(index >= size) {
			throw new RuntimeException("长度过长");
		}
		return vals[index];
		
	}
}

列表–泛型

/***
 * 列表
 */
class MyListObject<E>{ 
	Object[] vals = null;
	int size = 0;
	public MyListObject() {
		vals = new Object[10];
	}

	public MyListObject(int size) {
		this.vals = new Object[size];
	}
	
	/***
	 * 获取长度
	 */
	public int length() {
		return size;
	}
	
	/***
	 * 判断是否为空
	 * @return
	 */
	public Boolean isEmpty() {
		if(size == 0) {
			return Boolean.TRUE;
		}
		return Boolean.FALSE;
	}
	
	/***
	 * add
	 */
	public void add(E val) {
		if(vals.length == size) {
			//扩容
			int newSize = size << 1;
			Object[] newVals = new Object[newSize];
			System.arraycopy(vals, 0, newVals, 0,size);
			vals = newVals;
		}
		vals[size++] = val;
	}
	
	
	/***
	 * delete
	 */
	public E delete(int index) {
		if(index >= size) {
			throw new RuntimeException("长度过长");
		}
		
		E oldValue = (E) vals[index];

        int move = size - index -1;  //计算出数组后面需要移动多少位
        
        /***
         * 从源数组vals 的index+1开始复制move位到vals中从index开始覆盖  --总共覆盖move位
         */
        System.arraycopy(vals, index+1, vals, index, move); 
        vals[--size] = null; //清除多的最后一位
        return oldValue;
		
	}
	
	/**
	 * get(index)
	 */
	public E get(int index) {
		if(index >= size) {
			throw new RuntimeException("长度过长");
		}
		return (E) vals[index];
		
	}
}

队列

class QueueList{
	int capacity; //容量
	int size = 0;//数组大小
	
	Integer[] vals;
	
	public QueueList() {
		capacity = 10;
		vals = new Integer[capacity];
	}
	
	public QueueList(int capacity) {
		this.capacity = capacity;
		vals = new Integer[capacity];
	}
	
	public void push(Integer val) {
		if(size == capacity) {
			throw new RuntimeException("容量已满");
		}
		vals[size++] = val;
	}
	
	
	public Integer pop() {
		if(size == 0) {
			throw new RuntimeException("空队列");
		}
		int move = size -1;
		Integer oldValue = vals[0];
		System.arraycopy(vals, 1, vals, 0, move);
		vals[--size] = null;
		
		return oldValue;
	}
}

测试用例

public class TestQueue {
	
	/***
	 * 列表
	 */
	@Test
	public void ArrList() {
		MyList list = new MyList(5);
		for (int i = 0; i < 6; i++) {
			list.add(i);
		}
		
		list.delete(0);
		
		for (int i = 0; i < 5; i++) {
			System.out.println(list.get(i));
		}
	}
	
	/***
	 * 队列
	 */
	@Test
	public void ArrQueue() {
		QueueList queueList = new QueueList(5);
		for (int i = 0; i < 5; i++) {
			queueList.push(i);
		}
		
		for (int i = 0; i < 5; i++) {
			Integer pop = queueList.pop();
			System.out.println(pop);
		}
	}
	
	/***
	 * Object队列
	 */
	@Test
	public void ArrObjectList() {
		MyListObject<String> list = new MyListObject(5);
		for (int i = 0; i < 5; i++) {
			list.add(String.valueOf(i));
		}
		
		for (int i = 0; i < 5; i++) {
			String string = list.get(i);
			System.out.println(string);
		}
	}
}