看懂资料在看一下下面的东西
线性表的链式存储结构的特点是用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的）。对于每个节点来说，除了存储其本身的信息（数据值）之外，还需存储一个指示其直接后继的结点的引用。存储数据元素信息的部分称为数据域 ，存储直接后继结点引用的部分成为指针域 。
优点——增、删速度快。
缺点——不能随机访问。
package ds.linerlist;
/**
* 结点类，包含结点的数据和指向下一个节点的引用
* @author Bao Yiming
* @param <E>
*/
class Node<E> {
private E e;
private Node<E> next = null;
Node() {
}
Node(E e) {
this.e = e;
}
public void setNext(Node<E> next) {
this.next = next;
}
public Node<E> getNext() {
return next;
}
public E getValue() {
return e;
}
public void setValue(E e) {
this.e = e;
}
@Override
public String toString() {
return "" + e;
}
}
/**
* 单链表的实现
* @author Bao Yiming
* @param <E>
*/
public class LinkedList<E> {
private Node<E> head = null; // 每个链表都存有一个空值的头结点。
private Node<E> tail = null; // 链表的最后一个结点，尾结点。
private int size = 0; // 当前链表中的节点数目。
/**
* 建立一个空链表（建立其头结点）。
*/
LinkedList() {
head = new Node<E>();
tail = head;
}
/**
* 在链表的尾部插入数据
* @param e 待插入的数据
* @return
*/
public boolean add(E e) {
Node<E> node = new Node<E>(e); // 将要插入的值封装成一个节点。
tail.setNext(node); // 将待插入结点放到尾结点的下一个结点。
tail = tail.getNext(); // 将新增加的结点设为尾节点。
++size; // 链表大小增1。
return true;
}
/**
*
* @param index 待插入的位置
* @param e 待插入的元素
* @return
*/
public boolean insert(int index, E e) {
validateIndex(index);
Node<E> newNode = new Node<E>(e); // 将要插入的值封装成一个节点。
Node preNode = getNode(index - 1);
newNode.setNext(preNode.getNext());
preNode.setNext(newNode);
return true;
}
/**
* 获取指定位置的结点
* @param index 欲获取结点的下标
*/
private Node<E> getNode(int index) {
validateIndex(index);
Node<E> node = head;
for (int p = 0; p <= index; ++p) {
node = node.getNext();
}
return node;
}
/**
* 获取指定位置的结点的值
* @param index 欲获取值的结点的下标
* @return
*/
public E get(int index) {
validateIndex(index);
Node<E> node = getNode(index);
return node.getValue();
}
/**
* 验证下标值是否合法，非法时抛出异常。
* @param index 待验证的下标值
*/
private void validateIndex(int index) {
if (index < 0 || index > size) {
throw new RuntimeException("无效的下标：" + index);
}
}
/**
* 删除指定位置的结点
* @param index 待删除结点的下标
* @return
*/
public boolean delete(int index) {
Node<E> curNode = null;
if (0 == index) {
curNode = head.getNext();
Node<E> nextNode = curNode.getNext();
head.setNext(nextNode);
} else {
validateIndex(index);
curNode = getNode(index); // 获取待删除节点。
Node<E> preNode = getNode(index - 1); // 获取待删除节点的前一个结点。
// 将待删除节点的前一个结点的下一个结点指向待删除节点的下一个结点。
preNode.setNext(curNode.getNext());
}
curNode.setNext(null); // 将待删除节点的下一结点置空。
return true;
}
/**
* 设置指定位置结点的值。
* @param index 待设置值的结点的下标
* @param e
*/
public void set(int index, E e) {
validateIndex(index);
Node<E> node = getNode(index);
node.setValue(e);
}
/**
* 获取链表的大小。
* @return
*/
public int size() {
return size;
}
@Override
public String toString() {
String str = "";
Node<E> node = head;
while (node != tail) {
str += (" " + node.getNext().getValue());
node = node.getNext();
}
return str;
}
}
转载地址：http://blog.csdn.net/baoyiming1991/article/details/6266147
栈（Stack）作为一个先进后出(FILO) 的线性结构，只支持在栈顶的插入和弹出。
队列（Queue）作为一个先进先出（FIFO） 的线性结构，支持在队首获取元素，在对尾插入元素。
栈的实现：
package ds.linerlist;
/**
* 栈的实现
* @param <E>
* @author <a href="mailto:[email protected]" mce_href="mailto:[email protected]">Bao Yiming</a>
*/
public class Stack<E> {
private Object[] data = null;
private int capacity; // capacity： 栈的容量
private int top; // top： 栈顶指针
Stack() {
this(10);
}
/**
* 初始化栈，声明保存数据的数组大小。
* @param initialSize 栈的初始化大小
*/
Stack(int initialSize) {
if (initialSize >= 0) {
this.capacity = initialSize;
data = new Object[initialSize];
top = 0;
} else {
throw new RuntimeException("初始化大小不能小于0：" + initialSize);
}
}
/**
* 判断栈是否为空
* @return
*/
boolean empty() {
return top == 0 ? true : false;
}
/**
* 获取栈顶元素的内容，但是不弹出
* @return
*/
E peek() {
return (E) data[top - 1];
}
/**
* 弹出栈顶元素
* @return
*/
E pop() {
E e = (E) data[top - 1];
--top;
return e;
}
/**
* 在栈顶插入元素
* @param e 待插入的元素
* @return
*/
boolean push(E e) {
ensureCapacity();
data[top] = e;
++top;
return true;
}
/**
* 检查存储数据的数组容量，如果数组已经满，则扩充容量；否则不操作。
*/
private void ensureCapacity() {
int index;
if (top == capacity) {
capacity *= 2;
Object[] newData = new Object[capacity];
for (index = 0; index < top; ++index) {
newData[index] = data[index];
}
data = newData;
}
}
@Override
public String toString() {
String str = "";
for (int index = 0; index <= top - 1; ++index) {
str += (data[index] + " ");
}
return str;
}
}
队列的实现
package ds.linerlist;
/**
* 队列的实现
* @param <E>
* @author <a href="mailto:[email protected]" mce_href="mailto:[email protected]">Bao Yiming</a>
*/
public class Queue<E> {
Object[] data = null;
private int capacity; // capacity： 队的容量
private int tail; // tail： 队尾指针
/**
* 初始化为声明大小，则设置为10。
*/
Queue() {
this(10);
}
/**
* 初始化队列，声明保存数据的数组大小。
* @param initialSize 队列的初始化大小
*/
Queue(int initialSize) {
if (initialSize >= 0) {
this.capacity = initialSize;
data = new Object[initialSize];
tail = 0;
} else {
throw new RuntimeException("初始化大小不能小于0：" + initialSize);
}
}
/**
* 判断队列是否为空
* @return
*/
public boolean empty() {
return tail == 0 ? true : false;
}
/**
* 在队尾插入元素
* @param e 待插入的元素
* @return
*/
public boolean add(E e) {
ensureCapacity();
data[tail] = e;
++tail;
return true;
}
/**
* 获取队首的元素内容，但不将该元素出队。
* @return
*/
public E peek() {
return (E) data[0];
}
/**
* 将队首元素出队。
* @return
*/
public E poll() {
E e = (E) data[0];
for (int index = 1; index < tail; ++index) {
data[index - 1] = data[index];
}
data[tail - 1] = null;
--tail;
return e;
}
/**
* 检查存储数据的数组容量，如果数组已经满，则扩充容量；否则不操作。
*/
private void ensureCapacity() {
int index;
if (tail == capacity) {
capacity *= 2;
Object[] newData = new Object[capacity];
for (index = 0; index < tail; ++index) {
newData[index] = data[index];
}
data = newData;
}
}
@Override
public String toString() {
String str = "";
for (int index = 0; index < tail; ++index) {
if (data[index] != null) {
str += (data[index] + " ");
}
}
return str;
}
}
时间： 2024-07-30 23:45:58