数据结构-线性表(3)

基于双向链表实现的链接表

双向链表结点定义

package com.wjy.Data_Structure.linearlist.common;

//双向链表结点
public class DLNode implements Node {
	private Object element;
	private DLNode pre;
	private DLNode next;

	public DLNode() {

	}

	public DLNode(Object element, DLNode pre, DLNode next) {
		super();
		this.element = element;
		this.pre = pre;
		this.next = next;
	}

	public DLNode getPre() {
		return pre;
	}

	public void setPre(DLNode pre) {
		this.pre = pre;
	}

	public DLNode getNext() {
		return next;
	}

	public void setNext(DLNode next) {
		this.next = next;
	}

	@Override
	public Object getData() {
		return element;
	}

	@Override
	public void setData(Object obj) {
		element = obj;
	}

}

双向链表是通过上述定义的结点使用 pre 以及 next 域依次串联在一起而形成的。一个双向链表的结构如下图：

链接表接口定义

package com.wjy.Data_Structure.linearlist.common;

import com.wjy.Data_Structure.linearlist.exception.InvalidNodeException;
import com.wjy.Data_Structure.linearlist.exception.OutOfBoundaryException;

//链接表接口
public interface LinkedList {
	/**
	 * 查询链接表当前的规模
	 *
	 * @return
	 */
	public int getSize();

	/**
	 * 判断列表是否为空
	 *
	 * @return
	 */
	public boolean isEmpty();

	/**
	 * 返回第一个结点
	 *
	 * @return
	 * @throws OutOfBoundaryException
	 */
	public Node first() throws OutOfBoundaryException;

	/**
	 * 返回最后一个结点
	 *
	 * @return
	 * @throws OutOfBoundaryException
	 */
	public Node last() throws OutOfBoundaryException;

	/**
	 * 返回p之后的结点
	 *
	 * @param p
	 * @return
	 * @throws InvalidNodeException
	 * @throws OutOfBoundaryException
	 */
	public Node getNext(Node p) throws InvalidNodeException, OutOfBoundaryException;

	/**
	 * 返回p之前的结点
	 *
	 * @param p
	 * @return
	 * @throws InvalidNodeException
	 * @throws OutOfBoundaryException
	 */
	public Node getPre(Node p) throws InvalidNodeException, OutOfBoundaryException;

	/**
	 * 将 e 作为第一个元素插入链接表,并返回 e 所在结点
	 *
	 * @param e
	 * @return
	 */
	public Node insertFirst(Object e);

	/**
	 * 将 e 作为后一个元素插入列表,并返回 e 所在结点
	 *
	 * @param e
	 * @return
	 */
	public Node insertLast(Object e);

	/**
	 * 将 e 插入至 p 之后的位置,并返回 e 所在结点
	 *
	 * @param p
	 * @param e
	 * @return
	 * @throws InvalidNodeException
	 */
	public Node insertAfter(Node p, Object e) throws InvalidNodeException;

	/**
	 * 将 e 插入至 p 之前的位置,并返回 e 所在结点
	 *
	 * @param p
	 * @param e
	 * @return
	 * @throws InvalidNodeException
	 */
	public Node inserBefore(Node p, Object e) throws InvalidNodeException;

	/**
	 * 删除给定位置处的元素，并返回之
	 *
	 * @param p
	 * @return
	 * @throws InvalidNodeException
	 */
	public Object remove(Node p) throws InvalidNodeException;

	/**
	 * 删除首元素，并返回之
	 *
	 * @return
	 * @throws InvalidNodeException
	 */
	public Object removeFirst() throws InvalidNodeException;

	/**
	 * 删除首元素，并返回之
	 *
	 * @return
	 * @throws InvalidNodeException
	 */
	public Object removeLast() throws InvalidNodeException;

	/**
	 * 将处于给定位置的元素替换为新元素，并返回被替换的元素
	 *
	 * @param p
	 * @param e
	 * @return
	 * @throws InvalidNodeException
	 */
	public Object replace(Node p, Object e) throws InvalidNodeException;

	/**
	 * 元素迭代器
	 *
	 * @return
	 */
	public Iterator elements();
}

迭代器接口定义

• 迭代器（Iterator）是程序设计的一种模式，它属于设计模式中的行为模式，它的功能是 提供一种方法顺序访问一个聚集对象中各个元素，而又不需暴露该对象的内部表示。
• 多个对象聚在一起形成的总体称之为聚集（Aggregate），聚集对象是能够包容一组对象 的容器对象。聚集依赖于聚集结构的抽象化，具有复杂性和多样性。例如数组就是一种基本的聚集。
• 聚集对象需要提供一种方法，允许用户按照一定的顺序访问其中的所有元素。而迭代器 提供了一个访问聚集对象中各个元素的统一接口，简单的说迭代器就是对遍历操作的抽象。

package com.wjy.Data_Structure.linearlist.common;

import com.wjy.Data_Structure.linearlist.exception.OutOfBoundaryException;

//迭代器接口
public interface Iterator {
	/**
	 * 移动到第一个元素
	 */
	public void first();

	/**
	 * 移动到下一个元素
	 */
	public void next() throws OutOfBoundaryException;

	/**
	 * 检查迭代器中是否还有剩余的元素
	 *
	 * @return
	 */
	public boolean isDone();

	/**
	 * 返回当前元素
	 *
	 * @return
	 */
	public Object currentItem();
}

链接表的实现

• 在在结点 p 之前插入 s

主要操作：

s.setPre (p.getPre()); 
p.getPre().setNext(s); 
s.setNext(p);  
p.setPre(s); 

• 删除结点 p

主要操作：

p.getPre().setNext(p.getNext());  p.getNext().setPre(p.getPre()); 

package com.wjy.Data_Structure.linearlist.listslinkimpl;

import com.wjy.Data_Structure.linearlist.common.DLNode;
import com.wjy.Data_Structure.linearlist.common.Iterator;
import com.wjy.Data_Structure.linearlist.common.LinkedList;
import com.wjy.Data_Structure.linearlist.common.Node;
import com.wjy.Data_Structure.linearlist.exception.InvalidNodeException;
import com.wjy.Data_Structure.linearlist.exception.OutOfBoundaryException;

//基于双向链表实现的链接表
public class LinkedListDLNode implements LinkedList {
	private int size; // 规模
	private DLNode head; // 头结点
	private DLNode tail; // 尾结点

	// 构建只有头尾结点的链表

	public LinkedListDLNode() {
		this.size = 0;
		this.head = new DLNode();
		this.tail = new DLNode();
		this.head.setNext(tail);
		tail.setPre(this.head);
	}

	// 辅助方法，判断结点 p 是否合法，如合法转换为 DLNode
	protected DLNode checkPosition(Node p) throws InvalidNodeException {
		if (p == null) {
			throw new InvalidNodeException("错误：p 为空。");
		}
		if (p == head) {
			throw new InvalidNodeException("错误：p 指向头节点，非法.");
		}
		if (p == tail) {
			throw new InvalidNodeException("错误：p 指向尾结点，非法.");
		}
		DLNode node = (DLNode) p;
		return node;

	}

	@Override
	public int getSize() {
		return size;
	}

	@Override
	public boolean isEmpty() {
		return size == 0;
	}

	@Override
	public Node first() throws OutOfBoundaryException {
		if (isEmpty()) {
			throw new OutOfBoundaryException("错误，链接表为空");
		}
		return head.getNext();
	}

	@Override
	public Node last() throws OutOfBoundaryException {
		if (isEmpty()) {
			throw new OutOfBoundaryException("错误：链接表为空");
		}
		return tail.getPre();
	}

	@Override
	public Node getNext(Node p) throws InvalidNodeException, OutOfBoundaryException {
		DLNode node = checkPosition(p);
		node = node.getNext();
		if (node == tail)
			throw new OutOfBoundaryException("错误： 已经是链接表尾端");
		return node;
	}

	@Override
	public Node getPre(Node p) throws InvalidNodeException, OutOfBoundaryException {
		DLNode node = checkPosition(p);
		node = node.getPre();
		if (node == head)
			throw new OutOfBoundaryException("错误：已经是链接表前段");
		return null;
	}

	@Override
	public Node insertFirst(Object e) {
		DLNode node = new DLNode(e, head, head.getNext());
		head.getNext().setPre(node);
		head.setNext(node);
		size++;
		return node;
	}

	@Override
	public Node insertLast(Object e) {
		DLNode node = new DLNode(e, tail.getPre(), tail);
		tail.getPre().setNext(node);
		tail.setPre(node);
		size++;
		return node;
	}

	@Override
	public Node insertAfter(Node p, Object e) throws InvalidNodeException {
		DLNode node = checkPosition(p);
		DLNode newNode = new DLNode(e, node, node.getNext());
		node.getNext().setPre(newNode);
		node.setNext(newNode);
		size++;
		return newNode;
	}

	@Override
	public Node inserBefore(Node p, Object e) throws InvalidNodeException {
		DLNode node = checkPosition(p);
		DLNode newNode = new DLNode(e, node.getPre(), node);
		node.getPre().setNext(newNode);
		node.setPre(newNode);
		size++;
		return newNode;
	}

	@Override
	public Object remove(Node p) throws InvalidNodeException {
		DLNode node = checkPosition(p);
		Object obj = node.getData();
		node.getPre().setNext(node.getNext());
		node.getNext().setPre(node.getPre());
		size--;
		return obj;
	}

	@Override
	public Object removeFirst() throws InvalidNodeException {
		return remove(head.getNext());
	}

	@Override
	public Object removeLast() throws InvalidNodeException {
		return remove(tail.getPre());
	}

	@Override
	public Object replace(Node p, Object e) throws InvalidNodeException {
		DLNode node = checkPosition(p);
		Object obj = node.getData();
		node.setData(e);
		return obj;
	}

	@Override
	public Iterator elements() {
		return new LinkedListIterator(this);
	}

}

基于 LinkedList 聚集对象的迭代器实现

package com.wjy.Data_Structure.linearlist.listslinkimpl;

import com.wjy.Data_Structure.linearlist.common.Iterator;
import com.wjy.Data_Structure.linearlist.common.LinkedList;
import com.wjy.Data_Structure.linearlist.common.Node;
import com.wjy.Data_Structure.linearlist.exception.OutOfBoundaryException;

public class LinkedListIterator implements Iterator {
	private LinkedList list;// 链接表
	private Node current;// 当前结点

	public LinkedListIterator(LinkedList list) {
		this.list = list;
		if (list.isEmpty())
			current = null;
		else
			current = list.first();// 从第一个元素开始
	}

	@Override
	public void first() {
		if (list.isEmpty())
			current = null;
		else
			current = list.first();// 从第一个元素开始

	}

	@Override
	public void next() throws OutOfBoundaryException {
		if (isDone())
			throw new OutOfBoundaryException("错误：已经没有元素");
		if (current == list.last())
			current = null;// 当前元素后面没有更多元素
		else
			current = list.getNext(current);
	}

	@Override
	public boolean isDone() {
		return current == null;
	}

	@Override
	public Object currentItem() {
		if (isDone())
			throw new OutOfBoundaryException("错误：已经没有元素");
		return current.getData();
	}

}