目录
206
方法一
cpp
class Solution {
public:
ListNode* reverseList(ListNode* head) { //传入一个链表, 返回反转之后的链表
ListNode new_head, *p = head, *q;
//定义一个虚拟头节点用来生成新链表;*p 指向 链表head的首地址;*q 用来存放 p的下一个值
new_head.next = NULL; //虚拟头节点开始,指针域置空
while (p) { //当p为空循环结束
q = p->next; //p 存放 q的下一个值
p->next = new_head.next; // 头插法插入新链表
new_head.next = p;
p = q; //p 下移
}
return new_head.next; //返回新链表
}
};
方法二
cpp
class Solution {
public:
//递归方法反转链表
ListNode* reverseList(ListNode* head) { //传入一个链表, 返回反转之后的链表
//边界条件:如果链表为空或者链表的指针域为空 ,直接返回链表
if (head == NULL || head->next == NULL) return head;
ListNode *tail = head->next; //定义一个结点指针 指向 链表首地址的下一个结点
ListNode *new_head = reverseList(head->next); // 递归
head->next = tail->next; //反转
tail->next = head;
return new_head;
}
};
141
cpp
class Solution {
public:
bool hasCycle(ListNode *head) {
ListNode *p = head, *q = head; //一个慢指针,一个快指针
while (q && q->next) //快指针不为空,循环继续
{
p = p->next; //慢,走一步
q = q->next->next; //快,走两步
if (p == q)
{
return true; //有环 返回 真
}
}
return false; //无环 返回 假
}
};
202
cpp
class Solution {
public:
int getNext(int x) {
int d, y = 0;
while (x) {
d = x % 10; //取个位数
y += d * d; //y 是 每一位的平方和
x /= 10; //去掉个位数
}
return y; //返回平方和
}
bool isHappy(int n) {
int p = n, q = n; //一个慢 一个快
while (q != 1) {
p = getNext(p); //走一步
q = getNext(getNext(q)); //走两步
if (p == q && p != 1) return false; //有环 不是快乐数
}
return true; //是快乐数
}
};
61
cpp
class Solution {
public:
//获取 链表 长度
int getLenght(ListNode *head) {
int n = 0;
while (head) {
n += 1;
head = head->next;
}
return n;
}
ListNode* rotateRight(ListNode* head, int k) {
if (head == NULL) return head; // 链表为空 返回
int n = getLenght(head);
k %= n; // 取余
if (k == 0) return head; //如果 k == 0 无需旋转链表
ListNode *p = head, *q = head; //前指针 , 后指针
for (int i = 0; i <= k; i++) p = p->next; //前指针先走k+1个位置
while (p) p = p->next, q = q->next; //而后 两指针一块走,直到前指针走到链表的结尾
p = q->next; //将前指针 置到 后指针的下一位
q->next = NULL; //后指针置空,
q = p; //后指针指向前指针
while (q->next != NULL) q = q->next; //后指针继续向前遍历,直到走到链表结尾
q->next = head; //后指针的指针域指向链表的首地址,实现链表的旋转
return p; //返回新链表的首地址
}
};
19
cpp
class Solution {
public:
//双指针等距移动法
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode new_head, *p = &new_head, *q = p; //p q 都指向虚拟头结点
new_head.next = head; //虚拟头 指向链表
for (int i = 0; i <= n; i++) q = q->next; //q指针先移动n+1位
while (q) p = p->next, q = q->next; //q p 再同时移动
p->next = p->next->next; //删除倒数第n位:p为倒数第n+1位
return new_head.next;
}
};
142
cpp
class Solution {
public:
ListNode *detectCycle(ListNode *head) {
ListNode *p = head, *q = head; //p慢指针 q快指针
while (q && q->next) {
p = p->next; //慢
q = q->next->next; //快
if (p == q) break; //相遇 结束循环
}
if (q == NULL || q->next == NULL) return NULL; //无环的情况
p = head; //p 重新指向链表首地址
while (p != q) p = p->next, q = q->next; //p 与 q 再次相遇就是环起始的位置
return p;
}
};
92
cpp
class Solution {
public:
ListNode* reverseBetween(ListNode* head, int left, int right) {
if (left == 1 && right == 1) return head; // 不符合反转条件直接返回原来链表
if (left != 1) { //左 不为 0
//递归 不用操心函数怎么实现的,只知道函数是用来干啥的------------用来反转链表的
head->next = reverseBetween(head->next, left - 1, right - 1);
} else {
// left = 1,,right 不为1
ListNode *tail = head->next, *new_head;//尾指针指向头节点的下一个,, 定义一个新链表
new_head = reverseBetween(head->next, left, right - 1);//新链表获取反转链表的地址
//将头插到反转链表的尾部
head->next = tail->next;
tail->next = head;
//新链表的首地址给head
head = new_head;
}
return head;
}
};