开宗明义:本系列基于小象学院林沐老师课程《面试算法 LeetCode 刷题班》,刷题小白,旨在理解和交流,重在记录,望各位大牛指点!
Leetcode学习之链表(1)
链表的定义
链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。由于不必须按顺序存储,链表在插入的时候可以达到O(1)的复杂度,比另一种线性表顺序表快得多,但是查找一个节点或者访问特定编号的节点则需要O(n)的时间,而顺序表相应的时间复杂度分别是O(logn)和O(1)。
链表是由一个 head 指针变量和许多节点组成。每个节点有许多元素,最后一个元素是一个指向下一个节点首地址的指针,第一个节点的首地址交给head,末尾的指针指向第二个节点的首地址,以此类推,到达最后一个节点,最后一个节点的末尾指针指向 NULL。
一条链表必须有一个 head 指针才能寻找到第一个节点,否则无法进行链表的访问,并且每个节点的末尾指针必须指向下一个节点的首地址,否则就无法进行链式访问数据,并且最后一个节点的末尾指针必须指向NULL,避免指针指向未知区域。
链表的分类:
1、链表基础
定义一个结构体指针 p,将一个结构体变量的变量名赋给 p,则此时 p 指向的是结构体的首地址,如果对想通过结构体指针p来访问该结构体变量的成员,就需要进行节引用运算。方法如下:
- (*p). 成员名
- p -> 成员名
测试代码:
#include <stdio.h>
#include <iostream>
//先定义一个节点结构体,这个结构体可以存放数据和末尾指针
struct ListNode {
int val; //存储元素的数据域
//float score;
struct ListNode *next; //存储下一节点地址的指针域
};
//struct ListNode {
// int val; //存储元素的数据域
// ListNode *next; //存储下一节点地址的指针域
//};
int main()
{
ListNode a, b, c, d, e;
a.val = 10;
b.val = 20;
c.val = 30;
d.val = 40;
e.val = 50;
a.next = &b;//b链表的地址
b.next = &c;
c.next = &d;
d.next = &e;
e.next = NULL;//最后一个节点指针指向NULL,避免指向未知区域
ListNode *head = &a;//一条链表必须有一个 head 指针才能寻找到第一个节点,否则无法进行链表的访问。
while (head)
{
printf("%d\n",head->val);//这边涉及结构体的解析
head = head->next;
//printf("%d\n", (*head).val);//这边涉及结构体的解析
//head = (*head).next;
}
system("pause");
return 0;
}
效果图:
2、链表逆序 LeetCode 206
题目来源:
题目描述:已知链表头节点指针head,将链表逆序(不可申请额外空间)。
要求描述:
解决思路:依次遍历链表节点,每遍历一个节点即逆置一个节点。这就需要设置新建一个节点指针,这个节点指针指向空地址,中间还需要设置一个临时链表节点指针做过渡。
测试代码:
#include <stdio.h>
#include <iostream>
//先定义一个节点结构体,这个结构体可以存放数据和末尾指针
struct ListNode {
int val; //存储元素的数据域
ListNode *next; //存储下一节点地址的指针域
ListNode(int x) :val(x), next(NULL) {} //默认构造函数
//在C++中,结构体和类有很多相似之处,如结构体也可以有构造函数和析够函数,类中成员变量默认为私有,而结构体中则为公有
//所以在定义一个新的结构体实例时,会自动执行其构造函数ListNode(int x);进行初始化。
//关于val(x), next(NULL)这叫“初始化列表”,和在构造函数里面直接赋值效果是一样的,但是用初始化列表更好
};
class Solution {
public://这个函数形式表示返回的是一个指针
ListNode* reverseList(ListNode* head){
//新建一个节点,这个节点指向空地址
ListNode *new_head = NULL;
while (head)
{//这边取个指针做过渡
ListNode *next = head->next;//备份当前节点指向下一个节点的地址;
head->next = new_head; //这就是第一个new_head指向 NULL 的意义
new_head = head;//把new_head这个指针向前移动一个
head = next;//head这个也向前移动一个
}
return new_head;//返回新链表头节点
}
};
int main()
{
ListNode a(1), b(2), c(3), d(4), e(5);//构造函数
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
e.next = NULL;
Solution solve;//类
ListNode *head1 =&a;//链表的第一个节点
//display
while (head1)
{
printf("%d\n", head1->val);
head1 = head1->next;
}
ListNode *head2 = NULL;
head2=solve.reverseList(&a);
printf("反转后:\n");
while (head2)
{
printf("%d\n", head2->val);
head2 = head2->next;
}
system("pause");
return 0;
}
效果图:
3、链表求固定长度的逆序 LeetCode 92
题目来源:
题目描述:已知链表头节点指针
,将链表从位置
到
逆序(不申请额外空间)。
要求描述:
解决思路:
测试代码:
#include <stdio.h>
#include <iostream>
struct ListNode {
int val; //存储元素的数据域
ListNode *next; //存储下一节点地址的指针域
ListNode(int x) :val(x), next(NULL) {} //默认构造函数
};
class Solution {
public: //链表头指针,从 m 逆至到 n
ListNode* reverseBetween(ListNode *head, int m, int n) {
int change_len = n - m + 1;//计算需要逆置的节点个数
ListNode *pre_head = NULL;//初始化开始逆置的节点的前驱
ListNode *result = head;//最终转换后的链表头节点,非特殊情况即为head,换句话说就是返回的节点头
while (head && --m) //将head向前移动m-1个位置
{
pre_head = head;//记录head的前驱
head = head->next;
}
//
ListNode *modify_list_tail = head;//将modify_list_tail指向当前的head,即逆置前的链表头,逆置后的链表尾。
ListNode *new_head = NULL; //这边只是一个指针
while (head && change_len)//逆置change_len个节点
{
ListNode *next = head->next;
head->next = new_head;
new_head = head;
head = next;
change_len--;//每完成一个节点逆置,chang_len--
}
modify_list_tail->next = head;//modify_list_tail逆置后的链表尾。此时head是逆置后的后一个元素
if (pre_head)
{//如果pre_head不为空,表示不是从第一个节点开始逆置的,也就是 m > 1。
pre_head->next = new_head; //new_head是反转后的第一个,将逆置链表开始的节点前驱与逆置后的头节点相连
}
else
{//pre_head为空。说明m = 1,从第一个节点开始逆置
result = new_head;//结果即为逆置后的头节点
}
return result;
}
};
int main()
{
ListNode a(1), b(2), c(3), d(4), e(5);
a.next = &b;
b.next = &c;
c.next = &d;
d.next = &e;
Solution solve;
ListNode *head = solve.reverseBetween(&a, 2, 4);
while (head)
{
printf("%d\n", head->val);
head = head->next;
}
system("pause");
return 0;
}
效果图: