链表概述
链表是一种通过指针串联在一起的线性结构,每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null(空指针的意思)
双链表
单链表中的指针域只能指向节点的下一个节点。
双链表:每一个节点有两个指针域,一个指向下一个节点,一个指向上一个节点。
双链表 既可以向前查询也可以向后查询
循环链表
链表首尾相连
循环链表可以用来解决约瑟夫环问题
链表的存储和定义
数组是在内存中是连续分布的,但是链表在内存中可不是连续分布的。
链表是通过指针域的指针链接在内存中各个节点。
所以链表中的节点在内存中不是连续分布的 ,而是散乱分布在内存中的某地址上,分配机制取决于操作系统的内存管理
定义:
public class ListNode {
// 结点的值
int val;
// 下一个结点
ListNode next;
// 节点的构造函数(无参)
public ListNode() {
}
// 节点的构造函数(有一个参数)
public ListNode(int val) {
this.val = val;
}
// 节点的构造函数(有两个参数)
public ListNode(int val, ListNode next) {
this.val = val;
this.next = next;
}
}
链表和数组对比
插入删除(时间复杂度) | 查询(时间复杂度) | 适用场景 | |
---|---|---|---|
数组 | O(n) | O(1) | 数据量固定,频繁查询,较少增删 |
链表 | O(1) | O(n) | 数据量不固定,频繁增删,较少查询 |
数组在定义的时候,长度就是固定的,如果想改动数组的长度,就需要重新定义一个新的数组。
链表的长度可以是不固定的,并且可以动态增删, 适合数据量不固定,频繁增删,较少查询的场景。
移除链表元素
删除链表中等于给定值 val 的所有节点
输入:head = [1,2,6,3,4,5,6], val = 6
输出:[1,2,3,4,5]
思路
虚拟头结点在进行删除操作
这样删除元素,就会议同样的方式进行
代码
public static ListNode removeElements(ListNode head, int val) {
ListNode dummy=new ListNode(-1,head);//虚拟头节点
ListNode pre=dummy;
ListNode cur=head;
while (cur!=null){
if (cur.val==val){
pre.next=cur.next;
}else {
pre =cur;
}
cur=cur.next;
}
return dummy.next;
}
设计链表
在链表类中实现这些功能:
- get(index):获取链表中第 index 个节点的值。如果索引无效,则返回-1。
- addAtHead(val):在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表的第一个节点。
- addAtTail(val):将值为 val 的节点追加到链表的最后一个元素。
- addAtIndex(index,val):在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度,则该节点将附加到链表的末尾。如果 index 大于链表长度,则不会插入节点。如果index小于0,则在头部插入节点。
- deleteAtIndex(index):如果索引 index 有效,则删除链表中的第 index 个节点。
代码
class MyListNode {
//size存储链表元素的个数
int size;
//虚拟头结点
ListNode head;
//初始化链表
public MyListNode() {
size = 0;
head = new ListNode(0);
}
/**
* 获取链表中第 index 个节点的值。如果索引无效,则返回-1。
*
* @param index
* @return
*/
public int get(int index) {
if (index < 0 || index >= size) {
return -1;
}
ListNode currentNode = head;
for (int i = 0; i <= index; i++) {
currentNode = currentNode.next;
}
return currentNode.val;
}
/**
* 在链表的第一个元素之前添加一个值为 val 的节点。插入后,新节点将成为链表的第一个节点。
*
* @param val
*/
public void addAtHead(int val) {
addAtIndex(0, val);
}
/**
* 将值为 val 的节点追加到链表的最后一个元素。
*
* @param val
*/
public void addAtTail(int val) {
addAtIndex(size, val);
}
/**
* 在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度,则该节点将附加到链表的末尾。
* 如果 index 大于链表长度,则不会插入节点。如果index小于0,则在头部插入节点
*/
public void addAtIndex(int index, int val) {
if (index > size) {
return;
}
if (index < 0) {
index = 0;
}
size++;
//找到要添加节点的前一个节点
ListNode cur = head;
for (int i = 0; i < index; i++) {
cur = cur.next;
}
ListNode toAdd = new ListNode(val);
toAdd.next = cur.next;
cur.next = toAdd;
}
/**
* 如果索引 index 有效,则删除链表中的第 index 个节点
*
* @param index
*/
public void deleteAtIndex(int index) {
if (index < 0 || index >= size) {
return;
}
size--;
if (index == 0) {
head = head.next;
return;
}
ListNode pred = head;
for (int i = 0; i < index ; i++) {
pred = pred.next;
}
pred.next = pred.next.next;
}
}
反转链表
题意:反转一个单链表。
示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
思路
首先定义一个cur指针,指向头结点,再定义一个pre指针,初始化为null。
然后开始反转了,先把 cur->next 节点用tmp指针保存一下,也就是保存一下这个节点。
接下来要改变 cur->next 的指向,然后继续移动pre和cur指针。
最后,cur 指针已经指向了null,循环结束,链表也反转完毕了
代码
public ListNode reverseList(ListNode head) {
ListNode prev = null;
ListNode cur = head;
ListNode temp = null;
while (cur!=null){
temp = cur.next;// 保存下一个节点
cur.next=prev;
prev=cur;
cur=temp;
}
return prev;
}
总结
链表主要需要灵活使用虚拟头节点,设计链表挺难的,感觉是自己对链表不怎么熟悉