Java_LinkedList_数据结构

    java api 在包java.util.LinkedList中有一个LinkedList双向链表类;在由于最近有许多的java课程作业，兴趣之余自己写了一个类似的LinkedList类。由于是从C/C++转向java的，代码中还是有许多C风格的。

抽象类：LinearList.java

/**
 * <p>文件<code>LinearList.java</code>线性表抽象类.</p>
 * @author  liyang
 * @time  2012-04-12
 */
package com.homework.datastructure;

public abstract class LinearList<Type> {
	public int length = 0;

	/**
	 * <p>获取当前的表长</p>
	 * @return 返回当前线性表的表长.
	 */
	public int getLength(){return this.length;}
	
	/**
	 * 判断线性表是否为空
	 * @return 若表为空,返回true;否则,返回false.
	 */
	public boolean isEmpty(){return this.length == 0;}

	/**
	 * <p>获取在index索引处的记录.</p>
	 * @param index 记录位置
	 * @return 若index合法,返回index处的记录;否则,返回null.
	 */
	public abstract Type getElem(int index);

	/**
	 *  <p>头插</p>
	 * @param e 要插入的元素
	 * @return 插入成功,返回true;否则,返回false.
	 */
	public abstract boolean pushFront(Type e);

	/**
	 * <p>头删</p>
	 * @return 删除成功,返回删除的元素;否则,返回null.
	 */
	public abstract Type popFront();

	/**
	 * <p>尾插</p>
	 * @param e 要插入的元素
	 * @return 插入成功,返回true;否则,返回false.
	 */
	public abstract boolean pushBack(Type e);

	/**
	 *  <p>尾删</p>
	 * @return 删除成功,返回删除的元素;否则,返回null.
	 */
	public abstract Type popBack();

	/**
	 * <p>在index索引处插入元素为e的新记录.</p>
	 * @param e 要插入的元素
	 * @param index 要插入的位置
	 * @return 插入成功返回true;否则,返回false.
	 */
	public abstract boolean insert(Type e,int index);

	/**
	 * <p>删除在index索引处的记录.</p>
	 * @param index 预删除记录的索引位置
	 * @return 删除成功,返回删除的元素;否则,返回null.
	 */
	public abstract Type delete(int index);

	/**
	 *  <p>查找线性表中第一个元素为value的记录位置.</p>
	 * @param value 查找的元素
	 * @return 查找成功,返回对应的索引位置;否则,返回-1.
	 */
	public abstract int search(Type value);

	/**
	 * <p>清除线性表的所有记录.</p>
	 * @return 若线性表为空,则不必执行该操作,返回false;线性表不为空,清除后返回true.
	 */
	public abstract boolean clear();
}

 具体实现类：LinkedList.java

 

package com.homework.datastructure;

/**
 * <p>文件<code>LinkedList.java</code>链表类.</p> 
 * <p>动态链表：利用java泛型技术实现.</p>
 * @author  liyang
 * @time  2012-04-12
 * @param <Type> 初始值
 */
public class LinkedList<Type> extends LinearList<Type>{

	private final int MAX_SIZE = 100;	

	/**
	 * <p>动态定义链表结点</p>
	 * @author  liyang
	 */
	private class Node{
		Type data;
		Node next;

		public Node(){
			next = null;
		}
		public Node(Type value){
			this.data = value;
			next = null;
		}
	};

	//头结点
	Node head = new Node();

	@Override
	public Type getElem(int index){

		if(index <= 0 || index >this.length){
			return null;
		}
		Node p = head.next;
		while(true){
			index--;
			if(index == 0){
				break;
			}
			p = p.next;
		}

		return p.data;
	}

	@Override
	public boolean pushFront(Type e) {
		if(this.length >= MAX_SIZE){
			return false;
		}

		Node p = new Node(e);
		p.next = head.next;
		head.next = p;
		this.length++;
		return true;
	}

	@Override
	public Type popFront() {
		if(head.next == null){
			return null;
		}
		Type e = head.next.data;
		head.next = head.next.next;
		this.length--;

		return e;
	}

	@Override
	public boolean pushBack(Type e) {
		if(head.next == null){
			return false;
		}
		Node p = head.next;
		while(p.next != null){
			p = p.next;
		}

		Node q = new Node(e);
		p.next = q;
		this.length++;
		return true;
	}

	@Override
	public Type popBack() {
		if(head.next == null){
			return null;
		}
		Node p = head;
		while(p.next.next != null){
			p = p.next;
		}

		Type e = p.next.data;
		p.next = p.next.next;

		this.length--;
		return e;
	}

	@Override
	public boolean insert(Type e, int index) {
		if(index <= 0 || index > this.length || (index + this.length) > MAX_SIZE){
			return false;
		}
		Node p = head;
		while(true){
			index--;
			if(index == 0){
				break;
			}
			p = p.next;
		}
		Node q = new Node(e);
		q.next = p.next;
		p.next = q;
		this.length++;

		return true;
	}

	@Override
	public Type delete(int index){
		if(index <= 0 || index > this.length){
			return null;
		}
		Node p = head;
		while(true){
			index--;
			if(index == 0){
				break;
			}
			p = p.next;
		}
		Type  e = p.next.data;
		p.next = p.next.next;
		this.length--;
		return e;
	}

	@Override
	public int search(Type value) {
		Node p = head.next;
		int i = 1;
		while(p.data != value){
			i++;
			p = p.next;
		}
		return (i <= length) ? i : -1;
	}
	
	@Override
	public boolean clear(){
		if(head.next == null){
			return false;
		}
		head.next = null;
		this.length = 0;
		return true;
	}
}

java的泛型技术还是不错的。