数据结构-线性表-顺序表(JAVA)

暑假打算学一下数据结构，顺序表这个东西看着思路这么简单，没想到实现起来却有这么多细节。

首先声明一个接口，包括线性表所有需要的方法。这是线性表的基本部分。

public interface List<T> {
boolean isEmpty();				//判断是否为空
int size();						//线性表元素个数（长度）
T get(int i);					//返回第i个元素
void set(int i,T x);			//设置第i个元素为x
String toString();				//返回线性表所有元素为字符串
int insert(int i,T x);			//插入x作为第i和元素，x!=null返回值为x的序号
int insert(T x);				//在表的最后插入x，返回值为x的序号
T remove(int i);				//删除第i个元素，返回值为删除的元素
void clear();					//清除这个表
int search(T key);				//查找首次和key相等的元素，返回值为其下标
boolean contains(T key);		//查询是否包含key
int insertDifferent(T x);		//插入不重复元素
int remove(T key);				//删除首次出现和key相等的元素,返回其下标
boolean equals(Object obj);		//判断两个线性表是否相等
void addAll(List<T> list);		//在这个单链表中添加list所有元素，集合并运算
}

然后线性表内容继承前面的接口，实现里面的基本功能。

public class SeqList <T> implements List<T>{
	protected Object[] element;				//存储元素
	protected int n;						//存储现在元素的个数
	
	public SeqList(){
		this(64);
	}
	public SeqList(T[] values){
		this(values.length);
		for(int i=0;i<values.length;i++){
			element[i]=values[i];
			n=element.length;
		}
	}
	public SeqList(int length){
		element=new Object[length];
	}
	
	public boolean isEmpty() {				//判断是否为空
		return n==0;						//如果是0返回true
	}

	public int size() {						//线性表元素个数（长度）
		return n;							//返回n的值
	}

	public T get(int i) {				//返回第i个元素
		if(i>=0&&i<n)return (T) element[i];
		return null;						//如果在0-n范围内，返回这个元素，否则返回null
	}
											//设置第i个元素为x，如果x是null或者i不在范围内都抛出异常
	public void set(int i, T x) {		
		if(x==null)throw new NullPointerException("x==null");
		else if(i>=0&&i<n)element[i]=x;
		else throw new java.lang.IndexOutOfBoundsException(i+"");
	}
	
	public String toString(){				//返回这个链表的所有元素
		String str=this.getClass().getName()+"(";
		if(this.n>0)str+=element[0].toString();
		for(int i=1;i<n;i++){
			str+=","+element[i].toString();
		}
		str+=")";
		return str;
	}
	
	public int insert(int i, T x) {	//设置第i个元素为x
		if(x==null)throw new NullPointerException("x==null");	//如果x为空直接抛出异常
		i=i<0?0:i>n?n:i;					//如果x超出边界值，x取边界值
		Object[] source=element;			//把这个数组拷贝给另一个数组
		if(n==element.length){				//如果数据数量到了数组的范围，那数组长度扩大二倍，然后把刚才拷贝的数组第i位以前的赋值过去。
			element=new Object[source.length*2];		
			for(int j=0;j<i;j++)element[j]=source[j];
		}
		for(int j=n-1;j>=i;j--)
			element[j+1]=source[j];			//后面的数据需要移项
		n++;								//既然是插入元素，那元素个数是一定要增加的
		element[i]=x;						//然后把第i个设置为x
		return i;
	}

	public int insert(T x) {				//在顺序表的最后插入一个元素，调用上一个函数
		int n=this.n;
		insert(n,x);
		return n;
	}

	public T remove(int i) {				//删除第i个元素
		if(n>=0&&i>=0&&i<n){				//如果i在范围之内执行这个操作
			T old=(T)element[i];			//先把第i个元素储存起来
			for(int j=i;j<n;j++)
				element[j]=element[j+1];	//把第i个元素后面的都往前移动一格
			element[n-1]=null;				//把初始的最后一个元素清空
			n--;							//因为是删除操作，自然要把长度减1啦
			return old;						//把刚才储存起来的元素返回过去
		}
		return null;
	}

	public void clear() {
		for(int i=0;i<n;i++)element[i]=null;
		n=0;
	}

	public int search(T key) {			//查找首个和key相等的元素，返回下标，如果没有返回-1
		for(int i=0;i<n;i++){
			if(key.equals(element[i]))return i;
		}
		return -1;
	}

	public boolean contains(T key) {	//查询顺序表是否包含key，调用search函数，看其是否为-1
		return search(key)!=-1;
	}

	public int insertDifferent(T x) {	//插入不重复元素，查找不成功时候，尾插入
		int i=search(x);
		if(i==-1){
		i=n;		
		insert(x);
		}
		return i;
	}

	public int remove(T key) {			//删除首次出现和key相等的元素,返回其下标
		int i=search(key);		//先查找其下标
		if(i!=-1)remove(i);		//如果存在就删除
		return i;
	}

	public void addAll(List<T> list) {	
		if(list==null)throw new NullPointerException("x==null");	//如果list为空抛出异常
		int length=list.size();			
		Object[] source=element;
		if(element.length<n+length){		//如果添加后超过范围，那element范围扩大
			element=new Object[n+length];
			for(int i=0;i<n;i++)
				element[i]=source[i];
		}
		for(int i=0;i<length;i++){
			element[i+n]=list.get(i);
		}
		n+=length;
	}
}

最后是测试类，测试里面一些函数是否完善。

public class SeqListTest {

	public static void main(String[] args) {
		List l=new SeqList<Integer>();
		for(int i=0;i<10;i++)l.insert(i);
		System.out.println(l.toString());
		l.remove(5);
		l.remove(6);
		System.out.println(l.toString());
		l.set(1, 2);
		l.set(2, 1);
		System.out.println(l.toString());
		List l2=new SeqList<Integer>();
		l2.addAll(l);
		l.clear();
		System.out.println(l.toString());
		System.out.println(l2.toString());
	}
}

 

发现写的还行O(∩_∩)O

 

参考书籍《数据结构JAVA版》第四版。