java 有序链表_Java单链表、双端链表、有序链表实现

单链表:

47c19dfeb8977f535474c7bcedc85925.png

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)

78b633c541d7437799d8cc9de7beba90.png

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#

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值