单链表与双向链表的Java实现

链表是一种物理存储单元上非连续、非顺序的存储结构。链表的机制灵活，它可以替代数组成为栈、队列的基础存储结构。链表比数组来说，没有大小限制，插入删除不基本需要移动元素。

链表的概念，就像有一群人，其中一个人举起一面旗子。而其他的人必须抓住另一个的后背，而且只能抓住一个。这样，所有的人就形成了一条人链，这个结构就是链表，而人就是链节点。

首先，我们先将链节点的代码写上：

public class Link
{
//id,数据,下一个
public int id;
public int data;
public Link next;

public Link(int id,int data)
{
this.id = id;
this.data = data;
this.next = null;
}

//显示数据
public String displayLink()
{
return "<ID:" + id +",Data:" + data + ",Next:"+ (next == null?"null":next.id) + ">";
}

}
然后，构建链表，他包括插入、删除、判空、显示、查找等方法，其代码如下：

public class LinkedList
{
//链表头
private Link first;

public LinkedList()
{
first = null;
}

//显示整个链表
public void displayLinkedList()
{
Link current =first;
StringBuffer sb = new StringBuffer("");

if(current == null )
sb.append("链表为空。");
else
sb.append("链表如下：\n");

while(current != null)
{
sb.append(current.displayLink()+"\n");
current = current.next;
}
System.out.println(sb.toString());
}

//插入
public void insertFrist(int id,int data)
{
Link newLk = new Link(id,data);
newLk.next = first;
first = newLk;
}

//删除
public Link delectFrist()
{
if(!isEmpty())
{
Link tempLk = first;
first = first.next;
return tempLk;
}
else
throw new IndexOutOfBoundsException("链表已空");
}

//判空
public boolean isEmpty()
{
return first == null;
}

//查找特定元素
public Link find(int data)
{
Link current =first;

while(current != null)
{
if(current.data == data)
return current;
current = current.next;
}
return null;
}

//删除特定元素
public Link delete(int data)
{
Link current = first;
Link crtParent = null;

while(current != null)
{
if(current.data == data)
{
if(crtParent == null)
first = first.next;
else
crtParent.next = current.next;
return current;
}
crtParent = current;
current = current.next;
}
return null;
}

public static void main(String[] args) {
LinkedList ll = new LinkedList();
ll.insertFrist(1, 0);
ll.insertFrist(2, 11);
ll.insertFrist(3, 9);
ll.insertFrist(4, 93);
ll.insertFrist(5, 12);
ll.insertFrist(6, 16);
ll.displayLinkedList();
}
}

这是一个单链表类，只能通过next后继遍历元素，大家可以看出，链头插入元素只需要修改next标志位，不需要移动后面的元素，我们测试一下：

链表如下：
<ID:6,Data:16,Next:5>
<ID:5,Data:12,Next:4>
<ID:4,Data:93,Next:3>
<ID:3,Data:9,Next:2>
<ID:2,Data:11,Next:1>
<ID:1,Data:0,Next:null>
另外，如果单链表中各元素都是有序的，那就叫有序链表，我们为其编写一个新的有序插入方法，其代码如下：

//插入有序
public void insertForSort(int id,int data)
{
Link current = first;
Link crtParent = null;
Link newLk = new Link(id,data);

while(current != null && current.data <= data)
{
crtParent = current;
current = current.next;
}

if(crtParent == null)
first = newLk;
else
crtParent.next = newLk;
newLk.next = current;
}

将mian方法中的insertFrist修改为insertForSort。测试一下，结果如下：

链表如下：
<ID:1,Data:0,Next:3>
<ID:3,Data:9,Next:2>
<ID:2,Data:11,Next:5>
<ID:5,Data:12,Next:6>
<ID:6,Data:16,Next:4>
<ID:4,Data:93,Next:null>

还有种链表叫双向链表，它的链节点中不仅包括后继next,还包括前继prev，所以他不仅可以从前遍历，还可以从后便遍历，但其代码比单链表的复杂，这里我们将id和data合并成key，链节点代码如下：

public class DuoLink {
//Key，后继，前继
public int key;
public DuoLink next;
public DuoLink prev;

public DuoLink(int key)
{
this.key = key;
this.next = null;
this.prev = null;
}

public String displayLink()
{
return "<Key:" + key + ",Next:"+(next==null?"null":next.key)+ ",Prev:"+(prev == null?"null":prev.key)+">";
}
}

双向链表代码如下：

public class DuoLinkedList {
//链表头、链表尾
private DuoLink first;
private DuoLink last;

public DuoLinkedList(){
first = null;
last = null;
}

//判空
public boolean isEmpty(){
return first == null;
}

//查找
public DuoLink find(int key)
{
DuoLink current = first;
while(current != null && key != current.key)
{
current = current.next;
}
return current;
}

//表头插入
public void insertFirst(int in)
{
DuoLink newDL = new DuoLink(in);
if(first == null)
last = newDL;
else
{
first.prev = newDL;
newDL.next = first;
}
first = newDL;
}

//表尾插入
public void insertLast(int in)
{
DuoLink newDL = new DuoLink(in);
if(last == null)
first = newDL;
else
{
newDL.prev = last;
last.next = newDL;
}
last = newDL;

}

//在key后插入
public void insertAfter(int key,int in) throws Exception
{
DuoLink find = find(key);//找到元素
DuoLink newDL = new DuoLink(in);
if(find == null)
throw new Exception("no find");
else if(find == last)
insertLast(in);
else
{
find.next.prev = newDL;
newDL.prev = find;
newDL.next = find.next;
find.next = newDL;
}
}

//删除表头元素
public DuoLink deleteFirst() throws Exception
{
if(isEmpty())
throw new Exception("空链表");
if(first.next == null)
last = null;
else
first.next.prev = null;
first = first.next;
return first;
}

//删除表尾元素
public DuoLink deleteLast() throws Exception
{
if(isEmpty())
throw new Exception("空链表");
if(last.prev == null)
first = null;
else
last.prev.next = null;
last = last.prev;
return last;
}

//删除元素
public DuoLink delete(int key) throws Exception
{
DuoLink find = find(key);
if(find == null)
throw new Exception("没有找到！");
else if(find == first)
deleteFirst();
else if(find == last)
deleteLast();
else
{
find.prev.next = find.next;
find.next.prev = find.prev;
find.next = null;
find.prev = null;
}
return find;
}

//从头到尾显示
public void displayFromFirst()
{
DuoLink cr = first;
StringBuffer sb = new StringBuffer("");
while(cr != null)
{
sb.append(cr.displayLink()+"\n");
cr = cr.next;
}
System.out.println(sb.toString());
}

//从尾到头显示
public void displayFromLast()
{
DuoLink cr = last;
StringBuffer sb = new StringBuffer("");
while(cr != null)
{
sb.append(cr.displayLink()+"\n");
cr = cr.prev;
}
System.out.println(sb.toString());
}

//测试
public static void main(String[] args) throws Exception {
DuoLinkedList dll = new DuoLinkedList();
dll.insertFirst(9);
dll.insertFirst(4);
dll.insertFirst(6);
dll.insertFirst(3);
dll.delete(4);
dll.displayFromFirst();
}

}

我们来测试一下：

<Key:3,Next:6,Prev:null>
<Key:6,Next:9,Prev:3>
<Key:9,Next:null,Prev:6>