Java单链表、双端链表、有序链表实现
单链表:
insertFirst:在表头插入一个新的链接点,时间复杂度为O(1)
deleteFirst:删除表头的链接点,时间复杂度为O(1)
有了这两个方法,就可以用单链表来实现一个栈了,见http://blog.csdn.net/a19881029/article/details/22579759
find:查找包含指定关键字的链接点,由于需要遍历查找,平均需要查找N/2次,即O(N)
remove:删除包含指定关键字的链接点,由于需要遍历查找,平均需要查找N/2次,即O(N)
- public class LinkedList {
- private class Data{
- private Object obj;
- private Data next = null;
- Data(Object obj){
- this.obj = obj;
- }
- }
- private Data first = null;
- public void insertFirst(Object obj){
- Data data = new Data(obj);
- data.next = first;
- first = data;
- }
- public Object deleteFirst() throws Exception{
- if(first == null)
- throw new Exception("empty!");
- Data temp = first;
- first = first.next;
- return temp.obj;
- }
- public Object find(Object obj) throws Exception{
- if(first == null)
- throw new Exception("LinkedList is empty!");
- Data cur = first;
- while(cur != null){
- if(cur.obj.equals(obj)){
- return cur.obj;
- }
- cur = cur.next;
- }
- return null;
- }
- public void remove(Object obj) throws Exception{
- 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 boolean isEmpty(){
- return (first == null);
- }
- public void display(){
- 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) throws Exception {
- LinkedList ll = new LinkedList();
- 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)
有了这几个方法就可以用双端链表来实现一个队列了,http://blog.csdn.net/a19881029/article/details/22654121
- public class FirstLastList {
- private class Data{
- private Object obj;
- private Data next = null;
- Data(Object obj){
- this.obj = obj;
- }
- }
- private Data first = null;
- private Data last = null;
- public void insertFirst(Object obj){
- Data data = new Data(obj);
- if(first == null)
- last = data;
- data.next = first;
- first = data;
- }
- public void insertLast(Object obj){
- Data data = new Data(obj);
- if(first == null){
- first = data;
- }else{
- last.next = data;
- }
- last = data;
- }
- public Object deleteFirst() throws Exception{
- if(first == null)
- throw new Exception("empty");
- Data temp = first;
- if(first.next == null)
- last = null;
- first = first.next;
- return temp.obj;
- }
- public void deleteLast() throws Exception{
- 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 void display(){
- 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) throws Exception {
- FirstLastList fll = new FirstLastList();
- 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 class SortedList {
- private class Data{
- private Object obj;
- private Data next = null;
- Data(Object obj){
- this.obj = obj;
- }
- }
- private Data first = null;
- public void insert(Object obj){
- Data data = new Data(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;
- else
- pre.next = data;
- data.next = cur;
- }
- public Object deleteFirst() throws Exception{
- if(first == null)
- throw new Exception("empty!");
- Data temp = first;
- first = first.next;
- return temp.obj;
- }
- public void display(){
- 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) throws Exception{
- SortedList sl = new SortedList();
- 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 ->
- 2
- first -> last : 33 -> 80 -> 100 ->
- first -> last : 33 -> 80 -> 99 -> 100 ->
表的插入和删除平均需要比较N/2次,即O(N),但是获取最小数据项只需O(1),因为其始终处于表头,对频繁操作最小数据项的应用,可以考虑使用有序链表实现,如:优先级队列
和数组相比,链表的优势在于长度不受限制,并且在进行插入和删除操作时,不需要移动数据项,故尽管某些操作的时间复杂度与数组想同,实际效率上还是比数组要高很多
劣势在于随机访问,无法像数组那样直接通过下标找到特定的数据项
Java单链表、双端链表、有序链表实现的更多相关文章
- Java数据结构——用双端链表实现队列
//================================================= // File Name : LinkQueue_demo //---------------- ...
- java数据结构-09双端队列
一.相关概念: (Deque)双端队列能够在队头.队尾进行添加.删除等操作 二.接口设计: 三.代码实现 public class Deque<E> { private List< ...
- C++单链表反转、两有序链表合并仍有序
1 #include<iostream> 2 3 struct Node 4 { 5 int data; 6 Node *next; 7 }; 8 9 typedef struct Nod ...
- java数据结构——单链表、双端链表、双向链表(Linked List)
1.继续学习单链表,终于摆脱数组的魔爪了,单链表分为数据域(前突)和引用域(指针域)(后继),还有一个头结点(就好比一辆火车,我们只关心火车头,不关心其它车厢,只需知晓车头顺藤摸瓜即可),头结点没有前 ...
- JAVA基础——链表结构之双端链表
双端链表:双端链表与传统链表非常相似.只是新增了一个属性-即对最后一个链结点的引用 如上图所示:由于有着对最后一个链结点的直接引用.所以双端链表比传统链表在某些方面要方便.比如在尾部插入一个链结点.双 ...
- Java实现 LeetCode 21 合并两个有序链表
21. 合并两个有序链表 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4 输出:1 ...
- c# 有序链表合并 链表反转
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.T ...
- 算法练习之合并两个有序链表, 删除排序数组中的重复项,移除元素,实现strStr(),搜索插入位置,无重复字符的最长子串
最近在学习java,但是对于数据操作那部分还是不熟悉 因此决定找几个简单的算法写,用php和java分别实现 1.合并两个有序链表 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两 ...
- 代码题(14)— 合并有序链表、数组、合并K个排序链表
1.21. 合并两个有序链表 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2->4, 1->3->4 输出 ...
- leecode刷题(23)-- 合并两个有序链表
leecode刷题(23)-- 合并两个有序链表 合并两个有序链表 将两个有序链表合并为一个新的有序链表并返回.新链表是通过拼接给定的两个链表的所有节点组成的. 示例: 输入:1->2-> ...
随机推荐
- Beta 分工比例
组员在Beta版本的分工和个人贡献百分比. 人员 任务完成情况 贡献比 031302331 闹钟,爬取知乎数据,书籍下载,解决bug,帮助队友 25% 031302442 注册登录逻辑,书籍评论评分页 ...
- G-nav-02
/*header: Navigation public style*/header:before, header:after ,.navigation:before, .navigation:afte ...
- C语言中memset(void *s, char ch,unsigned n)用的用法
将指针s所指的内存空间中前n为重置为字符c 程序例: #include <string.h> #include <stdio.h> #include <memory.h& ...
- 图解Android - 如何看Android的UML 图?
如何看UML图? UML能给我们带来什么? 这是本文要寻找的答案.UML图有很多类型,我们这里只讨论最重要也最常用的两种 - 类图和时序图. 1. 类图 通过类图,我们可以很容易的了解代码架构,理清模 ...
- 【POJ 2923】Relocation(状压DP+DP)
题意是给你n个物品,每次两辆车运,容量分别是c1,c2,求最少运送次数.好像不是很好想,我看了网上的题解才做出来.先用状压DP计算i状态下,第一辆可以运送的重量,用该状态的重量总和-第一辆可以运送的, ...
- 【UVALive 7334】Kernel Knights
题 题意 有两个队的骑士1到n和n+1到2n,每个骑士只能互相攻击对手队的一个骑士.kernel的意思是在这个kernel里的骑士不会互相攻击,在kernel外的骑士被kernel里的骑士攻击. 现在 ...
- 【转】pageX、clientX、screenX、offsetX、layerX、x
参考:http://www.cnblogs.com/xesam/archive/2011/12/08/2280509.html chrome: e.pageX——相对整个页面的坐标e.layerX—— ...
- 第七节 JBPM 中的脚本语言
1.JPDL表达式 2.动作:数据库操作例子 3.路由:transaction一个流程之间的指向 4.BeanShell脚本语言 例子: 发布到数据库中才能做一个测试类
- 【BZOJ-2818】Gcd 线性筛
2818: Gcd Time Limit: 10 Sec Memory Limit: 256 MBSubmit: 3347 Solved: 1479[Submit][Status][Discuss ...
- 【bzoj1061】 Noi2008—志愿者招募
http://www.lydsy.com/JudgeOnline/problem.php?id=1061 (题目链接) 题意 给定n天,第i天需要ai个志愿者,有m类志愿者,每类志愿者工作时间为[l, ...