目录
203.移除链表元素
由于不会用JAVA中的链表操作,因此第一道链表题目直接看了题解,下面附上代码。
学到的核心思想是增加一个虚拟头结点进行直接删除操作,这样原链表的所有节点就都可以按照统一的方式进行移除了,可以避免对头结点和其他结点的使用不同操作。
class Solution {
public ListNode removeElements(ListNode head, int val) {
/**
* 不添加虚拟节点方式
* 时间复杂度 O(n)
* 空间复杂度 O(1)
* @param head
* @param val
* @return
*/
// ListNode next;
// while (head != null && head.val == val) {
// head = head.next;
// }
// if (head == null) {
// return head;
// }
// ListNode pre = head;
// ListNode cur = head.next;
// while (cur != null) {
// if (cur.val == val) {
// pre.next = cur.next;
// } else {
// pre = cur;
// }
// cur = cur.next;
// }
//
// return head;
/**
* 不添加虚拟节点and pre Node方式
* 时间复杂度 O(n)
* 空间复杂度 O(1)
* @param head
* @param val
* @return
*/
// while (head != null && head.val == val) {
// head = head.next;
// }
// ListNode curr = head;
// while (curr != null) {
// while (curr.next != null && curr.next.val == val) {
// curr.next = curr.next.next;
// }
// curr = curr.next;
// }
// return head;
/**
* 添加虚节点方式
* 时间复杂度 O(n)
* 空间复杂度 O(1)
* @param head
* @param val
* @return
*/
if (head == null) {
return head;
}
ListNode dummyhead = new ListNode(-1, head);
ListNode cur = dummyhead;
while (cur.next != null) {
if (cur.next.val == val) {
cur.next = cur.next.next;
} else {
cur = cur.next;
}
}
return dummyhead.next;
}
}
707.设计链表
707给了单链表和双链表2个题解,双链表的看的我懵懵的
下面直接粘贴了随想录的代码,因为我自己的文件被搞得有点混乱,一开始把ListNode类放到了运行leetcode的区域外面,导致debug了挺久时间。
//单链表
class ListNode {
int val;
ListNode next;
ListNode(){}
ListNode(int val) {
this.val=val;
}
}
class MyLinkedList {
//size存储链表元素的个数
int size;
//虚拟头结点
ListNode head;
//初始化链表
public MyLinkedList() {
size = 0;
head = new ListNode(0);
}
//获取第index个节点的数值,注意index是从0开始的,第0个节点就是头结点
public int get(int index) {
//如果index非法,返回-1
if (index < 0 || index >= size) {
return -1;
}
ListNode currentNode = head;
//包含一个虚拟头节点,所以查找第 index+1 个节点
for (int i = 0; i <= index; i++) {
currentNode = currentNode.next;
}
return currentNode.val;
}
//在链表最前面插入一个节点,等价于在第0个元素前添加
public void addAtHead(int val) {
addAtIndex(0, val);
}
//在链表的最后插入一个节点,等价于在(末尾+1)个元素前添加
public void addAtTail(int val) {
addAtIndex(size, val);
}
// 在第 index 个节点之前插入一个新节点,例如index为0,那么新插入的节点为链表的新头节点。
// 如果 index 等于链表的长度,则说明是新插入的节点为链表的尾结点
// 如果 index 大于链表的长度,则返回空
public void addAtIndex(int index, int val) {
if (index > size) {
return;
}
if (index < 0) {
index = 0;
}
size++;
//找到要插入节点的前驱
ListNode pred = head;
for (int i = 0; i < index; i++) {
pred = pred.next;
}
ListNode toAdd = new ListNode(val);
toAdd.next = pred.next;
pred.next = toAdd;
}
//删除第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;
}
}
//双链表
class ListNode{
int val;
ListNode next,prev;
ListNode() {};
ListNode(int val){
this.val = val;
}
}
class MyLinkedList {
//记录链表中元素的数量
int size;
//记录链表的虚拟头结点和尾结点
ListNode head,tail;
public MyLinkedList() {
//初始化操作
this.size = 0;
this.head = new ListNode(0);
this.tail = new ListNode(0);
//这一步非常关键,否则在加入头结点的操作中会出现null.next的错误!!!
head.next=tail;
tail.prev=head;
}
public int get(int index) {
//判断index是否有效
if(index<0 || index>=size){
return -1;
}
ListNode cur = this.head;
//判断是哪一边遍历时间更短
if(index >= size / 2){
//tail开始
cur = tail;
for(int i=0; i< size-index; i++){
cur = cur.prev;
}
}else{
for(int i=0; i<= index; i++){
cur = cur.next;
}
}
return cur.val;
}
public void addAtHead(int val) {
//等价于在第0个元素前添加
addAtIndex(0,val);
}
public void addAtTail(int val) {
//等价于在最后一个元素(null)前添加
addAtIndex(size,val);
}
public void addAtIndex(int index, int val) {
//index大于链表长度
if(index>size){
return;
}
//index小于0
if(index<0){
index = 0;
}
size++;
//找到前驱
ListNode pre = this.head;
for(int i=0; i<index; i++){
pre = pre.next;
}
//新建结点
ListNode newNode = new ListNode(val);
newNode.next = pre.next;
pre.next.prev = newNode;
newNode.prev = pre;
pre.next = newNode;
}
public void deleteAtIndex(int index) {
//判断索引是否有效
if(index<0 || index>=size){
return;
}
//删除操作
size--;
ListNode pre = this.head;
for(int i=0; i<index; i++){
pre = pre.next;
}
pre.next.next.prev = pre;
pre.next = pre.next.next;
}
}
/**
* Your MyLinkedList object will be instantiated and called as such:
* MyLinkedList obj = new MyLinkedList();
* int param_1 = obj.get(index);
* obj.addAtHead(val);
* obj.addAtTail(val);
* obj.addAtIndex(index,val);
* obj.deleteAtIndex(index);
*/
707中写双链表的时候需要注意
为什么先要赋值prev再赋值next?
pred.next.next.prev = pred;
pred.next = pred.next.next;
因为当 pred.next
更新后,pred.next
已经指向新的节点,即原来的 pred.next.next
。这时候再访问 pred.next.next
已经变成了错误的操作,因为 pred.next
已经改变了,不再是原来的要删除的节点的下一个节点。因此会导致链表结构破坏,可能会引发运行时错误或链表中出现循环或断裂的情况。
结论:
为了确保链表的正确性,删除节点时需要先更新删除节点的下一个节点的 prev
指针,再更新前一个节点的 next
指针。这样可以确保链表在任何时候都保持正确的双向连接结构。
206.反转链表
206听了题解还是比较好理解的,主要是双指针方法和递归法。
看到题目我的思路是每次循环找到链表最后一个值赋给新的链表,但是没做到如何定义循环条件。
并且重新定义一个新的链表,也是对内存空间的浪费。
因此题解的思路是只需要改变链表的next指针的指向,直接将链表反转 ,而不用重新定义一个新的链表。
需要定义一个cur指针,指向头结点;一个pre指针,以及一个temp指针。
双指针易于逻辑理解,迭代法更加简洁,此处的迭代法很有意思,值得关注。
class Solution {
public ListNode reverseList(ListNode head) {
// 双指针写法
// ListNode pre = null;
// ListNode cur = head;
// ListNode temp = null;
// while (cur != null) {
// temp = cur.next;
// cur.next = pre;
// pre = cur;
// cur = temp;
// }
//
// return pre;
// 递归方法,更加简洁,思路按照双指针进行赋值
return reverse(head, null);
}
public ListNode reverse(ListNode cur, ListNode pre) {
if (cur == null) {
return pre;
}
ListNode temp = null;
temp = cur.next;
cur.next = pre;
return reverse(temp, cur);
}
}
第三天的总算是结束了,直冲Day4!