标签：
从这里开始将要进行Java数据结构的相关讲解，Are you ready？Let‘s go~~
java中的数据结构模型可以分为一下几部分:
1.线性结构
2.树形结构
3.图形或者网状结构
接下来的几张，我们将会分别讲解这几种数据结构，主要也是通过Java代码的方式来讲解相应的数据结构。
今天要讲解的是:Java线性结构
Java数据结构之线性结构
说到线性结构的话，我们可以根据其实现方式分为两类:
1）顺序结构的线性表
2）链式结构的线性表
3）栈和队列的线性表
对于1）和2）的讲解，请参考下面的地址:
下面主要讲解线性结构中的栈和队列。
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中主要的实现类为Dqueue接口的实现类ArrayDeque(线性)和LinkedList(链式)，如果感兴趣的话，请查相关的源代码。
首先讲解的是队列的线性存储:
具体内容请看相关代码:
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;
}
// 返回队列顶元素，但不删除队列顶元素
@SuppressWarnings("unchecked")
public T element()
{
if (empty())
{
throw new IndexOutOfBoundsException("空队列异常");
}
return (T)elementData[front];
}
// 判断循环队列是否为空队列
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;
}
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();
}
}
}
}
标签：
原文地址：http://www.cnblogs.com/xiohao/p/4354276.html
