数组与链表---一对好朋友

数组和链表

---

两种数据结构的对比

数组： 优点是支持随机访问，缺点是空间大小一旦确定便不能改变。

链表：优点是空间大小可以按需改变，缺点是数据不能随机访问。

这两者的对比鲜明！

运用—实现栈结构

栈数据结构分别用数组和链表来实现。

栈API

方法	作用
public boolean isEmpty()	判断栈是否为空
public int size()	判断栈中元素个数
public Item pop()	出栈
public void push(Item item)	入栈

item是泛型 ，代表一种类

首先是数组

定容栈

public class CapacityStack<Item> {
	private Item[] a;
	private int N;
	
	public CapacityStack(int cap)//容量初始化
	{
		a =(Item[]) new Object[cap];
	}
	
	public boolean isEmpty()
	{
		return N==0;
	}
	
	public int size()
	{
		return N;
	}
	
	public void push(Item item)
	{
		a[N++] = item;
	}
	
	public Item pop()
	{
		Item i = a[--N];
		a[N] = null;//防止对象游离
		return i;
	}	
}

链表实现

public class Stack<Item>{
	private Node first;
	private int N;
    
	private class Node{
		Item item;
		Node next;
	}
	
	public boolean isEmpty() {
		return N == 0;
	}
	
	public int size()
	{
		return N;
	}
	
	public void push(Item item)
	{
		Node oldfirst = first;
		first = new Node();
		first.item  = item;
		first.next = oldfirst;
		N++;
	}
	
	public Item pop()
	{
		Item item = first.item;
		first = first.next;
		N--;
		return item;
	}
}

对比

用数组实现的栈因为其空间大小需要在一开始确定所以称为定容栈

两种方式显示的栈在方法的效率上来讲都是一样。

但是在空间上定容栈有着明显的缺点

• 栈容量有上限，存在数组溢出隐患
• 栈空间存在盈余，导致空间浪费

总得来说，还是链表实现栈更合适。

优化

定容栈 ------> 可变容量栈

• 当栈元素等于栈容量时扩大一倍容量。
• 当栈元素等于栈容量的1/4时，缩小栈容量到原来的二分之一。

两者的实现都是靠 数组转移

实现

public class ResizingArrayStack<Item>{
	private Item[] a = (Item[]) new Object[1];//空间初始化
	private int N = 0;
	
	public ResizingArrayStack(int cap)//容量初始化
	{
		a = (Item[]) new Object[cap];	
	}

	public void push(Item item)
	{
		a[N++] = item;
		if(N == a.length) resize(N*2);
	}
	
	public Item pop()
	{
		Item temp = a[--N];
		a[N] = null;
		if(N!=0 & N == a.length/4) resize(2*N);//空间使用效率不会低于1/4
		return temp;
	}
	
	public boolean isEmpty() {
		return N==0;
	}
	
	public int size()
	{
		return N;
	}
	
	public void resize(int max) {
		Item[] temp = (Item[]) new Object[max];
		for(int i = 0;i<a.length;i++)
			temp[i] = a[i];
		a = temp;
	}
}

尽管这样的实现使得栈的容量可变，但是效率还是低于链表实现的。