数据结构——链表表的实现

package list.linkedlist;

/**
 * 线性表接口List的定义如下
 *
 */
public interface List<E> {
	public Object value(int pos);// 返回线性表中地pos个元素的值

	boolean add(Object obj, int pos);// 向第pos个元素位置插入一个元素obj

	void remove(int pos);// 删除第pos个元素并返回，若不存在返回空

	int find(Object obj);// 从表头查找等于obj值的第一个元素，返回序号

	boolean modify(Object obj, int pos);// 用obj修改线性表中给定序号pos的元素值

	boolean isEmpty();// 判断线性表是否为空

	int size();// 返回线性表的长度

	String forward();// 正向遍历输出线性表中所有元素

	String backward();// 反向遍历输出线性表中所有元素

	void clear();// 清除线性表中所有元素
	
}

<pre name="code" class="java">package list.linkedlist;

/**
 * 链表中单个节点类
 * 
 */
public class Node {
	Object element;// 当前节点的值
	Node next;// 当前节点保存的下一个节点指针域

	public Node(Node next) {//只对next赋值
		this.next = next;
	}

	public Node(Object element, Node next) {//对两个域同时赋值
		this.element = element;
		this.next = next;
	}
}

package list.linkedlist;


/**
 * 带附加表头节点的循环单链表
 */
public class LinkList<T> implements List<T> {

	private Node head;// 头结点
	private int length;// 单链表的长度

	/**
	 * 初始化线性表为空
	 */
	public LinkList() {// 无参构造函数
		this.length = 0;// 线性表的初始长度为0
		this.head = new Node(null);// 初始化头结点
		this.head.next = head;// 构成单链接循环空表
	}

	/**
	 * 得到线性表中第pos个元素的值
	 */
	public Object value(int pos) {
		if (pos < 1 || pos > this.length) {
			return null;
		}
		int count = 1;// 计数
		Node p = head.next;// 指向附加表头节点
		while (count < pos) {
			p = p.next;
			count++;
		}
		return p.element;
	}

	/**
	 * 向线性表中给定位置上插入一个元素
	 * 
	 * 1.对参数pos值进行判断，若pos无效，返回失败
	 * 
	 * 2.扫描得到单链表的第pos个节点位置，此扫描需要设置前后两个指针，一个指向待扫描的节点，一个指向其前驱节点
	 * 
	 * 3.根据插入元素创建一个新节点，并链接到单链表中
	 * 
	 * 4.使线性表的长度增加1，返回真
	 */
	public boolean add(Object obj, int pos) {
		// 向线性表的第pos个位置插入一个元素
		if (pos < 1 || pos > length + 1) {
			return false;
		}

		int count = 1;
		Node p = this.head;// p指向头指针,q的前驱节点
		Node q = head.next;// q指向附加头结点
		while (count < pos) {
			p = q;
			q = q.next;
			count++;
		}
		// 退出循环的时候count = pos，就是要插入的位置
		p.next = new Node(obj, q);// 在第pos位置插入新节点，新节点next指向q
		this.length++;// 线性表的长度加1
		return true;
	}

	/**
	 * 从链表中删除给定位置的元素
	 */
	public void remove(int pos) {
		if (pos >= 1 || pos <= this.length) {
			int num = 1;
			Node p = head;
			Node q = head.next;
			while (num < pos) {
				p = q;
				q = q.next;
				num++;
			}
			p.next = q.next;
			this.length--;
		}
	}

	/**
	 * 查找具有指定值的元素，返回第一次出现的位置
	 */
	public int find(Object obj) {
		int num = 1;
		Node p = head.next;// 单链表的表头
		while (p != null && !p.element.equals(obj)) {
			p = p.next;
			num++;
		}
		if (p == head)
			return -1;
		return num;
	}

	/**
	 * 修改链表指定位置的元素的值
	 */
	public boolean modify(Object obj, int pos) {
		if (pos < 1 || pos > this.length)
			return false;
		int num = 1;
		Node p = head.next;
		while (num < pos) {
			p = p.next;
			num++;
		}
		p.element = obj;
		return true;
	}

	public boolean isEmpty() {
		return this.length == 0;
	}

	public int size() {
		return this.length;
	}

	/**
	 * 正向遍历
	 */
	public String forward() {
		String str = "";
		Node p = this.head.next;
		while (p != head) {
			str += p.element.toString() + "   ";
			p = p.next;
		}
		return str;
	}

	/**
	 * 反向遍历
	 */
	public String backward() {
		String str = "";
		Object[] temp = new Object[this.length];
		int i = 0;
		Node p = head.next;
		while (p != head) {
			temp[i++] = p.element;
			p = p.next;
		}
		for (int j = this.length - 1; j >= 0; j--){
			str += temp[j] + "  ";
		}
			return str;
	}

	/**
	 * 清空链表
	 */
	public void clear() {
		this.head.next = head;
		this.length = 0;
	}

}

package list.linkedlist;

public class TestLinkedList {
	public static void main(String[] args) {
		LinkList<Integer> list = new LinkList<Integer>();
		list.add(1,1);
		list.add(2,2);
		list.add(3,1);
		System.out.println(list.forward());
		list.remove(1);
		System.out.println(list.forward());
		System.out.println(list.find(1));
		list.modify(0, 1);
		System.out.println(list.forward());
		System.out.println(list.backward());
	}
}