单链表:
insertFirst:在表头插入一个新的链接点,时间复杂度为O(1)
deleteFirst:删除表头的链接点,时间复杂度为O(1)
find:查找包含指定关键字的链接点,由于需要遍历查找,平均需要查找N/2次,即O(N)
remove:删除包含指定关键字的链接点,由于需要遍历查找,平均需要查找N/2次,即O(N)
public classLinkedList {private classData{privateObject obj;private Data next = null;
Data(Object obj){this.obj =obj;
}
}private Data first = null;public voidinsertFirst(Object obj){
Data data= newData(obj);
data.next=first;
first=data;
}public Object deleteFirst() throwsException{if(first == null)throw new Exception("empty!");
Data temp=first;
first=first.next;returntemp.obj;
}public Object find(Object obj) throwsException{if(first == null)throw new Exception("LinkedList is empty!");
Data cur=first;while(cur != null){if(cur.obj.equals(obj)){returncur.obj;
}
cur=cur.next;
}return null;
}public void remove(Object obj) throwsException{if(first == null)throw new Exception("LinkedList is empty!");if(first.obj.equals(obj)){
first=first.next;
}else{
Data pre=first;
Data cur=first.next;while(cur != null){if(cur.obj.equals(obj)){
pre.next=cur.next;
}
pre=cur;
cur=cur.next;
}
}
}public booleanisEmpty(){return (first == null);
}public voiddisplay(){if(first == null)
System.out.println("empty");
Data cur=first;while(cur != null){
System.out.print(cur.obj.toString()+ " -> ");
cur=cur.next;
}
System.out.print("\n");
}public static void main(String[] args) throwsException {
LinkedList ll= newLinkedList();
ll.insertFirst(4);
ll.insertFirst(3);
ll.insertFirst(2);
ll.insertFirst(1);
ll.display();
ll.deleteFirst();
ll.display();
ll.remove(3);
ll.display();
System.out.println(ll.find(1));
System.out.println(ll.find(4));
}
}
1 -> 2 -> 3 -> 4 ->
2 -> 3 -> 4 ->
2 -> 4 ->
null
4
双端链表(不是双向链表):
与单向链表的不同之处在保存有对最后一个链接点的引用(last)
insertFirst:在表头插入一个新的链接点,时间复杂度O(1)
insertLast:在表尾插入一个新的链接点,时间复杂度O(1)
deleteFirst:删除表头的链接点,时间复杂度O(1)
deleteLast::删除表尾的链接点,由于只保存了表尾的链接点,而没有保存表尾的前一个链接点(这里就体现出双向链表的优势了),所以在删除表尾链接点时需要遍历以找到表尾链接点的前一个链接点,需查找N-1次,也就是O(N)
public classFirstLastList {private classData{privateObject obj;private Data next = null;
Data(Object obj){this.obj =obj;
}
}private Data first = null;private Data last = null;public voidinsertFirst(Object obj){
Data data= newData(obj);if(first == null)
last=data;
data.next=first;
first=data;
}public voidinsertLast(Object obj){
Data data= newData(obj);if(first == null){
first=data;
}else{
last.next=data;
}
last=data;
}public Object deleteFirst() throwsException{if(first == null)throw new Exception("empty");
Data temp=first;if(first.next == null)
last= null;
first=first.next;returntemp.obj;
}public void deleteLast() throwsException{if(first == null)throw new Exception("empty");if(first.next == null){
first= null;
last= null;
}else{
Data temp=first;while(temp.next != null){if(temp.next ==last){
last=temp;
last.next= null;break;
}
temp=temp.next;
}
}
}public voiddisplay(){if(first == null)
System.out.println("empty");
Data cur=first;while(cur != null){
System.out.print(cur.obj.toString()+ " -> ");
cur=cur.next;
}
System.out.print("\n");
}public static void main(String[] args) throwsException {
FirstLastList fll= newFirstLastList();
fll.insertFirst(2);
fll.insertFirst(1);
fll.display();
fll.insertLast(3);
fll.display();
fll.deleteFirst();
fll.display();
fll.deleteLast();
fll.display();
}
}
1 -> 2 ->
1 -> 2 -> 3 ->
2 -> 3 ->
2 ->
有序链表:链表中的数据按从小到大排列
public classSortedList {private classData{privateObject obj;private Data next = null;
Data(Object obj){this.obj =obj;
}
}private Data first = null;public voidinsert(Object obj){
Data data= newData(obj);
Data pre= null;
Data cur=first;while(cur != null &&(Integer.valueOf(data.obj.toString())
.intValue()>Integer.valueOf(cur.obj.toString())
.intValue())){
pre=cur;
cur=cur.next;
}if(pre == null)
first=data;elsepre.next=data;
data.next=cur;
}public Object deleteFirst() throwsException{if(first == null)throw new Exception("empty!");
Data temp=first;
first=first.next;returntemp.obj;
}public voiddisplay(){if(first == null)
System.out.println("empty");
System.out.print("first -> last : ");
Data cur=first;while(cur != null){
System.out.print(cur.obj.toString()+ " -> ");
cur=cur.next;
}
System.out.print("\n");
}public static void main(String[] args) throwsException{
SortedList sl= newSortedList();
sl.insert(80);
sl.insert(2);
sl.insert(100);
sl.display();
System.out.println(sl.deleteFirst());
sl.insert(33);
sl.display();
sl.insert(99);
sl.display();
}
}
first -> last : 2 -> 80 -> 100 ->
2first-> last : 33 -> 80 -> 100 ->first-> last : 33 -> 80 -> 99 -> 100 ->
表的插入和删除平均需要比较N/2次,即O(N),但是获取最小数据项只需O(1),因为其始终处于表头,对频繁操作最小数据项的应用,可以考虑使用有序链表实现,如:优先级队列
和数组相比,链表的优势在于长度不受限制,并且在进行插入和删除操作时,不需要移动数据项,故尽管某些操作的时间复杂度与数组想同,实际效率上还是比数组要高很多
劣势在于随机访问,无法像数组那样直接通过下标找到特定的数据项
转自:http://blog.csdn.net/a19881029/article/details/22695289#