数据结构之顺序表

package jxau.blueDot.lyx;

/**
 * 
 * @author lyx
 *	@下午5:06:16
 * @TODO:
 * 	数据结构之顺序表
 */

/**
 * 	 顺序表： 线性表的顺序表指的是:用一组地址连续的存储单元一次存储线性表的数据元素。
 * 以元素在计算机内“物理位置相邻”来表示线性表中数据元素之间的逻辑关系。只要确定了存
 * 储线性表的起始位置，线性表中任何一数据元素都可以随机存取，所以线性表的存储结构是
 * 一种随机存取的存储结构。
 *		由于高级程序设计语言中的数组类型也具有随机存取的特性，因此，通常都用数组来描述
 *	数据结构中的顺序存储结构。
 *
 * 优点——随机存储，读取数据的速度快
 * 
 * 缺点——顺序存储，当需要增加、删除数据是慢
 * 
 */
public interface SequenceList {

	/**
	 * 
	 * @void
	 * 清空顺序表
	 */
	public void clear();
	
	/**
	 * 
	 * @int
	 * @return
	 * 在表中指定位置插入一个新元素
	 */
	public void add(int i,Object value);
	
	/**
	 * 
	 * @int
	 * @return
	 * 在表尾追加一个元素
	 */
	public void add(Object val);
	
	/**
	 * 
	 * @Object
	 * @return
	 * 删除并返回指定位置的元素
	 */
	public Object remove(int i);
	
	/**
	 * 
	 * @boolean
	 * @return
	 * 检测表是否为空
	 */
	public boolean isEmpty();
	
	/**
	 * 
	 * @long
	 * @return
	 * 返回表中元素的个数
	 */
	public long size();
	
	/**
	 * 
	 * @Object
	 * @return
	 * 返回指定位置的元素
	 */
	public Object getValue(int i);
	
	/**
	 * 
	 * @int
	 * @return
	 * 返回指定元素的序号
	 */
	public int indexOf(Object val);
}

具体实现java版

package jxau.blueDot.lyx;

public class SequenceListAchieve implements SequenceList {

	private static final int DEFAULT_SIZE = 10;
	private Object[] array;
	private int count;
	
	public SequenceListAchieve(){
		array = new Object[DEFAULT_SIZE];
		count = 0;
	}
		
	@Override
	public void clear() {
		// TODO Auto-generated method stub
		for(int i=0;i<count;i++){
			array[i] = null;
		}
		count = 0;
		
	}

	@Override
	public void add(int i, Object value) {
		// TODO Auto-generated method stub
		if(i<0 || i>count){			
			throw new IndexOutOfBoundsException();
		}
		
		if(count == array.length){
			expand();
		}
		
		for(int j=count;j>i;j--){
			array[j] = array[j-1];
		}
		
		array[i] = value;
		count++;
		
	}

	@Override
	public void add(Object val) {
		// TODO Auto-generated method stub
		if(count == array.length){
			expand();
		}
		
		array[count++] = val;
	}

	@Override
	public Object remove(int i) {
		// TODO Auto-generated method stub
		if(i<0 || i>count){			
			throw new IndexOutOfBoundsException();
		}
		Object val = array[i];
		
		for(int j=i;j<count-1;j++){
			array[j] = array[j+1];
		}
		
		array[--count] = null;
		
		return val;
	}

	@Override
	public boolean isEmpty() {
		// TODO Auto-generated method stub
		return count==0;
	}

	@Override
	public long size() {
		// TODO Auto-generated method stub
		return count;
	}

	@Override
	public Object getValue(int i) {
		// TODO Auto-generated method stub
		if(i<0 || i>count){			
			throw new IndexOutOfBoundsException();
		}
		return array[i];
	}

	@Override
	public int indexOf(Object val) {
		// TODO Auto-generated method stub
		for(int i=0;i<count;i++){
			if(val.equals(array[i])){
				return i;
			}
		}
		return -1;
	}
		
	/**
	 * 数组扩展
	 * @void
	 */
	private void expand(){
		
		Object[] newArray = new Object[2*array.length];
		
		for(int i=0;i<array.length;i++){			
			newArray[i] = array[i];
		}
		
		array = newArray;
	}
	
	/**
	 * 重写toString方法
	 */
	public String toString(){
		
		String buf = new String("[");
		
		for(int i=0;i<count;i++){
			if(i>0){
				buf += ", ";
			}
			buf += array[i];
		}
		
		return buf;
		
	}

}