链表理论基础
链表是一种通过指针串联在一起的线性结构,每一个节点由两部分组成,一个是数据域一个是指针域(存放指向下一个节点的指针),最后一个节点的指针域指向null(空指针的意思)。
单链表、双链表、循环链表
链表在内存中不是连续分布的,链表是通过指针域的指针链接在内存中各个节点。
C/C++的定义链表节点方式:
// 单链表
struct ListNode {
int val; // 节点上存储的元素
ListNode *next; // 指向下一个节点的指针
ListNode(int x) : val(x), next(NULL) {} // 节点的构造函数
};
不定义构造函数,C++默认生成一个构造函数,但是在初始化的时候就不能直接给变量赋值!例如:
ListNode* head = new ListNode(5);
203.移除链表元素
思路:基本的单链表遍历及删除操作。
时间复杂度:O(n)
空间复杂度:O(1)
分析:
使用头结点,可以统一链表的插入和删除操作。
注意:
单链表的定义,以及使用构造函数的写法。
代码实现:
class Solution {
public:
ListNode* removeElements(ListNode* head, int val) {
ListNode* newhead = new ListNode(0, head);
ListNode* p = newhead;
ListNode* q = newhead->next;
while(q != NULL){
if(q->val == val){
p->next = q->next;
q = q->next;
}
else{
p = p->next;
q = q->next;
}
}
return newhead->next;
}
};
707.设计链表
思路:单链表各种操作:定义、初始化、查找、插入、删除、遍历。
时间复杂度:略
空间复杂度:略
分析:
掌握好基本的遍历、插入、删除即可。
注意:
1.单链表的定义,以及使用构造函数的写法。
//定义链表结点
struct ListNode{
int val;
ListNode *next;
//构造函数
ListNode(int x) : val(x), next(NULL) {}
};
//使用构造函数new一个节点,这个节点data域为0,next域为NULL
tmp = new ListNode(0);
2.初始化链表时,所用到的变量要在private中自己定义。初始化一个链表,需要一个头结点、一个链表长度。
3.链表长度size大小一定要随着插入删除操作及时更改,不要忘记。
class MyLinkedList {
public:
//定义链表结点
struct ListNode{
int val;
ListNode *next;
//构造函数
ListNode(int x) : val(x), next(NULL) {}
};
MyLinkedList() {
//初始化一个空的单链表,它有一个头结点,size记录它的长度
dummyHead = new ListNode(0);
size = 0;
}
int get(int index) {
if(index < 0 || index >= size){
return -1;
}
else{
ListNode *p = dummyHead->next;
for(int i = 0; i < index; i++){//移动index次
p = p->next;
}
return p->val;
}
}
void addAtHead(int val) {
ListNode *tmp = new ListNode(val);
ListNode *p = dummyHead->next;
tmp->next = p;
dummyHead->next = tmp;
size++;
}
void addAtTail(int val) {
ListNode* p = dummyHead;
while(p->next != NULL){
p = p->next;
}
ListNode* tmp = new ListNode(val);
p->next = tmp;
tmp->next = NULL;
size++;
}
void addAtIndex(int index, int val) {
if(index >=0 && index < size){
//插到前面
ListNode *p = dummyHead;
for(int i = 0; i < index; i++){//移动index次
p = p->next;
}
ListNode* tmp = new ListNode(val);
tmp->next = p->next;
p->next = tmp;
size++;
}
else if(index == size){
//插到尾部
ListNode* p = dummyHead;
while(p->next != NULL){
p = p->next;
}
ListNode* tmp = new ListNode(val);
p->next = tmp;
tmp->next = NULL;
size++;
}
}
void deleteAtIndex(int index) {
if(index >= 0 && index < size){
ListNode* p = dummyHead;
//将p指向index-1的位置
for(int i = 0; i < index; i++){//移动index次
p = p->next;
}
ListNode* q = p->next;//q是待删除节点、
p->next = q->next;
delete(q);
size--;
}
}
private:
ListNode* dummyHead;
int size;
};
206.反转链表
思路:想通过创建一个虚拟头结点和反向复制节点来反转链表,但这个方法复杂且容易出错。
时间复杂度:略
空间复杂度:略
代码实现(未通过):
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode() : val(0), next(nullptr) {}
* ListNode(int x) : val(x), next(nullptr) {}
* ListNode(int x, ListNode *next) : val(x), next(next) {}
* };
*/
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* dummyHead = new ListNode(0,head); //创建虚拟头结点
ListNode* p = dummyHead;
while(p->next != NULL){//p指向链表最末尾
p = p->next;
}
ListNode* q = dummyHead->next;
dummyHead = p->next;
while(q != dummyHead){
ListNode* tmp = new ListNode(0,NULL);
tmp->val = q->val;
p->next = tmp;
p = p->next;
ListNode* tmpDelete = q;
q = q->next;
delete(tmpDelete);
}
return dummyHead->next;
}
};
思路:双指针。直接反转链表中的指针。
时间复杂度:O(n)
空间复杂度:O(1)
注意:
1.两个指针的初始情况,循环退出的条件 。
2.指针反转之后链表会断掉,因此需要tmp指针在反转之前暂存一下,把链表接上。
代码实现:
class Solution {
public:
ListNode* reverseList(ListNode* head) {
ListNode* front = head;
ListNode* rear = NULL;
while(front != NULL){
ListNode* tmp = front->next;
front->next = rear;
rear = front;
front = tmp;
}
head = rear;
return head;
}
};
思路:递归。将一个复杂的大问题转化为多个简单一样的小问题,依据双指针的思路来写。
时间复杂度:O(n)
空间复杂度:O(n)
注意:
1.要先掌握双指针,依据双指针的思路来写递归的代码,否组不够直观。
2.递归要注意两点:1)跳出递归的条件;2)循环的基本操作。
代码实现:
class Solution {
public:
ListNode* reverse(ListNode* rear, ListNode* front){
if(front == NULL){
return rear;
}
else{
ListNode* tmp = front->next;
front->next = rear;
return reverse(front, tmp);
}
}
ListNode* reverseList(ListNode* head) {
return reverse(NULL, head);
}
};