无序链表和有序链表

链表–无序链表

无序链表的相关接口

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>