数组和链表实现队列的比较

• 首先对于数组、链表基本都有的基本操作就是增删改查，采用数组和链表两种方式实现增删改查操作
• 第一种方式是数组实现队列
  首先定义一个接口是增删改查

//定义的接口 其中E为泛型，用来定义具体操作的是什么类型 可以是一个类也可以是基本数据类型（用包装类实现）
public interface Iarray<E> {
	//增加
	void add(E e);
	//删除
	void delete(E e);
	//修改
	void check(E e,E ee);
	//遍历
	void arraylist();
	//长度
	int size();
	

}

• 具体代码块增加操作，思路是因为数组在底层存单元的存储是连续的，因此对于数组的增加操作是首先要new一个比原来数组长度长度增大1的内存然后将要增加的数据存进去

public void add(E e) {
		// TODO Auto-generated method stub
		//定义了一个比原来数组长度大1的数组
		obb = new Object[ob.length+1];
		//将原来数组的全部元素都存入新建的数组里面去
		for(int i = 0;i<ob.length;i++) {
			obb[i] = ob[i];
					//System.out.println(obb[i]);
		}
		//新建数组的最后一个内存单元用来存放新增加的数据
			obb[obb.length-1] = e;
			ob = obb;				
	}

• 删除操作，思路是根据要删除的数据值来进行操作，首先遍历数组找到和要删除数值相同的数值然后将其值改为数组类型的默认值，后面新建一个数组长度为原数组长度减去相同数值的个数，最后再将原来在、数组里面的非null值拷贝到新建的数组里面去

public void delete(E e) {
		//用来遍历新建数组
		int x = 0;
		// TODO Auto-generated method stub
		//遍历原来数组里面和要删除数据值相同的数据 将其值变为数组默认的值null
		for(int i = 0;i<ob.length;i++) {
			if(ob[i] == e) {
				ob[i] = null;
				//用来表示有几个这样要删除的数据
				j++;
			}
		}
		//新建数组的长度是将原来数组长度减去上面和要删除数据值相同的数据个数j
		obb = new Object[ob.length-j];
		for(int i = 0;i<ob.length;i++) {
			if(ob[i] != null) {
				obb[x++] = ob[i];			
			}	
		}
		ob = obb;	
	}

• 修改操作，思路是首先找到需要改变的数值，然后将其修改，数组长度不会变，可以直接操作

public void check(E e, E ee) {
	// TODO Auto-generated method stub
	for(int i = 0;i<ob.length;i++) {
		if(ob[i] == e) {	
			ob[i] = ee;
		}	
	}
}

• 遍历数组

public void arraylist() {
	// TODO Auto-generated method stub
	for(int i = 0;i<ob.length;i++) {
		System.out.println(ob[i]);
	}	
}

• 数组长度

public int size() {
	// TODO Auto-generated method stub
	return ob.length;
}
	

• 利用链表实现队列

public interface Inode<E> {
	//增加
	public void add(E e);
	//删除
	public void delet(E e);
	//长度
	public int size();
	//遍历
	public void linklist();
	//修改
	public void check(E e,E ee);	
}

• 节点类，里面有需要存储的数据，还包括指向下一个节点的属性

public class Node {
	public Object obj;//需要存储数据
	public Node next;//用来指向下一个
	public Node() {	
	}
	//带参数的构造方法 直接可以将数据传进来
	public Node(Object obj) {
		this.obj = obj;
	}
}

• 具体实现

public class link<E> implements Inode<E> {
	//创建一个根节点指向链表的根
	public Node root;
	//创建一个尾节点指向链表的尾
	public Node last;
	//链表的长度
	public int size;
	//构造方法直接对根节点进行新建对象
	public link(){
		root = new Node();
	}

	@Override
	public void add(E e) {
		//将要增加的数据放入节点类中 调用节点类的构造方法
		Node no = new Node(e);
		Node head = root.next;
		//判断链表的下一个节点是否为空 为空则新建节点存入数据
		if(head == null) {
			root.next = no;
			last = no;
			size++;
			
		}else{
			last.next = no;
			last = no;
			size++;
		}	
	}

	@Override
	public void delet(E e) {
		Node nn = root.next;
		Node mm = root;
		while(nn != null) {
			//nn = root.next;
			if(nn.obj == e) {
				//root.next = nn.next;
				mm.next = nn.next;
				size--;
				break;
				
			}else {
				nn = nn.next;
				mm = mm.next;
				
			}
			
		}
		
	}

	@Override
	public int size() {
		// TODO Auto-generated method stub
		return size;
	}
	@Override
	public void linklist() {
		//Node nn = root;
		for(Node nn = root.next;nn != null;nn = nn.next) {
			System.out.println(nn.obj);	
		}
		// TODO Auto-generated method stub
	}
	@Override
	public void check(E e, E ee) {
		// TODO Auto-generated method stub
		for(Node nn = root.next;nn != null;nn = nn.next) {
			if(e.equals(nn.obj)) {
				nn.obj = ee;
				//break;
			}	
		}
	}
	
	public static void main(String[] args) {
		link<String> ll = new link();
		long start = System.currentTimeMillis();	
		for(int i = 0;i<120000;i++) {	
			ll.add("1258");
		}
		ll.add("1258");
		ll.add("1223");
		ll.add("12584");
		ll.add("1224");
		ll.add("12580");
		ll.add("12");
		ll.add("12580");
		ll.add("12");
		//System.out.println(ll.size());
		//ll.linklist();
		ll.check("1258", "66666");
		//System.out.println(ll.size());
		//ll.linklist();
		ll.delet("12");
		//System.out.println(ll.size());
		//ll.linklist();
		long end = System.currentTimeMillis();
		System.out.println(end-start);		
	}
}

• 总结通过增加1000000个数据来判断两种方法的时间，最终发现链表实现队列相比数组实现队列所耗费的时间少很多，这也充分证明了在计算机底层存储数组形式和链表形式的优缺点，因为数组存储必须是连续的，因此会很难实现当遇到占很大内存的数据就会很难实现，链表则可以采用离散存储，经实际运行代码可以验证！！