链表:一种通过指针串联在一起的线性结构。
节点:由数据域和指针域(存放指向下一个节点的指针)两部分组成。
struct ListNode {
int val;
ListNode* next;
ListNode(int x) : val(x), next(NULL) {} // 自定义构造函数
};
// 调用自定义构造函数初始化节点
ListNode* head = new ListNode(5);
// 调用系统默认构造函数初始化节点
ListNode* head = new ListNode();
head->val = 5;
链表类型:
1. 单链表
节点:1个数据域、1个指针域
头节点(入口节点)称为head。
一般最后一个节点指向null(空指针)。
2. 双链表
节点:1个数据域、2个指针域(指向下一个和上一个节点)
既可以向前查询,也可以向后查询
3. 循环链表
首尾相连,可用来解决约瑟夫环问题
链表的存储方式:不连续分布(散乱分布,分配取决于OS内存管理机制),通过指针域的指针链接到内存中各个节点,串联在一起。
链表的操作:
删除节点(注意养成习惯手动释放清理删除的节点内存,Java和Python不用手动管理内存)
添加节点
查找O(n)删除O(1)
性能分析:
第2节是203移除链表元素removeElements:删除链表中等于给定值val的所有节点;
一开始想到的思路就是让节点next指针直接指向下下一个节点。如果删除的是head节点呢?
①直接使用原来的链表进行删除操作,将头节点向后移动一位,需要单独写一段代码逻辑来实现;
class Solution203_0 {
public:
ListNode* removeElements(ListNode* head, int val) {
while (head != NULL && head->val == val) {
ListNode* tmp = head;
head = head->next;
delete tmp;
}
ListNode* cur = head;
while (cur != NULL && cur->next != NULL) {
// 有前一个while循环要么head==NULL要么head->val不等于val值
// 所以要判断cur不等于NULL进入循环判断cur->next是否等于val
if (cur->next->val == val) {
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
}
else {
cur = cur->next;
}
}
return head;
}
};
②设置一个虚拟头节点dummy node进行删除操作,以统一的逻辑移除节点,注意return dummyNode->next。
class Solution203_1 {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* dummyHead = new ListNode(0);
dummyHead->next = head;
ListNode* cur = dummyHead;
while (cur->next != NULL) {
if (cur->next->val == val) {
ListNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
}
else {
cur = cur->next;
}
}
head = dummyHead->next;
delete dummyHead;
return head;
}
};
// O(n)
// O(1)
第3节是707设计链表,实现五个功能:索引、插入头节点、插入尾节点、插入节点、删除节点
(注意链表head节点的索引为0)
通过设置虚拟头节点的方式操作链表:在类中定义结构体并初始化类
Class Solution707_MyLinkedNode {
public:
struct LinkedNode {
int val;
LinkedNode* next;
LinkedNode(int val) : val(val), next(nullptr) {}
}
Solution707_MyLinkedNode() {
_dummyHead = new LinkedNode(0);
_size = 0;
}
...
private:
int _size;
LinkedNode* _dummyHead;
};
分别在类中添加5中方法:
void addAtHead(int val) {
LinkedNode* newNode = new LinkedNode(val);
newNode->next = _dummyHead->next;
_dummyHead->next = neNode;
_size++;
}
void addAtTail(int val) {
LinkedNode* newNode = new LinkedNode(val);
LinkedNode* cur = _dummyHead;
while (cur->next != nullptr) {
cur = cur->next;
}
cur->nxet = newNode;
_size++;
}
void addAtIndex(int index, int val) {
if (index > _size) return;
if (index < 0) index = 0;
LinkedNode* newNode = new LinkedNode(int val);
LinkedNode* cur = _dummyHead;
while (index--) {
cur = cur->next;
}
// 插入时先右后左
newNode->next = cur->next;
cur->next = newNode;
_size++;
}
int get(int index) {
if (index > (_size -1) || index < 0) {
return -1;
}
LinkedNode* cur = _dummyHead->next;
while (index--) {
cur = cur->next;
}
return cur->val;
}
void deleteAtIndex(int index) {
if (index >= _size || index < 0) {
return;
}
LinkedNode* cur = _dummyHead;
while (index--) {
cur = cur->next;
}
LinkedNode* tmp = cur->next;
cur->next = cur->next->next;
delete tmp;
tmp = nullptr;
_size--;
}
void printLinkedList() {
LinkedNode* cur = _dummyHead;
while (cur->next != nullptr) {
cout << cur->next->val << " ";
cur = cur->next;
}
cout << endl;
}
第4节206翻转链表reverseList,实现对链表的翻转,如果再定义新链表翻转是浪费内存。实际上改变链表的next指针指向即可。
利用双指针pre和cur进行翻转:
class Solution206_0 {
public:
ListNode* reverseList(ListNode* head) {
ListNode* temp;
ListNode* cur = head;
ListNode* pre = nullptr;
while (cur) {
temp = cur->next;
cur->next = pre;
pre = cur;
cur = temp;
}
return pre;
}
};
利用递归法(从前往后):
class Solution206_1 {
public:
ListNode* reverse(ListNode* pre, ListNode* cur) {
if (cur == NULL) return pre;
ListNode* temp = cur->next;
cur->next = pre;
return reverse(cur, temp);
}
ListNode* reverseList(ListNode* head) {
return reverse(NULL, head);
}
};
利用递归法(从后往前):这个方法不好理解,技巧性太强,细节理解不到位,根本写不出来,建议画图了解一下。
class Solution {
public:
ListNode* reverseList(ListNode* head) {
// 边缘条件判断
if(head == NULL) return NULL;
if (head->next == NULL) return head;
// 递归调用,翻转第二个节点开始往后的链表
ListNode *last = reverseList(head->next);
// 翻转头节点与第二个节点的指向
head->next->next = head;
// 此时的 head 节点为尾节点,next 需要指向 NULL
head->next = NULL;
return last;
}
};
注意:每一层递归返回的是同一个last,在最底层开始的倒数第二个head开始迭代head->next->next=head,就是把head的下一个节点连在自己身上,自己连到nullptr暂放,返回last后接着进行上一层函数的head->next->next=head,注意此时的head是倒数第三个节点,把第二个节点(原本连在nullptr上)连在自己身上,自己连到nullptr暂放。
以上就是今天的全部学习内容。