记录我学习数据结构之路（八）

线性表的顺序存储的缺点就是插入和删除的时候需要移动大量的数据，这是非常耗时间的。那应该换一种思路，在第一个元素的时候，就知道第二个元素的位置；在第二个的时候就找到了第三个的位置，以此类推。这样，只要记录下下一个的位置了，不管数据存在哪里，都能顺利地找到下一个结点的位置。

代码实现：

/***
 * 单链表节点类
 * @author link
 *
 */
public class Node {
	public int iNum;
	public double dNum;
	public Node next;   //指向下一个结点

	public Node(int i,double d){
		iNum = i;
		dNum = d;
	}

	public void show(){
		System.out.print("{"+iNum+","+dNum+"}");
	}
}

/***
 * 单链表类
 * @author link
 *
 */
public class LinkedList {
	private Node first; //声明结点对象

	public LinkedList(){
		first = null;
	}
	/*
	 * 插入方法：创建一个结点对象，然后让这个结点的下一个结点指向first对象，然后把这个对象赋值给first对象
	 */
	public void insertFirst(int i,double d){
		Node node = new Node(i, d);
		node.next = first;
		first = node;
	}

	public boolean isEmpty(){
		return first == null;
	}
	/*
	 * 删除第一个结点：让下一个节点变成第一个结点就行了
	 */
	public Node deleteFirst(){
		Node temp = first;
		first = first.next;
		return temp;
	}
	/*
	 * 删除某个指定的结点：循环判断当前结点寻找对应的结点后，如果是第一个结点，直接让下一个结点成为第一个结         * 点，如果不是第一个节点，就让当前结点的前一个结点指向当前结点的下一个结点就行了
	 */
	public Node delete(int i){
		Node current = first;//声明当前结点
		Node pervious = first;//声明当前结点的前一个节点
		while(current.iNum != i){
			if(current.next == null)return null;
		else{
			pervious = current;
			current = current.next;
			}
		}
		if(current == first)
			first = first.next;
		else{
			pervious.next = current.next;
		}
		return current;
	}
	/*
	 * 寻找某个结点：循环当前结点，如果找到则推出循环返回结点，如果没找到就指向下一个结点继续寻找
	 */
	public Node find(int i){
		Node current = first;
		while(current.iNum != i){
			if(current.next == null){
				return null;
			}else{
				current= current.next;
			}
		}
		return current;
	}

	public void display(){
		System.out.print("List(first-->last):");
		Node current = first;
		while(current!=null){
			current.show();
			current = current.next;
		}
		System.out.println();
	}
}

/***
 * 测试类
 * @author link
 *
 */
public class LinkListApp {

	public static void main(String[] args) {
		LinkedList list = new LinkedList();
		list.insertFirst(12, 2.3);
		list.insertFirst(42, 3.5);
		list.insertFirst(89, 12.2);
		list.insertFirst(41, 5.5);
		list.insertFirst(21, 2.8);
		list.insertFirst(43, 2.2);
		list.insertFirst(67, 6.9);
		list.display();
		list.delete(89);
		list.display();

		Node temp = list.find(41);
		if(temp != null){
			System.out.println("Found:{"+temp.iNum+","+temp.dNum+"}");
		}else{
			System.out.println("Can not find!");
		}
	}

}

运行结果：

List(first-->last):{67,6.9}{43,2.2}{21,2.8}{41,5.5}{89,12.2}{42,3.5}{12,2.3}

List(first-->last):{67,6.9}{43,2.2}{21,2.8}{41,5.5}{42,3.5}{12,2.3}

Found:{41,5.5}

简单总结一下单链表结构与顺序存储结构的优缺点：在存储分配方式中，顺序存储结构用一段连续的存储单元依次存储线性表的数据元素；单链表采用链式存储结构，用一组任意的存储单元存放线性表的元素。在时间性能上，查找数据操作时，顺序存储结构为O(1)，单链表为O(n)；插入和删除操作时，顺序存储结构需要平均移动表长一半的元素，时间为O(n)，单链表在找出某位置的指针后，插入和删除是间仅为O(1)。在空间性能上，顺序存储结构需要预分配存储空间，分大了，浪费，分小了容易发生溢出；单链表不需要分配存储空间，只要有就可以分配，元素个数也不受限制。