無序鏈表和有序鏈表

鏈表–無序鏈表

無序鏈表的相關接口

1. 尋秩訪問–rank2data(head,rank),時間複雜度爲O(rank),複雜度與rank成正比，以均勻分佈爲例，期望的時間複雜度爲O(n),其中n爲鏈表的長度

<pre>
public class LinkedList {

	public static void main(String[] args) {
		//創建一個鏈表node1->node2->node3->node4
		ListNode node1 = new ListNode(1);
		ListNode node2 = new ListNode(2);
		ListNode node3 = new ListNode(3);
		ListNode node4 = new ListNode(4);
		ListNode node5 = new ListNode(5);
		node1.nexNode = node2;
		node2.nexNode = node3;
		node3.nexNode = node4;
		node4.nexNode = node5;
		int data = 0;
		data = rank2data(node1,2);
		System.out.println(data);
	}
	public static int rank2data(ListNode head, int rank) {
		//循秩查找：由秩到位置
		ListNode p = head;
		while(0 < rank--) {
			p = p.nexNode;
		}
		return p.data;
	}

}
class ListNode{
	public ListNode preNode;
	public ListNode nexNode;
	public int data;
	
	public ListNode(int data) {
		super();
		this.preNode = null;
		this.nexNode = null;
		this.data = data;
	}

	@Override
	public String toString() {
		return "ListNode [data=" + data + "]";
	}
}
</pre>

2.搜索–find(e,n,p)在節點p的前n個真前驅節點中找到等於e的最後者

<pre>
public static ListNode find(int e, int n, ListNode p) {
	while(0 < n--) {
		if(p.preNode.data == e) {
			return p.preNode;
		}else{
			p = p.preNode;
		}
	}
	return null;
}
</pre>

3.插入–Insert(data,p)在P結點前面插入一個新的節點，節點存儲數據爲data

<pre>
public static ListNode insertBefore(int data, ListNode p) {
	ListNode newNode = new ListNode(data);
	p.preNode.nexNode = newNode;
	newNode.preNode = p.preNode;
	newNode.nexNode = p;
	p.preNode = newNode;
	return p.preNode;
}
</pre>

4.刪除–remove§刪除節點p，返回節點p所存儲的數值

<pre>
public static int remove(ListNode p) {
	//刪除p節點,返回p節點的數值
	int data = p.data;
	p.preNode.nexNode = p.nexNode;
	p.nexNode.preNode = p.preNode;
	return data;
}
</pre>

5.唯一化–dedubelicate(head)將head鏈表中重複元素只保留一個

<pre>
public static void dedubelicate(ListNode head) {
	ListNode p = head;
	int rank = 1;
	while(p.nexNode != null) {
		p = p.nexNode;
		ListNode q = find(p.data, rank, p);
		if (q == null) {
			rank++;
		}else {
			int data = remove(q);
		}
	}
}
</pre>

6.遍歷–tranvers(head)將head鏈表遍歷一遍

<pre>
public static void tranvers(ListNode head) {
	ListNode p = head;
	while(p != null) {
		System.out.println(p.data);
		p = p.nexNode;
	}
}
</pre>

鏈表–有序鏈表

有序鏈表的各種接口

1.唯一化：uniquify(head),head爲鏈表頭部，返回鏈表唯一化之後的長度

<pre>
public static int uniquify(ListNode head) {
	ListNode p = head;
	int size = 1;
	while(p.nexNode != null) {
		if (p.nexNode.data == p.data) {
			int data = remove(p.nexNode);
		}else {
			p = p.nexNode;
			size++;
		}
	}
	return size;
}
</pre>

2.查找：search(e,n,p)，在節點p的前n個節點查找不大於存儲的值不大於e的節點，並返回

<pre>
public static ListNode search(int e, int n, ListNode p) {
	//在有序鏈表的前n個節點中,找到不大於e的最後者
	while( 0 < n--) {
		if (p.preNode.data <= e) {
			return p.preNode;
		}else {
			p = p.preNode;
		}
	}
	return p;
}
</pre>