顺序表、链表：LeetCode题目

目录

206

141

202

61

19

142

92

---

206

方法一

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;   //返回新链表
    }
};

 方法二

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

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

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

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

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

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

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;
    }
};