Java实现线性表

线性表的实现方法一般有两种——顺序表和链表

首先定义一个接口，用于定义线性表应实现的功能

package List;


public interface List<T> 
{
	//清空线性表
	void clear();
	//在线性表最前面插入元素
	boolean insert(T data);
	//在线性表的最后面插入元素
	boolean append(T data);
	//删除线性表的第一个元素
	boolean removed(T data);
	//把fence设置到第一个位置
	void setStart();
	//把fence设置到最后一个位置
	void setEnd();
	//把fence左移一个位置，如果在最开始，则不动
	void prev();
	//把fence右移一个位置，如果在最右边，则不动
	void next();
	//返回fence左边的长度
	int leftLength();
	//返回fence右边的长度
	int rightLength();
	//
	boolean setPos(int pos);
	//查看线性表里面是否有指定元素
	boolean getValue(T data);
	//打印输出线性表元素
	void print();
}

顺序表实现

package List;

public class AList<T> implements List<T> {
	
	private int maxSize;
	private int listSize;
	private int fence;
	Object[] listArray;
	
	public AList(int DefaultListSize)
	{
		maxSize = DefaultListSize;
		listSize = fence = 0;
		listArray = new Object[maxSize];
	}
	@Override
	public void clear() {
		for(int i = 0;i < listSize;i++)
		{
			listArray[i] = null;
		}
	}

	@Override
	public boolean insert(T data) {
		if(listSize < maxSize - 1)
		{
			for(int i = listSize + 1;i >= 1;i--)
			{
				listArray[i] = listArray[i-1];
			}
			listArray[0] = data;
			listSize++;
			return true;
		}
		return false;
	}

	@Override
	public boolean append(T data) {
		if(listSize > maxSize - 1 )
		{
			reSize();
			listArray[listSize++] = data;
			return true;
		}
		return false;
	}

	@Override
	public boolean removed(Object data) {
		if(listSize > 0 )
		{
			data = listArray[listSize-1];
			listSize--;
			return true;
		}
		return false;
	}

	@Override
	public void setStart() {
		fence = 0;
	}

	@Override
	public void setEnd() {
		fence = listSize;
	}

	@Override
	public void prev() {
		if(fence != 0)
		{
			fence--;
		}
	}

	@Override
	public void next() {
		if(fence < listSize)
		{
			fence++;
		}
	}

	@Override
	public int leftLength() {
		return fence;
	}

	@Override
	public int rightLength() {
		return listSize - fence;
	}

	@Override
	public boolean setPos(int pos) {
		if(pos >= 0 && pos <=listSize)
			fence = pos;
		return (pos >= 0) && (pos <= listSize);
	}

	@Override
	public boolean getValue(Object data) {
		if(rightLength() == 0) 
			return false;
		else
		{
			data = listArray[fence];
			return true;
		}
	}

	@Override
	public void print() {
		for(int i = 0;i < listSize;i++)
		{
			System.out.print(listArray[i] + " ");
		}
		System.out.println();
	}
	
	public void reSize()
	{
		Object[] temp = new Object[maxSize*2];
		for(int i = 0;i < listSize;i++)
		{
			temp[i] = listArray[i];
			listArray[i] = null;
		}
		listArray = temp;
	}
	public static void main(String[] args)
	{
		AList al = new AList(20);
		long begin = System.currentTimeMillis();
		for(int i = 0;i < 1000000;i++)
		{
			al.append(i);
		}
		long end = System.currentTimeMillis();
		long between = end - begin;
		System.out.println(between);
		//int a = 0;
		//al.removed(a);
		//al.print();
		
	}
}

链表实现

package List;

public class LList<T> implements List<T> {
	private class LinkNode{
		Object element;
		LinkNode next;
		public LinkNode(Object data,LinkNode next)
		{
			this.element = data;
			this.next = next;
		}
		public LinkNode(LinkNode next)
		{
			this.next = next;
		}
		
	}
	
	private LinkNode head;
	private LinkNode tail;
	private LinkNode fence;
	int leftcnt;
	int rightcnt;
	
	private void init()
	{
		fence = tail = head = new LinkNode(null);
		leftcnt = rightcnt = 0;
	}
	
	private void removeAll()
	{
		while(head != null)
		{
			fence = head;
			head = head.next;
			fence = null;
		}
	}
	public LList()
	{
		init();
	}
	@Override
	public void clear() {
		removeAll();
		init();
		
	}

	@Override
	public boolean insert(Object data) {
		fence.next = new LinkNode(data,fence.next);
		if(tail == fence)
			tail = fence.next;
		rightcnt++;
		return true;
	}

	@Override
	public boolean append(Object data) {
		tail = tail.next = new LinkNode(data,null);
		rightcnt++;
		return true;
	}

	@Override
	public boolean removed(Object data) {
		if(fence.next == null)
			return false;
		data = fence.next.element;
		LinkNode ltemp = fence.next;
		fence.next = ltemp.next;
		if(tail == ltemp)
			tail = fence;
		ltemp = null;
		rightcnt--;
		return true;
	}

	@Override
	public void setStart() {
		fence = head;
		rightcnt += leftcnt;
		leftcnt = 0;
	}

	@Override
	public void setEnd() {
		fence = tail;
		leftcnt += rightcnt;
		rightcnt = 0;
	}

	@Override
	public void prev() {
		if(fence != head)
		{
			LinkNode ltemp = head;
			while(ltemp.next != fence)
			{
				ltemp = ltemp.next;
			}
			fence = ltemp;
			leftcnt--;
			rightcnt++;
		}
	}

	@Override
	public void next() {
		if(fence != tail)
		{
			fence = fence.next;
			leftcnt++;
			rightcnt--;
		}
	}

	@Override
	public int leftLength() {
		return leftcnt;
	}

	@Override
	public int rightLength() {
		return rightcnt;
	}

	@Override
	public boolean setPos(int pos) {
		if(pos < 0 && pos > rightcnt + leftcnt)
			return false;
		fence = head;
		for(int i = 0;i < pos;i++)
			fence = fence.next;
		return true;
	}

	@Override
	public boolean getValue(Object data) {
		if(rightcnt == 0)
		{
			return false;
		}
		data = fence.next.element;
		return true;
	}

	@Override
	public void print() {
		LinkNode ltemp = head;
		while(ltemp != null)
		{
			System.out.print(ltemp.element + " ");
			ltemp = ltemp.next;
		}
		System.out.println();
	}
	public static void main(String[] args)
	{
		/*AList al = new AList(20);
		long begin = System.currentTimeMillis();
		for(int i = 0;i < 1000000;i++)
		{
			al.append(i);
		}
		long end = System.currentTimeMillis();
		long between = end - begin;
		System.out.println(between);*/
		LList ll = new LList();
		//long begin1 = System.currentTimeMillis();
		for(int i = 0;i < 20;i++)
		{
			ll.insert(i);
		}
		ll.print();
		System.out.println();
		//System.out.println(ll.head.element);
		//long end1 = System.currentTimeMillis();
		//long between1 = end1 - begin1;
		//System.out.println(between1);
	}
}

双链表实现

package List;

public class DLList<T> implements List<T> {

	private class DLink
	{
		Object element;
		DLink next;
		DLink prev;
		
		DLink(Object element,DLink prev,DLink next)
		{
			this.element = element;
			this.next = next;
			this.prev = prev;
		}
		DLink(DLink next,DLink prev)
		{
			this.next = next;
			this.prev = prev;
		}
	}
	private DLink fence;
	private DLink head;
	private DLink tail;
	private int leftcnt;
	private int rightcnt;
	
	private void init()
	{
		fence = tail = head  = new DLink(null,null);
		leftcnt = rightcnt = 0;
	}
	private void removeAll()
	{
		while(head != null)
		{
			fence = head;
			fence = null;
			head = head.next;
		}
	}
	
	public DLList()
	{
		this.init();
	}
	@Override
	public void clear() {
		removeAll();
		init();	
	}

	@Override
	public boolean insert(Object data) {
		fence.next = new DLink(data,fence,fence.next);
		if(fence.next.next != null)
			fence.next.next.prev = fence.next;
		if(tail == fence)
			tail = fence.next;
		rightcnt++;
		return true;
	}

	@Override
	public boolean append(Object data) {
		tail = tail.next = new DLink(data,tail,null);
		rightcnt++;
		return true;
	}

	@Override
	public boolean removed(Object data) {
		if(fence.next == null)
			return false;
		data = fence.next.element;
		DLink dltemp = fence.next;
		if(dltemp.next != null)
			dltemp.next.prev = fence;
		else 
			tail = fence;
		rightcnt--;
		return true;
	}

	@Override
	public void setStart() {
		fence = head;
		rightcnt += leftcnt;
		leftcnt = 0;
	}

	@Override
	public void setEnd() {
		fence = tail;
		leftcnt += rightcnt;
		rightcnt = 0;
	}

	@Override
	public void prev() {
		if(fence != head)
		{
			fence = fence.prev;
			leftcnt--;
			rightcnt++;
		}
	}

	@Override
	public void next() {
		if(fence != tail)
		{
			fence = fence.next;
			rightcnt--;
			leftcnt++;
		}
	}

	@Override
	public int leftLength() {
		return leftcnt;
	}

	@Override
	public int rightLength() {
		return rightcnt;
	}

	@Override
	public boolean setPos(int pos) {
		if(pos < 0 || pos > leftcnt+rightcnt)
			return false;
		fence = head;
		for(int i = 0;i < pos;i++)
		{
			fence = fence.next;
		}
		return true;
	}

	@Override
	public boolean getValue(Object data) {
		if(fence == tail)
			return false;
		data = fence.next.element;
		return true;
	}

	@Override
	public void print() {
		
		DLink dltemp = head;
		while(dltemp != null)
		{
			System.out.print(dltemp.element + " ");
			dltemp = dltemp.next;
		}
		System.out.println();
		
	}
	
	public static void main(String[] args)
	{
		DLList dll = new DLList();
		
		for(int i = 0;i < 20;i++)
		{
			dll.insert(i);
		}
		/*dll.append(1);
		System.out.println(dll.tail.next == dll.head);
		dll.insert(1);
		System.out.println(dll.tail.next == dll.head);*/
		//dll.append(2);
		dll.print();
		//System.out.println("end");
	}
}

注意：1、里面有问题没有解决，Java的传引用调用没有实现，所以删除时应通过返回值来返回被删除的对象

2、在使用的时候对象的定义应通过接口来定义，这样才符合面向对象机制