java实现单向链表

    之前没怎么接触过C++，对链表，数组等数据结构只是有个大概的了解；最近突然有了兴趣，用Java实现了各种数据结构！

   
    下面是单向链表的实现

    单向链表能唯一确定的只有第一个节点，每个节点有指向下一节点的指针域，最后的一个节点的指针域指向Null；

    下面是具体实现：

    先是一个单向链表类：

   

package com.zxd.link;

/**
 * SinglyLinkNode：单向链表对象
 *
 * @author   zeng.xiangdong 1770534116@qq.com
 * @version  V1.0	2014-7-2 下午10:32:46
 */
public class SinglyLinkedNode {
	//节点数据
	private int data;
	//下一个节点
	private SinglyLinkedNode nextNode;
		
	public SinglyLinkedNode(int data) {
		this.data = data;
		nextNode = null;
	}
	
	public int getData() {
		return data;
	}
		
	public void setData(int data) {
		this.data = data;
	}

	public SinglyLinkedNode getNextNode() {
		return nextNode;
	}

	public void setNextNode(SinglyLinkedNode nextNode) {
		this.nextNode = nextNode;
	}
		
	/**
	 * Creates a new instance of Node.
	 *
	 */
	public String toString() {
		return String.valueOf(getData());
	}
	
}

下面是单向链表的具体实现：

 

 

package com.zxd.link;

/**
 * SinglyLinkedList：Java单向非循环链表的实现
 * 单向非循环链表：能确定的只有第一个节点，并且每个节点有指向下一个节点的指针域，最后一个节点的指针指向一个NULL
 *
 * @author   zeng.xiangdong 1770534116@qq.com
 * @version  V1.0	2014-6-30 下午11:09:44
 */
public class SinglyLinkedList {

	//第一个节点
	private SinglyLinkedNode headNode;
	
	/**
	 * SinglyLinkedList:构造方法
	 * 
	 * @param data 第一个节点数据
	 * */
	public SinglyLinkedList(int data) {
		headNode = new SinglyLinkedNode(data);
	}
	
	/**
	 * insert:在表头插入一条数据
	 *
	 * @param dataNode 要插入的数据
	 */
	public void insertFirst(SinglyLinkedNode dataNode) {
		if(headNode == null) {
			headNode = dataNode;
		} else {
			//dataNode的指针指向原先的第一个节点            
			SinglyLinkedNode temp = headNode;
            dataNode.setNextNode(temp);
			headNode = dataNode;
		}
	} 
	
	/**
	 * insertLast:在链表的最后插入一条数据
	 * 
	 * @param dataNode 要插入的数据
	 * @throws Exception 
	 */
	public void insertLast(SinglyLinkedNode dataNode) throws Exception {
		if(headNode == null) {
			headNode = dataNode;
		} else {
			//最后一个节点的nextNode置为null
			dataNode.setNextNode(null);
			
			//判断是否是还有下一个节点
			SinglyLinkedNode lastNode = getLastNode();
			
			lastNode.setNextNode(dataNode);
		}
	}
	
	/**
	 * insert:在链表的指定位置插入数据
	 * 
	 * @param node 要插入的数据
	 * @param index 要插入的位置
	 * */
	public void insert(SinglyLinkedNode node, int index) throws Exception {
		SinglyLinkedNode currentNode = null;
		SinglyLinkedNode nextNode = null;
		
		if(headNode == null) {
			throw new Exception("null link list");
		} else {
			
			if(index == 0) {
				node.setNextNode(headNode);
				headNode = node;
			} else {
				currentNode = headNode;
				for(int i = 0; i < index - 1; i++) {
					nextNode = currentNode.getNextNode();
					
					currentNode = nextNode;
				} // end of for
				
				//currentNode 保存了要保存节点的前一个节点信息
				SinglyLinkedNode tempNode = currentNode.getNextNode();
				currentNode.setNextNode(node);
				node.setNextNode(tempNode);
			}
		} // end of else
	}

	/**
	 * deleteFirst:删除链表的第一条数据，即表头，并返回
	 * 
	 * @return firstNode
	 * */
	public SinglyLinkedNode deleteFirst() throws Exception{
		if(headNode == null) {
			throw new Exception("null link list");
		} else {
			SinglyLinkedNode currentNode = headNode;
			SinglyLinkedNode tempNode = headNode.getNextNode();

			headNode = tempNode;
			
			return currentNode;
		} // end of else
	}
	
	/**
	 * deleteLast:删除链表的最后一条数据，并返回
	 * 
	 * @param lastNode
	 * */
	public SinglyLinkedNode deleteLast() throws Exception{
		if(headNode == null) {
			throw new Exception("null link list");
		} else {
			SinglyLinkedNode preNode = headNode;
			SinglyLinkedNode currentNode = headNode.getNextNode();
			while(hasNext(currentNode)) {
				preNode = currentNode;
				currentNode = currentNode.getNextNode();
			}
			
			preNode.setNextNode(null);
			
			return currentNode;
		} // end of else
	}

	/**
	 * deleteByIndex:删除指定索引的节点，并返回
	 * 
	 * @param index 索引，下表从0开始
	 * */
	public SinglyLinkedNode deleteByIndex(int index) throws Exception{
		if(headNode == null) {
			throw new Exception("null link list");
		} else {
			SinglyLinkedNode preNode = headNode;
			SinglyLinkedNode currentNode = headNode.getNextNode();
			
			for(int i = 0; i < index; i++) {
				preNode = currentNode;
				currentNode = currentNode.getNextNode();
			}
			
			preNode.setNextNode(currentNode.getNextNode());
			
			return currentNode;
		} // end of else
	}
	
	/**
	 * getNodeByIndex:根据索引获得指定节点
	 *
	 * @return index 索引 下标从0开始 
	 * @throws Exception 
	*/
	public SinglyLinkedNode getNodeByIndex(int index) throws Exception{
		SinglyLinkedNode currentNode = null;
		SinglyLinkedNode nextNode = null;
		
		if(headNode == null) {
			throw new Exception("null linked list");
		} else {
			currentNode = headNode;
			
			//从第一个节点开始遍历：只有第一个节点是确定的
			for(int i = 0; i < index; i++) {
				//判断是否到最后了
				if(currentNode == null) {
					throw new Exception("the index is beyond the length of linked list");
				}
				
				if(hasNext(currentNode)) {
					nextNode = currentNode.getNextNode();
					currentNode = nextNode;
				} else {
					currentNode = null;
				}
				
			} // end of for
			
		} // end of else
		
		return currentNode;
	}
	
	/**
	 * isLast:判断节点是否是最后的节点
	 *
	 * @param node
	 * @return
	*/
	public boolean isLast(SinglyLinkedNode node) {
		return node.getNextNode() == null ? true : false;
	}

	/**
	 * getLastNode:取得链表的最后一个节点
	 *
	 * @return lastNode 
	 * @throws Exception 
	*/
	public SinglyLinkedNode getLastNode() throws Exception {
		SinglyLinkedNode currentNode = null;
		SinglyLinkedNode nextNode = null;
		
		if(headNode == null) {
			throw new Exception("null linked list");
		} else {
			currentNode = headNode;
			while(hasNext(currentNode)) {
				nextNode = currentNode.getNextNode();
				currentNode = nextNode;
			}
			
		} // end of else
		
		return currentNode;
	}

	/**
	 * hasNext:判断已有是否有下一个节点
	 *
	 * @param dataNode
	*/
	public boolean hasNext(SinglyLinkedNode dataNode) {
		if(dataNode.getNextNode() == null) {
			return false;
		}
		
		return true;
	}

	/**
	 * main:测试main方法
	 *
	 * @param args
	 */
	public static void main(String[] args) throws Exception {
		//初始化链表
		SinglyLinkedList list = new SinglyLinkedList(0);
		for(int i = 1; i < 10; i++) {
			list.insertLast(new SinglyLinkedNode(i));
		}
		
		//输出链表
		System.out.print("list : ");
		for(int i = 0; i < 10; i++) {
			System.out.print(list.getNodeByIndex(i) + " ");
		}
		System.out.println();
		
		//删除表头
		list.deleteFirst();
		
		//删除表尾
		list.deleteLast();

                //插入 		
		list.insert(new SinglyLinkedNode(11), 0);
		for(int i = 0; i < 9; i++) {
			System.out.print(list.getNodeByIndex(i) + " ");
		}
		System.out.println();

	} // end of main
	
}

 

输出结果：