java 链表的使用

本文详细介绍了链表与数组的主要区别,包括它们在内存存储、遍历、插入、删除等操作上的差异。链表分为单端链表和双端链表,其操作时间复杂度各有特点。在Java中,使用LinkedList实现链表操作的例子被给出,包括创建、添加、访问、查找、删除等。此外,链表适用于写多读少的场景,并推荐了两个LeetCode链表题目供练习。

链表与数组的区别

数组的存放为连续的内存空间, 链表不需要,任意碎片式的内存空间都可以形成链表

链表的分类

1 双端链表

既有next指向下一个数据也有previous指向前一个数据,可以双向遍历。

2 单端链表

只有next指向下一个数据,只能单向遍历。

链表的基本操作

1 访问----O(N)

需要遍历,从头找到尾

2 搜索----O(N)

需要遍历,从头找到尾

3 插入----O(1)

直接需要插入的位置断开指针,使上一个的指针指向新的元素的位置,新元素的下一个指向原本的下一个元素

4 删除----O(1)

断开删除元素前一个元素的next指向删除元素的next即可
tips
1 这里的插入删除操作的时间复杂度实际上说的插入或删除这一个操作的时间复杂度。
2 实际上整个操作的时间复杂度是O(N),因为需要先查找到元素,遍历到指定位置,再进行插入。

应用场景

写多读少的场景

java 链表的常见操作

1 创建链表

LinkedList<Integer> list_1 = new LinkedList<>();

2 添加元素

for (int i = 0; i<3 ;i++){
    list_1.add(i+1);
}
System.out.println(list_1.toString());
list_1.add(2,99);
System.out.println(list_1.toString());

3 访问元素

System.out.println(list_1.get(2));

4 查找元素

System.out.println(list_1.indexOf(99));
System.out.println(list_1.indexOf(88));

5 删除元素

list_1.remove(2);
System.out.println(list_1.toString());

6 链表长度

System.out.println(list_1.size());

7 更新元素

list_1.set(2, 88);
System.out.println(list_1.toString());

链表基础leetcode题目

1 leetcode 203 删除指定元素

参数设置:head(移动节点), prev(head的前一个),dummy(保存头节点,最后返回结果)
1 遍历整个链表,入口的条件是链表的头节点不为空(这样最后一个节点也可以遍历到)
2 如果碰到指定值,prev 指向head的下一个节点head移动一步
3 如果没有碰到指定值,prev指向head,head后移一步
4 最后返回头节点(需要有dummy存储头节点), 最后返回

2 leetcode 206 反转链表

参数设置:head(移动节点), hNext(head的后一个),dummy(保存头节点,最后返回结果),dNext(dummy的后一个节点)

dNext = dummy.next;
hNext = head.next;
dummy.next = hNext;
head.next = hNext.next;
hNext.next = dNext;
  链表类List的源代码如下: import Java.io.*; public class List {  /*用变量来实现表头*/  private Node Head=null;  private Node Tail=null;  private Node Pointer=null;  private int Length=0;  public void deleteAll()  /*清空整个链表*/  {   Head=null;   Tail=null;   Pointer=null;   Length=0;  }  public void reset()  /*链表复位,使第一个结点成为当前结点*/  {   Pointer=null;  }  public boolean isEmpty()  /*判断链表是否为空*/  {   return(Length==0);  }  public boolean isEnd()  /*判断当前结点是否为最后一个结点*/  {   if(Length==0)    throw new Java.lang.NullPointerException();   else if(Length==1)    return true;   else    return(cursor()==Tail);  }  public Object nextNode()  /*返回当前结点的下一个结点的值,并使其成为当前结点*/  {   if(Length==1)    throw new Java.util.NoSuchElementException();   else if(Length==0)    throw new Java.lang.NullPointerException();   else   {    Node temp=cursor();    Pointer=temp;    if(temp!=Tail)     return(temp.next.data);    else     throw new Java.util.NoSuchElementException();   }  }  public Object currentNode()  /*返回当前结点的值*/  {   Node temp=cursor();   return temp.data;  }     public void insert(Object d)  /*在当前结点前插入一个结点,并使其成为当前结点*/  {   Node e=new Node(d);   if(Length==0)   {    Tail=e;    Head=e;   }   else   {    Node temp=cursor();    e.next=temp;    if(Pointer==null)     Head=e;    else     Pointer.next=e;   }   Length++;  }  public int size()  /*返回链表的大小*/  {   return (Length);  }
### Java 链表使用方法 在 Java 中,链表通常通过自定义节点类来实现。以下是一个简单的单链表节点类定义: ```java class ListNode { int val; ListNode next; ListNode(int x) { val = x; } } ``` #### 创建链表 可以通过创建节点并将它们连接起来来创建链表: ```java ListNode head = new ListNode(1); ListNode second = new ListNode(2); ListNode third = new ListNode(3); head.next = second; second.next = third; ``` #### 遍历链表 使用循环遍历链表中的每个节点: ```java ListNode current = head; while (current != null) { System.out.println(current.val); current = current.next; } ``` #### 插入节点 在链表中插入新节点,例如在链表头部插入节点: ```java ListNode newNode = new ListNode(0); newNode.next = head; head = newNode; ``` #### 删除节点 删除链表中的节点,例如删除指定值的节点: ```java ListNode prev = null; ListNode current = head; int target = 2; while (current != null) { if (current.val == target) { if (prev == null) { head = current.next; } else { prev.next = current.next; } break; } prev = current; current = current.next; } ``` ### LeetCode 对 Java 链表的考察方式 #### 链表的基本操作 LeetCode 会考察链表的插入、删除、反转等基本操作。例如,LeetCode 206 题反转链表,需要将链表中的节点顺序反转。 ```java class Solution { public ListNode reverseList(ListNode head) { ListNode pre = null; ListNode cur = head; while (cur != null) { ListNode nxt = cur.next; cur.next = pre; pre = cur; cur = nxt; } return pre; } } ``` #### 链表的合并与分割 如 LeetCode 21 题合并两个有序链表,需要将两个有序链表合并成一个新的有序链表;LeetCode 86 题分隔链表,需要将链表按给定值进行分割。 ```java class Solution { public ListNode mergeTwoLists(ListNode l1, ListNode l2) { ListNode dummy = new ListNode(0); ListNode current = dummy; while (l1 != null && l2 != null) { if (l1.val < l2.val) { current.next = l1; l1 = l1.next; } else { current.next = l2; l2 = l2.next; } current = current.next; } if (l1 != null) { current.next = l1; } if (l2 != null) { current.next = l2; } return dummy.next; } } ``` #### 链表的查找与判断 LeetCode 会考察链表中特定节点的查找,如链表的中间节点(LeetCode 876 题);还会考察链表的一些特性判断,如判断链表是否为回文链表(LeetCode 234 题)[^3]。 ```java class Solution { public ListNode middleNode(ListNode head) { ListNode slow = head; ListNode fast = head; while (fast != null && fast.next != null) { slow = slow.next; fast = fast.next.next; } return slow; } } ``` #### 链表的相交与环 考察链表是否相交(LeetCode 160 题)以及链表是否存在环(LeetCode 141 题)。对于链表相交问题,可以使用哈希表来解决[^2]。 ```java import java.util.HashSet; import java.util.Set; class Solution { public ListNode getIntersectionNode(ListNode headA, ListNode headB) { Set<ListNode> set = new HashSet<>(); ListNode nodeA = headA; while (nodeA != null) { set.add(nodeA); nodeA = nodeA.next; } ListNode nodeB = headB; while (nodeB != null) { if (set.contains(nodeB)) { return nodeB; } nodeB = nodeB.next; } return null; } } ```
评论 1
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值