Java数据结构之线性表（2）

从这里开始将要进行Java数据结构的相关讲解，Are you ready？Let's go~~

java中的数据结构模型可以分为一下几部分:

1.线性结构

2.树形结构

3.图形或者网状结构

接下来的几张，我们将会分别讲解这几种数据结构，主要也是通过Java代码的方式来讲解相应的数据结构。

今天要讲解的是:Java线性结构

Java数据结构之线性结构

说到线性结构的话，我们可以根据其实现方式分为两类:

1）顺序结构的线性表

2）链式结构的线性表

3）栈和队列的线性表

对于1）和2）的讲解，请参考下面的地址:http://www.cnblogs.com/xiohao/p/4353910.html

下面主要讲解线性结构中的栈和队列。

1.线性结构之栈的讲解

    所谓栈是一种特殊的线性结构，它的特点在于只允许我们在线性表的尾端进行insert和remove操作。可以理解为是一种受限的

线性表。往线性表中加入一个元素我们称为入栈，从线性表中移除一个元素我们称为出栈。实在不懂，百度一下你就知道了。

在Java的jdk中的实现以Stack(底层继承的是Vector类)和LinkedList(里面同样实现了push，pop，peek等操作)为主，还是那句话，感兴趣的

自己查看源代码即可。

下面我们进行相关模仿，

首先通过数组来模仿入栈和出栈操作:

package com.yonyou.test;

import java.util.Arrays;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */
public class Test
 {
	public static void main(String[] args) {
   SequenceStack<String> stack=new SequenceStack<String>();
	System.out.println("顺序栈的初始化长度为:"+stack.length());
	stack.push("Hello");
	stack.push("World");
	stack.push("天下太平");
	System.out.println("当前stack中的元素为:"+stack);
	System.out.println("当前stack.peek();中的元素为:"+stack.peek());
	System.out.println("当前元素线性表是否为空:"+stack.empty());

	}
 }

/**
 * 创建一个线性栈
 * 注意这个类是线程不安全的，在多线程下不要使用
 * @author 小浩
 * @创建日期 2015-3-20
 * @param <T>
 */
class SequenceStack<T>
{
	//线性栈的默认长度为10
	private int DEFAULT_SIZE = 10;
	// 保存数组的长度。
	private int capacity;
	// 定义当底层数组容量不够时，程序每次增加的数组长度
	private int capacityIncrement = 0;
	// 定义一个数组用于保存顺序栈的元素
	private Object[] elementData;
	// 保存顺序栈中元素的当前个数
	private int size = 0;

    /**
     * 以默认数组长度创建空顺序栈
     */
	public SequenceStack()
	{
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}

   /**
    * 	以一个初始化元素来创建顺序栈
    * @param element
    */
	public SequenceStack(T element)
	{
		this();
		elementData[0] = element;
		size++;
	}
	/**
	 * 以指定长度的数组来创建顺序栈
	 * @param element 指定顺序栈中第一个元素
	 * @param initSize 指定顺序栈底层数组的长度
	 */
	public SequenceStack(T element , int initSize)
	{
		this.capacity = initSize;
		elementData = new Object[capacity];
		elementData[0] = element;
		size++;
	}
	/**
	 * 以指定长度的数组来创建顺序栈
	 * @param element 指定顺序栈中第一个元素
	 * @param initSize 指定顺序栈底层数组的长度
	 * @param capacityIncrement 指定当顺序栈的底层数组的长度不够时，底层数组每次增加的长度
	 */
	public SequenceStack(T element , int initSize
		, int capacityIncrement)
	{
		this.capacity = initSize;
		this.capacityIncrement = capacityIncrement;
		elementData = new Object[capacity];
		elementData[0] = element;
		size++;
	}

	/**
	 * 获取顺序栈的大小
	 * @return
	 */
	public int length()
	{
		return size;
	}

	/**
	 * 入栈
	 * @param element
	 */
	public void push(T element)
	{
		ensureCapacity(size + 1);
		elementData[size++] = element;
	}

	/**
	 * 很麻烦，而且性能很差
	 * @param minCapacity
	 */
	private void ensureCapacity(int minCapacity)
	{
		// 如果数组的原有长度小于目前所需的长度
		if (minCapacity > capacity)
		{
			if (capacityIncrement > 0)
			{
				while (capacity < minCapacity)
				{
					// 不断地将capacity长度加capacityIncrement，
					// 直到capacity大于minCapacity为止
					capacity += capacityIncrement;
				}
			}
			else
			{
				// 不断地将capacity * 2，直到capacity大于minCapacity为止
				while (capacity < minCapacity)
				{
					capacity <<= 1;
				}
			}
			elementData = Arrays.copyOf(elementData , capacity);
		}
	}

	/**
	 * 出栈
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T pop()
	{
		T oldValue = (T)elementData[size - 1];
		// 释放栈顶元素
		elementData[--size] = null;
		return oldValue;
	}

	/**
	 * 返回栈顶元素，但不删除栈顶元素
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T peek()
	{
		return (T)elementData[size - 1];
	}

	/**
	 * 判断顺序栈是否为空栈
	 * @return
	 */
	public boolean empty()
	{
		return size == 0;
	}

     /**
      * 清空顺序栈
      */
	public void clear()
	{
		// 将底层数组所有元素赋为null
		Arrays.fill(elementData , null);
		size = 0;
	}

	/**
	 * 重写toString
	 */
	public String toString()
	{
		if (size == 0)
		{
			return "[]";
		}
		else
		{
			StringBuilder sb = new StringBuilder("[");
			for (int i = size - 1  ; i > -1 ; i-- )
			{
				sb.append(elementData[i].toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2 , len).append("]").toString();
		}
	}
}

其次通过链式存储来模仿入栈和出栈操作，具体内容可以看下面的代码:

package com.yonyou.test;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */
public class Test
 {
	public static void main(String[] args) {
	LinkStack<String> stack=new LinkStack<String>();
	System.out.println("顺序栈的初始化长度为:"+stack.length());
	stack.push("Hello");
	stack.push("World");
	stack.push("天下太平");
	System.out.println("当前stack中的元素为:"+stack);
	System.out.println("当前stack.peek();中的元素为:"+stack.peek());
	System.out.println("当前元素线性表是否为空:"+stack.empty());

	}
 }

/**
 * 创建一个链式存储的线性栈
 * 注意这个类是线程不安全的，在多线程下不要使用
 * @author 小浩
 * @创建日期 2015-3-20
 * @param <T>
 */
class  LinkStack<T>
{
	// 定义一个内部类Node，Node实例代表链栈的节点。
	private class Node
	{
		// 保存节点的数据
		private T data;
		// 指向下个节点的引用
		private Node next;
		// 无参数的构造器
		public Node()
		{
		}
		// 初始化全部属性的构造器
		public Node(T data , Node next)
		{
			this.data = data;
			this.next = next;
		}
	}
	// 保存该链栈的栈顶元素
	private Node top;
	// 保存该链栈中已包含的节点数
	private int size;

	/**
	 * 创建空链栈
	 */
	public LinkStack()
	{
		// 空链栈，top的值为null
		top = null;
	}

	/**
	 * 以指定数据元素来创建链栈，该链栈只有一个元素
	 * @param element
	 */
	public LinkStack(T element)
	{
		top = new Node(element , null);
		size++;
	}

	/**
	 * 返回链栈的长度
	 * @return
	 */
	public int length()
	{
		return size;
	}

	/**
	 * 进栈
	 * @param element
	 */
	public void push(T element)
	{
		// 让top指向新创建的元素，新元素的next引用指向原来的栈顶元素
		top = new Node(element , top);
		size++;
	}

	/**
	 * 出栈
	 * @return
	 */
	public T pop()
	{
		Node oldTop = top;
		// 让top引用指向原栈顶元素的下一个元素
		top = top.next;
		// 释放原栈顶元素的next引用
		oldTop.next = null;
		size--;
		return oldTop.data;
	}

	/**
	 * 访问栈顶元素，但不删除栈顶元素
	 * @return
	 */
	public T peek()
	{
		return top.data;
	}

	/**
	 * 判断链栈是否为空栈
	 * @return
	 */
	public boolean empty()
	{
		return size == 0;
	}

	/**
	 * 清空链栈
	 */
	public void clear()
	{
		// 将底层数组所有元素赋为null
		top = null;
		size = 0;
	}
	/**
	 * 重写toString方法
	 */
	public String toString()
	{
		// 链栈为空链栈时
		if (empty())
		{
			return "[]";
		}
		else
		{
			StringBuilder sb = new StringBuilder("[");
			for (Node current = top ; current != null
				; current = current.next )
			{
				sb.append(current.data.toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2 , len).append("]").toString();
		}
	}
}

  2.线性结构之队列的讲解

    队列也是一种被限制过的线性结构，它使用固定的一端来插入元素（队尾），在另一端删除相关的元素（队头）。

其基本特征为“先进先出”，而栈的基本特点为“先进后出”。

在Java的jdk中主要的实现类为Dueue接口的实现类ArrayDeque(线性)和LinkedList(链式)，

其中Dueue接口是一个双端队列，它继承了队列根接口Queue，同时Queue接口有实现队列的6个根本方法

	抛出异常的版本	不抛出异常的版本（返回null）
插入	1、 boolean add(E e);	2、 boolean offer(E e);
移除	3、 E remove();	4、 E poll();
访问	5、 E element();	6、 E peek();

如果感兴趣的话，请查相关的源代码。

首先讲解的是队列的顺序存储:

具体内容请看相关代码:

package com.yonyou.test;

import java.util.Arrays;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */
public class Test
 {
	public static void main(String[] args) {
	SequenceQueue<String> queue=new SequenceQueue<String>();
	System.out.println("队列的初始化长度为:"+queue.length());
	queue.add("Hello");
	queue.add("World");
	queue.add("天下太平");
	System.out.println("当前stack中的元素为:"+queue);
    queue.remove();
	System.out.println("当前stack中的元素为:"+queue);
	System.out.println("当前元素线性表是否为空:"+queue.empty());

	}
 }

/**
 * 创建一个存储的线性队列
 * 注意这个类是线程不安全的，在多线程下不要使用
 * @author 小浩
 * @创建日期 2015-3-20
 * @param <T>
 */
class  SequenceQueue<T>
{
	//线性队列的默认长度
	private int DEFAULT_SIZE = 16;
	// 保存数组的长度。
	private int capacity;
	// 定义一个数组用于保存顺序队列的元素
	private Object[] elementData;
	// 保存顺序队列中元素的当前个数
	private int front = 0;
	private int rear = 0;

	/**
	 * 以默认数组长度创建空顺序队列
	 */
	public SequenceQueue()
	{
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}

	/**
	 * 以一个初始化元素来创建顺序队列
	 * @param element
	 */
	public SequenceQueue(T element)
	{
		this();
		elementData[0] = element;
		rear++;
	}

	/**
	 * 以指定长度的数组来创建顺序队列
	 * @param element 指定顺序队列中第一个元素
	 * @param initSize 指定顺序队列底层数组的长度
	 */
	public SequenceQueue(T element , int initSize)
	{
		this.capacity = initSize;
		elementData = new Object[capacity];
		elementData[0] = element;
		rear++;
	}

	/**
	 * 获取顺序队列的大小
	 * @return
	 */
	public int length()
	{
		return rear - front;
	}

	/**
	 * 插入队列
	 * @param element
	 */
	public void add(T element)
	{
		if (rear > capacity - 1)
		{
			throw new IndexOutOfBoundsException("队列已满的异常");
		}
		elementData[rear++] = element;
	}

	/**
	 * 移出队列
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T remove()
	{
		if (empty())
		{
			throw new IndexOutOfBoundsException("空队列异常");
		}
		// 保留队列的front端的元素的值
		T oldValue = (T)elementData[front];
		// 释放队列的front端的元素
		elementData[front++] = null;
		return oldValue;
	}

	/**
	 * 返回队列顶元素，但不删除队列顶元素
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T element()
	{
		if (empty())
		{
			throw new IndexOutOfBoundsException("空队列异常");
		}
		return (T)elementData[front];
	}

	/**
	 * 判断顺序队列是否为空队列
	 * @return
	 */
	public boolean empty()
	{
		return rear == front;
	}

	/**清空顺序队列
	 *
	 */
	public void clear()
	{
		//将底层数组所有元素赋为null
		Arrays.fill(elementData , null);
		front = 0;
		rear = 0;
	}

	/**
	 * 重写toString方法
	 */
	public String toString()
	{
		if (empty())
		{
			return "[]";
		}
		else
		{
			StringBuilder sb = new StringBuilder("[");
			for (int i = front  ; i < rear ; i++ )
			{
				sb.append(elementData[i].toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2 , len).append("]").toString();
		}
	}
}

　　其次讲解的是队列的线性存储的循环组成:

对于上面的非循环存储可能会非常大的浪费空间，下面我们将要创建一个对应的循环链表的概念，这样的话可能会有效的节约相应的空间。

因为循环链表可以有效的消除假满的现象哦。

废话不在多说，请看代码:

package com.yonyou.test;

import java.util.Arrays;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */
public class Test
 {
	public static void main(String[] args) {
	LoopQueue<String> queue=new LoopQueue<String>();
	System.out.println("队列的初始化长度为:"+queue.length());
	queue.add("Hello");
	queue.add("World");
	queue.add("天下太平");
	System.out.println("当前stack中的元素为:"+queue);
    queue.remove();
	System.out.println("当前stack中的元素为:"+queue);
	System.out.println("当前元素线性表是否为空:"+queue.empty());

	}
 }

/**
 * 创建一个顺序存储的循环线性队列
 * 注意这个类是线程不安全的，在多线程下不要使用
 * @author 小浩
 * @创建日期 2015-3-20
 * @param <T>
 */
class LoopQueue<T>
{
	//循环队列的默认长度为16
	private int DEFAULT_SIZE = 16;
	// 保存数组的长度。
	private int capacity;
	// 定义一个数组用于保存循环队列的元素
	private Object[] elementData;
	// 保存循环队列中元素的当前个数
	private int front = 0;
	private int rear = 0;

	/**
	 * 以默认数组长度创建空循环队列
	 */
	public LoopQueue()
	{
		capacity = DEFAULT_SIZE;
		elementData = new Object[capacity];
	}

	/**
	 * 以一个初始化元素来创建循环队列
	 * @param element
	 */
	public LoopQueue(T element)
	{
		this();
		elementData[0] = element;
		rear++;
	}
	/**
	 * 以指定长度的数组来创建循环队列
	 * @param element 指定循环队列中第一个元素
	 * @param initSize 指定循环队列底层数组的长度
	 */
	public LoopQueue(T element , int initSize)
	{
		this.capacity = initSize;
		elementData = new Object[capacity];
		elementData[0] = element;
		rear++;
	}

	/**
	 * 获取循环队列的大小
	 * @return
	 */
	public int length()
	{
		if (empty())
		{
			return 0;
		}
		return rear > front ? rear - front
			: capacity - (front - rear);
	}

	/**
	 * 插入队列
	 * @param element
	 */
	public void add(T element)
	{
		if (rear == front
			&& elementData[front] != null)
		{
			throw new IndexOutOfBoundsException("队列已满的异常");
		}
		elementData[rear++] = element;
		// 如果rear已经到头，那就转头
		rear = rear == capacity ? 0 : rear;
	}

	/**
	 * 移出队列
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T remove()
	{
		if (empty())
		{
			throw new IndexOutOfBoundsException("空队列异常");
		}
		// 保留队列的front端的元素的值
		T oldValue = (T)elementData[front];
		// 释放队列的front端的元素
		elementData[front++] = null;
		// 如果front已经到头，那就转头
		front = front == capacity ? 0 : front;
		return oldValue;
	}

	/**
	 * 返回队列顶元素，但不删除队列顶元素
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public T element()
	{
		if (empty())
		{
			throw new IndexOutOfBoundsException("空队列异常");
		}
		return (T)elementData[front];
	}

	/**
	 * 判断循环队列是否为空队列
	 * @return
	 */
	public boolean empty()
	{
		//rear==front且rear处的元素为null
		return rear == front
			&& elementData[rear] == null;
	}

	/**
	 * 清空循环队列
	 */
	public void clear()
	{
		// 将底层数组所有元素赋为null
		Arrays.fill(elementData , null);
		front = 0;
		rear = 0;
	}
	/**
	 * 重写toString方法
	 */
	public String toString()
	{
		if (empty())
		{
			return "[]";
		}
		else
		{
			// 如果front < rear，有效元素就是front到rear之间的元素
			if (front < rear)
			{
				StringBuilder sb = new StringBuilder("[");
				for (int i = front  ; i < rear ; i++ )
				{
					sb.append(elementData[i].toString() + ", ");
				}
				int len = sb.length();
				return sb.delete(len - 2 , len).append("]").toString();
			}
			// 如果front >= rear，有效元素为front->capacity之间、
			// 和0->front之间的元素
			else
			{
				StringBuilder sb = new StringBuilder("[");
				for (int i = front  ; i < capacity ; i++ )
				{
					sb.append(elementData[i].toString() + ", ");
				}
				for (int i = 0 ; i < rear ; i++)
				{
					sb.append(elementData[i].toString() + ", ");
				}
				int len = sb.length();
				return sb.delete(len - 2 , len).append("]").toString();
			}
		}
	}
}

　　最后要说的队列的链式存储，具体的实现方式还是请看代码吧。

package com.yonyou.test;

import java.util.Arrays;

/**
 * 测试类
 * @author 小浩
 * @创建日期 2015-3-20
 */
public class Test
 {
	public static void main(String[] args) {
	LinkQueue<String> queue=new LinkQueue<String>();
	System.out.println("队列的初始化长度为:"+queue.length());
	queue.add("Hello");
	queue.add("World");
	queue.add("天下太平");
	System.out.println("当前stack中的元素为:"+queue);
    queue.remove();
	System.out.println("当前stack中的元素为:"+queue);
	System.out.println("当前元素线性表是否为空:"+queue.empty());

	}
 }

/**
 * 创建一个链式存储的线性队列
 * 注意这个类是线程不安全的，在多线程下不要使用
 * @author 小浩
 * @创建日期 2015-3-20
 * @param <T>
 */
//定义一个内部类Node，Node实例代表链队列的节点。
class LinkQueue<T>{

	private class Node
	{
		// 保存节点的数据
		private T data;
		// 指向下个节点的引用
		private Node next;
		// 无参数的构造器
		public Node()
		{
		}
		// 初始化全部属性的构造器
		public Node(T data ,  Node next)
		{
			this.data = data;
			this.next = next;
		}
	}
	// 保存该链队列的头节点
	private Node front;
	// 保存该链队列的尾节点
	private Node rear;
	// 保存该链队列中已包含的节点数
	private int size;

	/**
	 * 创建空链队列
	 */
	public LinkQueue()
	{
		// 空链队列，front和rear都是null
		front = null;
		rear = null;
	}

	/**
	 * 以指定数据元素来创建链队列，该链队列只有一个元素
	 * @param element
	 */
	public LinkQueue(T element)
	{
		front = new Node(element , null);
		// 只有一个节点，front、rear都指向该节点
		rear = front;
		size++;
	}

	/**
	 * 返回链队列的长度
	 * @return
	 */
	public int length()
	{
		return size;
	}

	/**
	 * 将新元素加入队列
	 * @param element
	 */
	public void add(T element)
	{
		// 如果该链队列还是空链队列
		if (front == null)
		{
			front = new Node(element , null);
			// 只有一个节点，front、rear都指向该节点
			rear = front;
		}
		else
		{
			// 创建新节点
			Node newNode = new Node(element , null);
			// 让尾节点的next指向新增的节点
			rear.next = newNode;
			// 以新节点作为新的尾节点
			rear = newNode;
		}
		size++;
	}

	/**
	 * 删除队列front端的元素
	 * @return
	 */
	public T remove()
	{
		Node oldFront = front;
		front = front.next;
		oldFront.next = null;
		size--;
		return oldFront.data;
	}

	/**
	 *  访问链式队列中最后一个元素
	 * @return
	 */
	public T element()
	{
		return rear.data;
	}

	/**
	 * 判断链式队列是否为空队列
	 * @return
	 */
	public boolean empty()
	{
		return size == 0;
	}

	/**
	 * 清空链队列
	 */
	public void clear()
	{
		// 将front、rear两个节点赋为null
		front = null;
		rear = null;
		size = 0;
	}

	/**
	 * 重写toString方法
	 */
	public String toString()
	{
		// 链队列为空链队列时
		if (empty())
		{
			return "[]";
		}
		else
		{
			StringBuilder sb = new StringBuilder("[");
			for (Node current = front ; current != null
				; current = current.next )
			{
				sb.append(current.data.toString() + ", ");
			}
			int len = sb.length();
			return sb.delete(len - 2 , len).append("]").toString();
		}
	}
}

这里还是补充一下吧，除了以上介绍的队列外，我们还可以经用到的一个队列是双端队列。

所谓双端队列指的是我们可以在队列的两端进行插入和删除操作。如果我们只允许在队列的一端进行插入和删除的操作，那么队列也就成为

我们之前看到的栈了，是不是很有意思，没错就是这样的。其实栈，队列其本质都是一种受限制的线性表，只好不过限制的情况不同而已。

还需要说的jdk中Deque接口就是一个双端队列的实用接口。它可以理解为Queue和Stack的一个中和体。虽然上面的栈提到了类Stack，

但是现在已经不推荐使用了，一般情况，我们应该使用Deque，因为它的功能更加强大。

在jdk中双端队列接口Deque有两个实现类ArrayDeque(顺序存储的双端队列)和LinkedList(链式存储的双端队列)

是不是发现了LinkedList的功能太强大了。没错，它就是这么任性，没办法。

下面的看一下它的部分源代码:

* @since 1.2
 * @param <E> the type of elements held in this collection
 */

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

　　implements List<E>, Deque<E>, Cloneable, java.io.Serializable

看到红色字体了了吧，剩下你懂的~~

好吧，今天就先到这里吧~~~