数据结构-单向链表（一）（JAVA）

1.数据结构之链表

链表是一种按照线性顺序排列各对象的数据结构。数组的线性顺序是由数组下标决定的，然而与数组不同的是，链表的顺序        是由各个对象里面的指针决定的。链表为动态集合提供了一种简单而灵活的表示方式。

单向链表中每个对象有一个元素和一个next指针，指向下一个链表对象：x为单向链表中的一个元素，x.next指向它在链表中的

后继元素。链表中最后一个元素是没有后继元素的，它的指针则指向null。

这里单向链表添加元素的原则按照先进后出的原则，也就是说，顺序添加链表元素，最新添加的元素就是头元素。当然也可以

按照先进后出的原则创建链表。

<整体的链表实现代码在最后>

2.链表的操作

添加元素：

/**
	 * 对链表进行添加元素
	 */
	public void add(int data) {
		// 创建节点
		Node newNode = new Node(data);

		if (null == head) {
			// 如果头节点为空，则当前的节点为头节点
			head = newNode;
			return;
		}

		// 当前头节点不为空,则将要添加的节点放到最前
		newNode.next = head;
		head = newNode;
	}

向指定位置添加元素：

代码实现：

/**
	 * 向链表指定位置进行添加元素
	 * 
	 * @param index
	 *            指定添加元素的位置索引
	 * @param data
	 *            要添加的元素
	 */
	public void add(int index, int data) {
		// 创建节点
		Node newNode = new Node(data);

		if (null == head) {
			// 如果头节点为空，则当前的节点为头节点
			head = newNode;
			return;
		}

		// 如果索引是0，添加元素为头元素
		if (index == 0) {
			newNode.next = head;
			head = newNode;
			return;
		}
		// 遍历当前链表
		for (int i = 1; i < this.getLength(); i++) {
			if (i == index) {
				// 当前元素的前一个元素的后继元素指向要插入的节点元素
				this.get(i - 1).next = newNode;
				// 要插入的节点元素的后继元素指向当前元素
				newNode.next = this.get(i);
				break;
			}
		}
	}

删除元素：

代码实现：

/**
	 * 删除链表元素
	 * 
	 * @param data
	 */
	public void delete(int data) {
		// 先找到要删除的节点
		Node node = this.select(data);
		if (null == node) {
			// 要删除的节点不存在
			System.out.println("error:node do not exits");
			return;
		}
		// 将找到的node节点删除
		Node tempNode = head;
		// 如果头节点就是要删除的元素
		if (head.data == data) {
			head = head.next;
			return;
		}
		while (null != tempNode && tempNode.next.data != node.data) {
			tempNode = tempNode.next;
		}
		tempNode.next = node.next;
	}

 替换操作：

代码实现：

/**
	 * 替换指定位置的元素
	 * 
	 * @param index
	 *            替换元素的位置索引
	 * @param data
	 *            新元素
	 */
	public void replace(int index, int data) {
		Node newNode = new Node(data);

		if (index == 0) {
			head = newNode;
			return;
		}

		// 遍历当前链表
		for (int i = 1; i < this.getLength(); i++) {
			if (i == index) {
				newNode.next = this.get(i).next;
				this.get(i - 1).next = newNode;
				break;
			}
		}

	}

3.链表的代码实现

先创建一个节点类：

package com.yushen.linkedlist;

/**
 * 单向链表
 * 
 * @author yushen
 * 
 */
public class Node {

	public Node next;//指向后继节点的指针
	public int data;

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

链表的实现代码：

package com.yushen.linkedlist;

/**
 * 对单向链表的操作
 * 
 * @author Administrator
 * 
 */
public class LinkedList {

	// 第一次调用，将头节点置空
	Node head = null;

	/**
	 * 寻找指定data的节点
	 * 
	 * @param linkedList
	 *            一个链表
	 * @param data
	 *            要寻找的数据
	 * @return
	 */
	public Node select(int data) {
		// 从头节点开始
		Node node = head;
		// 只要node节点不为空且node节点的data不是要找的数据，就一直往后找
		while (null != node && node.data != data) {
			node = node.next;
		}
		return node;
	}

	/**
	 * 对链表进行添加元素
	 */
	public void add(int data) {
		// 创建节点
		Node newNode = new Node(data);

		if (null == head) {
			// 如果头节点为空，则当前的节点为头节点
			head = newNode;
			return;
		}

		// 当前头节点不为空,则将要添加的节点放到最前
		newNode.next = head;
		head = newNode;
	}

	/**
	 * 向链表指定位置进行添加元素
	 * 
	 * @param index
	 *            指定添加元素的位置索引
	 * @param data
	 *            要添加的元素
	 */
	public void add(int index, int data) {
		// 创建节点
		Node newNode = new Node(data);

		if (null == head) {
			// 如果头节点为空，则当前的节点为头节点
			head = newNode;
			return;
		}

		// 如果索引是0，添加元素为头元素
		if (index == 0) {
			newNode.next = head;
			head = newNode;
			return;
		}
		// 遍历当前链表
		for (int i = 1; i < this.getLength(); i++) {
			if (i == index) {
				// 当前元素的前一个元素的后继元素指向要插入的节点元素
				this.get(i - 1).next = newNode;
				// 要插入的节点元素的后继元素指向当前元素
				newNode.next = this.get(i);
				break;
			}
		}
	}

	/**
	 * 删除链表元素
	 * 
	 * @param data
	 */
	public void delete(int data) {
		// 先找到要删除的节点
		Node node = this.select(data);
		if (null == node) {
			// 要删除的节点不存在
			System.out.println("error:node do not exits");
			return;
		}
		// 将找到的node节点删除
		Node tempNode = head;
		// 如果头节点就是要删除的元素
		if (head.data == data) {
			head = head.next;
			return;
		}
		while (null != tempNode && tempNode.next.data != node.data) {
			tempNode = tempNode.next;
		}
		tempNode.next = node.next;
	}

	/**
	 * 返回链表的长度
	 * 
	 * @return
	 */
	public int getLength() {
		int length = 0;
		Node node = head;
		while (null != node) {
			length++;
			node = node.next;
		}
		return length;
	}

	/**
	 * 返回指定位置的元素
	 * 
	 * @param linkedList
	 * @param index
	 * @return
	 */
	public Node get(int index) {
		Node node = head;
		int length = 0;
		while (null != node && length != index) {
			length++;
			node = node.next;
		}
		return node;
	}

	/**
	 * 替换指定位置的元素
	 * 
	 * @param index
	 *            替换元素的位置索引
	 * @param data
	 *            新元素
	 */
	public void replace(int index, int data) {
		Node newNode = new Node(data);

		if (index == 0) {
			head = newNode;
			return;
		}

		// 遍历当前链表
		for (int i = 1; i < this.getLength(); i++) {
			if (i == index) {
				newNode.next = this.get(i).next;
				this.get(i - 1).next = newNode;
				break;
			}
		}

	}
}

测试代码：

package com.yushen.linkedlist;
public class Test {

	public static void main(String[] args) {

		LinkedList linkedList = new LinkedList();
		linkedList.add(1);
		linkedList.add(2);
		linkedList.add(3);
		linkedList.add(4);
		linkedList.add(5);
		System.out.println("length:" + linkedList.getLength());
		
		linkedList.delete(4);
		System.out.println("length:" + linkedList.getLength());
		linkedList.add(0, 10);
		System.out.println("length:" + linkedList.getLength());
		linkedList.replace(1, 8);
		System.out.println("length:" + linkedList.getLength());
		for (int i = 0; i < linkedList.getLength(); i++) {
			System.out.println(linkedList.get(i).data);
		}
		System.out.println("length:" + linkedList.getLength());
	}

}