链表存储java实现

顺序存储

线性表可以采用顺序存储，也就是用数组存储，这个方法虽然简单但是优缺点如下：

1. 插入耗费时间，O(n)，若正好插入第一位，那么就正好移动N个元素，平均值n/2

2.  删除耗费时间，O(n)，若删除的元素正好在第一位，那么就正好移动N-1个元素，平均值n-1/2

3.  取元素，比较简单，O(1)，比如取第3个

4.  总结，增删查改，增删耗费时间，查改节省时间

链式存储

单连表分为两种

1. 双向链表（Double linked list）更加普遍，易删除，但占用空间

2. 单向链表（Single linked list）不太普遍，不易删除，但节省空间

双向链表实现

1. 插入（insert）

head指针，prev == null 的为head，head为单独的一个存储指针，用于指向链表的头部。若无特殊要求，插入操作默认在头部进行。因为在头部插入更加高效O(1)，如果是尾部O(n）

2. 删除（remove）

直接跳过要删除的node节点即可

Node类

class Node
{
	int value;
	Node pre;
	Node next;
	Node(int key)
	{
		pre = null;
		next = null;
		value = key;
	}
}

双向链表类

public class DoubleLinkedList {
	Node head;
	public DoubleLinkedList()
	{
		head = null;
	}
	public boolean isEmpty() 
	{
		if (head == null) 
		{
			return true;
		}
		else 
		{
			return false;
		}
	}
	public Node search(int key) throws Exception 
	{
		Node ret = null;
		Node temp = head;
		if (isEmpty()) {
			throw new Exception("The list is Empty!");
		}
		else {
			while(temp != null) 
			{
				if (temp.value == key) 
				{
					ret = temp;
				}
				else 
				{
					temp = temp.next;
				}
			}
			return ret;	
		}
	}
	public void insert(Node node) throws Exception 
	{
		if (node == null) 
		{
			throw new Exception("The node is null!");
		}
		else 
		{
			if (isEmpty()) 
			{
				head = node;
			}
			else 
			{
				head.pre = node;
				node.next = head;
				node.pre = null;
				head = node;
			}
			
		}
	}
	public void print()throws Exception 
	{
		if(isEmpty())
		{
			throw new Exception("The list is null!");
		}
		else 
		{
			Node temp = head;
			while(temp != null) 
			{
				System.out.println(temp.value);
				temp = temp.next;
			}
		}
	}
	public void remove(Node node) throws Exception 
	{
		if (node.pre != null) 
		{
			node.pre.next = node.next;
		}
		else 
		{
			head = node.next;
		}
		if (node.next != null) 
		{
			node.next.pre = node.pre;
		}
		else 
		{
			;
		}
	}
	public void reverse() 
	{
		Node temp = null;
		temp = head;
		while(temp != null) 
		{
			Node change = null;
			change = temp.next;
			temp.next = temp.pre;
			temp.pre = change;
			head = temp;
			temp = temp.pre;
		}
	}
	public static void main(String[] args) throws Exception 
	{
		DoubleLinkedList dl = new DoubleLinkedList();
		Node node1 = new Node(5);
		Node node2 = new Node(6);
		Node node3 = new Node(7);
		dl.insert(node1);
		dl.insert(node2);
		dl.insert(node3);
		dl.print();
		dl.reverse();
		dl.print();
		
	}
}