力扣面试常见150题:栈+链表(java+c++)

于 2024-03-04 16:13:32 发布
阅读量1.4k 收藏 25
点赞数 26
分类专栏： 力扣150高频面试题 文章标签： leetcode 面试 链表 c++ java 剪枝
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lmywan0203/article/details/136455273
版权

栈

有效的括号(20)

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。

有效字符串需满足：

  1. 左括号必须用相同类型的右括号闭合。
  2. 左括号必须以正确的顺序闭合。
  3. 每个右括号都有一个对应的相同类型的左括号。

示例 1：

输入：s = "()"
输出：true

示例 2：

输入：s = "()[]{}"
输出：true

示例 3：

输入：s = "(]"
输出：false

提示：

  • 1 <= s.length <= 104
  • s 仅由括号 '()[]{}' 组成
class Solution {
public:
    bool isValid(string s) {
        int n = s.size();
        if (n % 2 == 1) {
            return false;
        }

        unordered_map<char, char> pairs = {
            {')', '('},
            {']', '['},
            {'}', '{'}
        };
        stack<char> stk;
        for (char ch: s) {
            if (pairs.count(ch)) {
                if (stk.empty() || stk.top() != pairs[ch]) {
                    return false;
                }
                stk.pop();
            }
            else {
                stk.push(ch);//输入的是反括号
            }
        }
        return stk.empty();
    }
};

class Solution {
    public boolean isValid(String s) {
        Stack<Character>stack = new Stack<Character>();
        int n = s.length(), i;
        for(i = 0; i < n; i++){
            char c = s.charAt(i);
            if(c == '('){//栈内输入反括号，便于后续配对
                stack.push(')');
            }
            else if(c == '['){
                stack.push(']');
            }
            else if(c == '{'){
                stack.push('}');
            }
            else if(stack.isEmpty() || c != stack.pop()){//反括号形态或者栈为空则false
                return false;
            }
        }
        return stack.isEmpty();
    }
}

简化路径(71)

给你一个字符串 path ，表示指向某一文件或目录的 Unix 风格 绝对路径 （以 '/' 开头），请你将其转化为更加简洁的规范路径。

在 Unix 风格的文件系统中，一个点（.）表示当前目录本身；此外，两个点 （..） 表示将目录切换到上一级（指向父目录）；两者都可以是复杂相对路径的组成部分。任意多个连续的斜杠（即，'//'）都被视为单个斜杠 '/' 。 对于此问题，任何其他格式的点（例如，'...'）均被视为文件/目录名称。

请注意，返回的 规范路径 必须遵循下述格式：

  • 始终以斜杠 '/' 开头。
  • 两个目录名之间必须只有一个斜杠 '/' 。
  • 最后一个目录名（如果存在）不能 以 '/' 结尾。
  • 此外，路径仅包含从根目录到目标文件或目录的路径上的目录（即，不含 '.' 或 '..'）。

返回简化后得到的 规范路径 。

示例 1：

输入：path = "/home/"
输出："/home"
解释：注意，最后一个目录名后面没有斜杠。

示例 2：

输入：path = "/../"
输出："/"
解释：从根目录向上一级是不可行的，因为根目录是你可以到达的最高级。

示例 3：

输入：path = "/home//foo/"
输出："/home/foo"
解释：在规范路径中，多个连续斜杠需要用一个斜杠替换。

示例 4：

输入：path = "/a/./b/../../c/"
输出："/c"

提示：

  • 1 <= path.length <= 3000
  • path 由英文字母，数字，'.'，'/' 或 '_' 组成。
  • path 是一个有效的 Unix 风格绝对路径。
class Solution {
public:
    string simplifyPath(string path) {
        auto split = [](const string& s, char delim) -> vector<string> {
            vector<string> ans;
            string cur;
            for (char ch: s) {
                if (ch == delim) {
                    ans.push_back(move(cur));
                    cur.clear();
                }
                else {
                    cur += ch;
                }
            }
            ans.push_back(move(cur));
            return ans;
        };

        vector<string> names = split(path, '/');
        vector<string> stack;
        for (string& name: names) {
            if (name == "..") {
                if (!stack.empty()) {
                    stack.pop_back();
                }
            }
            else if (!name.empty() && name != ".") {
                stack.push_back(move(name));
            }
        }
        string ans;
        if (stack.empty()) {
            ans = "/";
        }
        else {
            for (string& name: stack) {
                ans += "/" + move(name);
            }
        }
        return ans;
    }
};

class Solution {
    public String simplifyPath(String path) {
        String[] names = path.split("/");//按照/分割字符串
        Deque<String> stack = new ArrayDeque<String>();
        for (String name : names) {
            if ("..".equals(name)) {//父目录
                if (!stack.isEmpty()) {//若双向队列非空
                    stack.pollLast();//删除双向队列最后一个元素
                }
            } else if (name.length() > 0 && !".".equals(name)) {//若有内容且不是.
                stack.offerLast(name);//插入到双向队列末尾
            }
        }
        StringBuffer ans = new StringBuffer();//定义一个可变数组
        if (stack.isEmpty()) {//如果双向队列为空
            ans.append('/');//添加到可变数组
        } else {
            while (!stack.isEmpty()) {
                ans.append('/');
                ans.append(stack.pollFirst());//添加双向队列的首元素
            }
        }
        return ans.toString();
    }
}

逆波兰表达式求值(150)

给你一个字符串数组 tokens ，表示一个根据 逆波兰表示法 表示的算术表达式。

请你计算该表达式。返回一个表示表达式值的整数。

注意：

  • 有效的算符为 '+'、'-'、'*' 和 '/' 。
  • 每个操作数（运算对象）都可以是一个整数或者另一个表达式。
  • 两个整数之间的除法总是 向零截断 。
  • 表达式中不含除零运算。
  • 输入是一个根据逆波兰表示法表示的算术表达式。
  • 答案及所有中间计算结果可以用 32 位 整数表示。

示例 1：

输入：tokens = ["2","1","+","3","*"]
输出：9
解释：该算式转化为常见的中缀算术表达式为：((2 + 1) * 3) = 9

示例 2：

输入：tokens = ["4","13","5","/","+"]
输出：6
解释：该算式转化为常见的中缀算术表达式为：(4 + (13 / 5)) = 6

示例 3：

输入：tokens = ["10","6","9","3","+","-11","*","/","*","17","+","5","+"]
输出：22
解释：该算式转化为常见的中缀算术表达式为：
  ((10 * (6 / ((9 + 3) * -11))) + 17) + 5
= ((10 * (6 / (12 * -11))) + 17) + 5
= ((10 * (6 / -132)) + 17) + 5
= ((10 * 0) + 17) + 5
= (0 + 17) + 5
= 17 + 5
= 22

提示：

  • 1 <= tokens.length <= 104
  • tokens[i] 是一个算符（"+"、"-"、"*" 或 "/"），或是在范围 [-200, 200] 内的一个整数

逆波兰表达式：

逆波兰表达式是一种后缀表达式，所谓后缀就是指算符写在后面。

  • 平常使用的算式则是一种中缀表达式，如 ( 1 + 2 ) * ( 3 + 4 ) 。
  • 该算式的逆波兰表达式写法为 ( ( 1 2 + ) ( 3 4 + ) * ) 。

逆波兰表达式主要有以下两个优点：

  • 去掉括号后表达式无歧义，上式即便写成 1 2 + 3 4 + * 也可以依据次序计算出正确结果。
  • 适合用栈操作运算：遇到数字则入栈；遇到算符则取出栈顶两个数字进行计算，并将结果压入栈中
class Solution {//c++
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> stk;
        int n = tokens.size();
        for (int i = 0; i < n; i++) {
            string& token = tokens[i];
            if (isNumber(token)) {
                stk.push(atoi(token.c_str()));
            } else {
                int num2 = stk.top();
                stk.pop();
                int num1 = stk.top();
                stk.pop();
                switch (token[0]) {
                    case '+':
                        stk.push(num1 + num2);
                        break;
                    case '-':
                        stk.push(num1 - num2);
                        break;
                    case '*':
                        stk.push(num1 * num2);
                        break;
                    case '/':
                        stk.push(num1 / num2);
                        break;
                }
            }
        }
        return stk.top();
    }

    bool isNumber(string& token) {
        return !(token == "+" || token == "-" || token == "*" || token == "/");
    }
};
class Solution {
public:
    int evalRPN(vector<string>& tokens) {
        stack<int> st;
        for (string s : tokens) {
            if (s == "+") {
                int a = st.top(); st.pop();
                int b = st.top(); st.pop();
                st.push(a+b);
            }
            else if (s == "-") {
                int a = st.top(); st.pop();
                int b = st.top(); st.pop();
                st.push(b-a);
            }
            else if (s == "*") {
                int a = st.top(); st.pop();
                int b = st.top(); st.pop();
                st.push(a*b);
            }
            else if (s == "/") {
                int a = st.top(); st.pop();
                int b = st.top(); st.pop();
                st.push(b/a);
            }
            else {
                st.push(stoi(s));
            }
        }
        return st.top();
    }
};

class Solution {
    public int evalRPN(String[] tokens) {
        Deque<Integer> stack = new LinkedList<Integer>();
        int n = tokens.length;
        for (int i = 0; i < n; i++) {
            String token = tokens[i];
            if (isNumber(token)) {
                stack.push(Integer.parseInt(token));//转换为整数
            } else {
                int num2 = stack.pop();//去栈顶元素并压栈
                int num1 = stack.pop();//去栈顶元素并压栈
                switch (token) {//运算符号
                    case "+":
                        stack.push(num1 + num2);
                        break;
                    case "-":
                        stack.push(num1 - num2);
                        break;
                    case "*":
                        stack.push(num1 * num2);
                        break;
                    case "/":
                        stack.push(num1 / num2);
                        break;
                    default:
                }
            }
        }
        return stack.pop();
    }
    //判断是否是数字
    public boolean isNumber(String token) {
        return !("+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token));
    }
}

链表

环形链表(141)

给你一个链表的头节点 head ，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，评测系统内部使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。注意：pos 不作为参数进行传递 。仅仅是为了标识链表的实际情况。

如果链表中存在环 ，则返回 true 。 否则，返回 false 。

示例 1：

img

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

示例 2：

img

输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。

示例 3：

img

输入：head = [1], pos = -1
输出：false
解释：链表中没有环。

提示：

  • 链表中节点的数目范围是 [0, 104]
  • -105 <= Node.val <= 105
  • pos 为 -1 或者链表中的一个 有效索引 。

**进阶：**你能用 O(1)（即，常量）内存解决此问题吗？

法一:集合
/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    bool hasCycle(ListNode *head) {
        unordered_set<ListNode*> s;
        while(head != NULL){
            if(s.count(head)){
                return true;
            }
            s.insert(head);
            head = head->next;
        }
        return false;
    }
};
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        Set<ListNode> s = new HashSet<ListNode>();
        while(head != null){
            if(!s.add(head)){//集合里面不能添加改结点
                return true;//直接输出true
            }
            head = head.next;//遍历下一个结点
        }
        return false;
    }
}

法二:快慢指针:
class Solution {
public:
    bool hasCycle(ListNode* head) {
        if (head == nullptr || head->next == nullptr) {
            return false;
        }
        ListNode* slow = head;
        ListNode* fast = head->next;
        while (slow != fast) {
            if (fast == nullptr || fast->next == nullptr) {//若没有环fast先走完
                return false;
            }
            slow = slow->next;
            fast = fast->next->next;
        }
        return true;
    }
};
public class Solution {
    public boolean hasCycle(ListNode head) {
        if (head == null || head.next == null) {
            return false;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (slow != fast) {
            if (fast == null || fast.next == null) {
                return false;
            }
            slow = slow.next;
            fast = fast.next.next;
        }
        return true;
    }
}

两数相加(2)

给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。

请你将两个数相加，并以相同形式返回一个表示和的链表。

你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

示例 1：

img

输入：l1 = [2,4,3], l2 = [5,6,4]
输出：[7,0,8]
解释：342 + 465 = 807.

示例 2：

输入：l1 = [0], l2 = [0]
输出：[0]

示例 3：

输入：l1 = [9,9,9,9,9,9,9], l2 = [9,9,9,9]
输出：[8,9,9,9,0,0,0,1]

提示：

  • 每个链表中的节点数在范围 [1, 100] 内
  • 0 <= Node.val <= 9
  • 题目数据保证列表表示的数字不含前导零
/**
 * 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* addTwoNumbers(ListNode* l1, ListNode* l2) {//逆序数字，第一位开始可以直接往后加
        ListNode *res = NULL, *cur = NULL;
        int jin = 0;
        while(l1 || l2){
            int tmp1 = l1 ? l1->val : 0;//l1不为空则为其val,否则为0
            int tmp2 = l2 ? l2->val : 0;//同上
            int c = tmp1 + tmp2 + jin;//进位加上这两个数之和
            if(!res){//结果链表为空
                res = cur = new ListNode(c % 10);//结果为和的个位数
            }
            else{//结果链表不为空
                cur->next = new ListNode(c % 10);//当前结点为和的个位数
                cur = cur->next;
            }
            jin = c / 10;//进位数
            if(l1){//l1不为空
                l1 = l1->next;
            }
            if(l2){
                l2 = l2->next;
            }
        }
        if(jin > 0){//最后的进位大于0，则加到最后
            cur->next = new ListNode(jin);
        }
        return res;
    }
};

//java版，击败100%
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        ListNode res = null, cur = null;
        int jin = 0;
        while(l1 != null || l2 != null){
            int tmp1 = l1 != null ? l1.val : 0;
            int tmp2 = l2 != null ? l2.val : 0;
            int c = tmp1 + tmp2 + jin;
            if(res == null){
                res = cur = new ListNode(c % 10);
            }
            else{
                cur.next = new ListNode(c % 10);
                cur = cur.next;
            }
            jin = c / 10;
            if(l1 != null){
                l1 = l1.next;
            }
            if(l2 != null){
                l2 = l2.next;
            }
        }
        if(jin > 0){
            cur.next = new ListNode(jin);
        }
        return res;
    }
}

合并两个有序链表(21)

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

示例 1：

img

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

  • 两个链表的节点数目范围是 [0, 50]
  • -100 <= Node.val <= 100
  • l1 和 l2 均按 非递减顺序 排列
/**
 * 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* mergeTwoLists(ListNode* list1, ListNode* list2) {
        ListNode* res = new ListNode(-1);
        ListNode* cur = res;
        while(list1 && list2){
            if(list1->val <= list2->val){
                cur->next = list1;
                list1 = list1->next;
            }
            else{
                cur->next = list2;
                list2 = list2->next;
            }
            cur = cur->next;
        }
        cur->next = list1 ? list1 : list2;
        return res->next; 
    }
};

//java版打败100%
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode res = new ListNode(-1), cur = res;//初始化，定义结果链表和当前链表
        while(list1 != null && list2 != null){
            if(list1.val <= list2.val){//list1值小的时候,当前结点设为list1
                cur.next = list1;
                list1 = list1.next;
            }
            else{
                cur.next = list2;
                list2 = list2.next;
            }
            cur = cur.next;//cur走到上面next所指的位置
        }
        cur.next = list1 == null ? list2 : list1;//没输出完的部分
        return res.next;//返回哑结点后面的部分
    }
}

随机链表的复制(138)

给你一个长度为 n 的链表，每个节点包含一个额外增加的随机指针 random ，该指针可以指向链表中的任何节点或空节点。

构造这个链表的 深拷贝。 深拷贝应该正好由 n 个 全新 节点组成，其中每个新节点的值都设为其对应的原节点的值。新节点的 next 指针和 random 指针也都应指向复制链表中的新节点，并使原链表和复制链表中的这些指针能够表示相同的链表状态。复制链表中的指针都不应指向原链表中的节点 。

例如，如果原链表中有 X 和 Y 两个节点，其中 X.random --> Y 。那么在复制链表中对应的两个节点 x 和 y ，同样有 x.random --> y 。

返回复制链表的头节点。

用一个由 n 个节点组成的链表来表示输入/输出中的链表。每个节点用一个 [val, random_index] 表示：

  • val：一个表示 Node.val 的整数。
  • random_index：随机指针指向的节点索引（范围从 0 到 n-1）；如果不指向任何节点，则为 null 。

你的代码 只 接受原链表的头节点 head 作为传入参数。

示例 1：

img

输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]

示例 2：

img

输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]

示例 3：

img

输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]

提示：

  • 0 <= n <= 1000
  • -104 <= Node.val <= 104
  • Node.random 为 null 或指向链表中的节点。
/*
// Definition for a Node.
class Node {
public:
    int val;
    Node* next;
    Node* random;
    
    Node(int _val) {
        val = _val;
        next = NULL;
        random = NULL;
    }
};
*/

class Solution {
public:
    Node* copyRandomList(Node* head) {
        unordered_map<Node*, Node*> map;//哈希
        Node* cur = head;
        while(cur != NULL){//复制val
            map[cur] = new Node(cur -> val);//当前结点对应的val
            cur = cur -> next;
        }
        cur = head;
        while(cur != NULL){//键为val对应的值的next和random
            map[cur] -> next = map[cur -> next];
            map[cur] -> random = map[cur -> random];
            cur = cur ->next;
        }
        return map[head];
    }
};
class Solution {
public:
        Node* copyRandomList(Node* head) {
        unordered_map<Node*, Node*> node_map;
        Node* p = head;
        while (p) {
            if (!node_map.count(p)) {//哈希表里面没有当前结点p
                Node* t = new Node(p->val);
                node_map[p] = t;//哈希表插入值为val的结点
            }
            Node* n = node_map[p];//插入val值后的结点
            if (p->next) {//插入next
                if (!node_map.count(p->next)) {
                    Node* t = new Node(p->next->val);
                    node_map[p->next] = t;                    
                }
                n->next = node_map[p->next];
            }
            if (p->random) {//插入random
                if (!node_map.count(p->random)) {
                    Node* t = new Node(p->random->val);
                    node_map[p->random] = t;                    
                }
                n->random = node_map[p->random];
            }
            p = p->next;
        }
        return node_map[head];
    }
};

//高效写法
class Solution {
public:
    unordered_map<Node *, Node *> origin2new;

    Node* copyRandomList(Node* head) {
        if(!head){
            return NULL;
        }
        if(origin2new.find(head) == origin2new.end()){
            Node *newHead = new Node(head -> val);
            origin2new[head] = newHead;
            newHead -> next = copyRandomList(head -> next);
            newHead -> random = copyRandomList(head -> random);
        }
        return origin2new[head];
    }
};

//java
/*
// Definition for a Node.
class Node {
    int val;
    Node next;
    Node random;

    public Node(int val) {
        this.val = val;
        this.next = null;
        this.random = null;
    }
}
*/

class Solution {
    public Node copyRandomList(Node head) {
        if(head == null){
            return null;
        }
        Node cur = head;
        Map<Node, Node> m = new HashMap<Node, Node>();
        while(cur != null){
            m.put(cur, new Node(cur.val));
            cur = cur.next;
        }
        cur = head;//复制val后重来插入next和random
        while(cur != null){
            m.get(cur).next = m.get(cur.next);
            m.get(cur).random = m.get(cur.random);
            cur = cur.next;
        }
        return m.get(head);
    }
}

反转链表(206)

给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

示例 1：

img

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]

示例 2：

img

输入：head = [1,2]
输出：[2,1]

示例 3：

输入：head = []
输出：[]

提示：

  • 链表中节点的数目范围是 [0, 5000]
  • -5000 <= Node.val <= 5000

**进阶：**链表可以选用迭代或递归方式完成反转。你能否用两种方法解决这道题？

/**
 * 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* prev = nullptr;
        ListNode* curr = head;
        while (curr) {
            ListNode* next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
        }
        return prev;
    }
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode prev = null; //前指针节点
        ListNode curr = head; //当前指针节点
        //每次循环，都将当前节点指向它前面的节点，然后当前节点和前节点后移
        while (curr != null) {
            ListNode nextTemp = curr.next; //临时节点，暂存当前节点的下一节点，用于后移
            curr.next = prev; //将当前节点指向它前面的节点
            prev = curr; //前指针后移
            curr = nextTemp; //当前指针后移
        }
        return prev;
    }
}

反转链表II(92)

给你单链表的头指针 head 和两个整数 left 和 right ，其中 left <= right 。请你反转从位置 left 到位置 right 的链表节点，返回 反转后的链表 。

示例 1：

img

输入：head = [1,2,3,4,5], left = 2, right = 4
输出：[1,4,3,2,5]

示例 2：

输入：head = [5], left = 1, right = 1
输出：[5]

提示：

  • 链表中节点数目为 n
  • 1 <= n <= 500
  • -500 <= Node.val <= 500
  • 1 <= left <= right <= n

进阶： 你可以使用一趟扫描完成反转吗？

法一:一次到位
/**
 * 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* reverseBetween(ListNode* head, int left, int right) {
        ListNode* res = new ListNode(-1);//定义哑结点，作为最后结果
        res->next = head;//拼到头结点处
        ListNode* pre = res;//定义新的结点与res相同
        for(int i = 0; i < left - 1; i++){//遍历到left-1处,因为pre是next
            pre = pre->next;
        }
        ListNode* cur = pre->next;//cur代表left处
        ListNode* cur2;//cur2只代表cur的下一个，所以没有固定的位置
        //cur2放到pre前面
        for(int i = 0; i < right - left; i++){
            cur2 = cur->next;//cur2表示cur下一个结点
            cur->next = cur2->next;//cur下一个结点指向cur2的下一个结点
            cur2->next = pre->next;//cur2下一个结点指向
            pre->next = cur2;//pre下一个结点指向cur2
        }
        return res->next;
    }
};
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 设置 dummyNode 是这一类问题的一般做法
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;
        ListNode pre = dummyNode;
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }
        ListNode cur = pre.next;
        ListNode next;
        for (int i = 0; i < right - left; i++) {
            next = cur.next;
            cur.next = next.next;
            next.next = pre.next;
            pre.next = next;
        }
        return dummyNode.next;
    }
}

法二:运用反转链表的方法
class Solution {
private:
    void reverseLinkedList(ListNode *head) {
        // 也可以使用递归反转一个链表
        ListNode *pre = nullptr;
        ListNode *cur = head;

        while (cur != nullptr) {
            ListNode *tmp = cur->next;
            cur->next = pre;
            pre = cur;
            cur = tmp;
        }
    }

public:
    ListNode *reverseBetween(ListNode *head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode *dummyNode = new ListNode(-1);
        dummyNode->next = head;

        ListNode *pre = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i = 0; i < left - 1; i++) {
            pre = pre->next;
        }

        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
        ListNode *rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode->next;
        }

        // 第 3 步：切断出一个子链表（截取链表）
        ListNode *leftNode = pre->next;
        ListNode *curr = rightNode->next;

        // 注意：切断链接
        pre->next = nullptr;
        rightNode->next = nullptr;

        // 第 4 步：同第 206 题，反转链表的子区间
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre->next = rightNode;
        leftNode->next = curr;
        return dummyNode->next;
    }
};
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        // 因为头节点有可能发生变化，使用虚拟头节点可以避免复杂的分类讨论
        ListNode dummyNode = new ListNode(-1);
        dummyNode.next = head;

        ListNode pre = dummyNode;
        // 第 1 步：从虚拟头节点走 left - 1 步，来到 left 节点的前一个节点
        // 建议写在 for 循环里，语义清晰
        for (int i = 0; i < left - 1; i++) {
            pre = pre.next;
        }

        // 第 2 步：从 pre 再走 right - left + 1 步，来到 right 节点
        ListNode rightNode = pre;
        for (int i = 0; i < right - left + 1; i++) {
            rightNode = rightNode.next;
        }

        // 第 3 步：切断出一个子链表（截取链表）
        ListNode leftNode = pre.next;
        ListNode curr = rightNode.next;

        // 注意：切断链接
        pre.next = null;
        rightNode.next = null;

        // 第 4 步：同第 206 题，反转链表的子区间
        reverseLinkedList(leftNode);

        // 第 5 步：接回到原来的链表中
        pre.next = rightNode;
        leftNode.next = curr;
        return dummyNode.next;
    }

    private void reverseLinkedList(ListNode head) {
        // 也可以使用递归反转一个链表
        ListNode pre = null;
        ListNode cur = head;

        while (cur != null) {
            ListNode tmp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = tmp;
        }
    }
}

删除链表的倒数第N个结点(19)

给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。

示例 1：

img

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]

示例 2：

输入：head = [1], n = 1
输出：[]

示例 3：

输入：head = [1,2], n = 1
输出：[1]

提示：

  • 链表中结点的数目为 sz
  • 1 <= sz <= 30
  • 0 <= Node.val <= 100
  • 1 <= n <= sz

**进阶：**你能尝试使用一趟扫描实现吗？

/**
 * 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* removeNthFromEnd(ListNode* head, int n) {
        int cnt = 0;
        ListNode* len = head;
        while(len != NULL){
            cnt++;
            len = len->next;
        }
        ListNode* res = new ListNode(0, head);
        ListNode* cur = res;
        for(int i = 1; i < cnt - n + 1; i++){
            cur = cur->next;
        }
        cur->next = cur->next->next;
        ListNode* res2 = res->next;
        delete res;
        return res2;
    }
};
//c++击败100%的写法
class Solution {
public:
    ListNode* removeNthFromEnd(ListNode* head, int n) {
        ListNode* dummy = new ListNode(0);
        dummy -> next = head;
        ListNode* p = dummy;
        ListNode* q = dummy;
        while(n--){
            q = q -> next;
        }
        while(q -> next){
            p = p -> next;
            q = q -> next;
        }
        p -> next = p -> next -> next;
        ListNode* ans = dummy -> next;
        delete dummy;
        return ans;
    }
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        int cnt = 0;
        ListNode len = head;
        while(len != null){
            cnt++;
            len = len.next;
        }
        int m = cnt - n;
        ListNode res = new ListNode(0, head);
        ListNode cur = res;
        for(int i = 1; i < m + 1; i++){
            cur = cur.next;
        }
        cur.next = cur.next.next;
        ListNode res2 = res.next;
        return res2;
    }
}

删除排序链表中的重复元素II(82)

给定一个已排序的链表的头 head ， 删除原始链表中所有重复数字的节点，只留下不同的数字 。返回 已排序的链表 。

示例 1：

img

输入：head = [1,2,3,3,4,4,5]
输出：[1,2,5]

示例 2：

img

输入：head = [1,1,1,2,3]
输出：[2,3]

提示：

  • 链表中节点数目在范围 [0, 300] 内
  • -100 <= Node.val <= 100
  • 题目数据保证链表已经按升序 排列
/**
 * 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* deleteDuplicates(ListNode* head) {
        if(!head){
            return head;
        }
        ListNode* res = new ListNode(0, head);
        ListNode* cur = res;
        while(cur->next != NULL && cur->next->next != NULL){//cur下一个和下下一个都不空
            if(cur->next->val == cur->next->next->val){//先两个对比
                int x = cur->next->val;//相同值
                while(cur->next != NULL && cur->next->val == x){//往后比较
                    cur->next = cur->next->next;//跳过
                }
            }
            else{
                cur = cur->next;
            }
        }
        return res->next;
    }
};

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode deleteDuplicates(ListNode head) {
        if (head == null) {
            return head;
        }
        
        ListNode dummy = new ListNode(0, head);

        ListNode cur = dummy;
        while (cur.next != null && cur.next.next != null) {
            if (cur.next.val == cur.next.next.val) {
                int x = cur.next.val;
                while (cur.next != null && cur.next.val == x) {
                    cur.next = cur.next.next;
                }
            } else {
                cur = cur.next;
            }
        }

        return dummy.next;
    }
}

旋转链表(61)

给你一个链表的头节点 head ，旋转链表，将链表每个节点向右移动 k 个位置。

示例 1：

img

输入：head = [1,2,3,4,5], k = 2
输出：[4,5,1,2,3]

示例 2：

img

输入：head = [0,1,2], k = 4
输出：[2,0,1]

提示：

  • 链表中节点的数目在范围 [0, 500] 内
  • -100 <= Node.val <= 100
  • 0 <= k <= 2 * 109
/**
 * 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* rotateRight(ListNode* head, int k) {
       if(k == 0 || head == NULL || head->next == NULL){//边界情况
           return head;
       }
       int n = 1;//计数算长度
       ListNode* cur = head;//cur代表最终的尾结点
       while(cur->next != NULL){
           cur = cur->next;
           n++;
       }
       int m = n - k % n;//移动位数为长度-次数对长度取模
       if(m == n){
           return head;//移动次数等于长度相当于不动
       }
       cur->next = head;//成环
       while(m--){
           cur = cur->next;//根据移动次数往后遍历
       }
       ListNode* res = cur->next;//结果链表的头结点
       cur->next = NULL;//尾结点next为空
       return res;
    }
};

class Solution {
    public ListNode rotateRight(ListNode head, int k) {
        if (k == 0 || head == null || head.next == null) {
            return head;
        }
        int n = 1;
        ListNode iter = head;
        while (iter.next != null) {
            iter = iter.next;
            n++;
        }
        int add = n - k % n;
        if (add == n) {
            return head;
        }
        iter.next = head;
        while (add-- > 0) {
            iter = iter.next;
        }
        ListNode ret = iter.next;
        iter.next = null;
        return ret;
    }
}

分隔链表(86)

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。

你应当 保留 两个分区中每个节点的初始相对位置。

示例 1：

img

输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

示例 2：

输入：head = [2,1], x = 2
输出：[1,2]

提示：

  • 链表中节点的数目在范围 [0, 200] 内
  • -100 <= Node.val <= 100
  • -200 <= x <= 200
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode small = new ListNode(0);//定义哑结点,存小于x的数
        ListNode smallHead = small;//小于x链表的头结点
        ListNode large = new ListNode(0);//定义哑结点,存大于等于x的数
        ListNode largeHead = large;//大于等于x链表的头结点
        while(head != null){//head往后遍历
            if(head.val < x){
                small.next = head;//small结点指向head
                small = small.next;
            }
            else{
                large.next = head;
                large = large.next;
            }
            head = head.next;
        }
        large.next = null;//large是大的结点，后面是空
        small.next = largeHead.next;//small和largeHead等结点是哑结点,得next
        return smallHead.next;//同理，需要next
    }
}

class Solution {
    public ListNode partition(ListNode head, int x) {
        ListNode small = new ListNode(0);
        ListNode smallHead = small;
        ListNode large = new ListNode(0);
        ListNode largeHead = large;
        while (head != null) {
            if (head.val < x) {
                small.next = head;
                small = small.next;
            } else {
                large.next = head;
                large = large.next;
            }
            head = head.next;
        }
        large.next = null;
        small.next = largeHead.next;
        return smallHead.next;
    }
}

de {

  • int val;

  • ListNode next;

  • ListNode() {}

  • ListNode(int val) { this.val = val; }

  • ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  • }
    */
    class Solution {
    public ListNode partition(ListNode head, int x) {
    ListNode small = new ListNode(0);//定义哑结点,存小于x的数
    ListNode smallHead = small;//小于x链表的头结点
    ListNode large = new ListNode(0);//定义哑结点,存大于等于x的数
    ListNode largeHead = large;//大于等于x链表的头结点
    while(head != null){//head往后遍历
    if(head.val < x){
    small.next = head;//small结点指向head
    small = small.next;
    }
    else{
    large.next = head;
    large = large.next;
    }
    head = head.next;
    }
    large.next = null;//large是大的结点，后面是空
    small.next = largeHead.next;//small和largeHead等结点是哑结点,得next
    return smallHead.next;//同理，需要next
    }
    }

class Solution {
public ListNode partition(ListNode head, int x) {
ListNode small = new ListNode(0);
ListNode smallHead = small;
ListNode large = new ListNode(0);
ListNode largeHead = large;
while (head != null) {
if (head.val < x) {
small.next = head;
small = small.next;
} else {
large.next = head;
large = large.next;
}
head = head.next;
}
large.next = null;
small.next = largeHead.next;
return smallHead.next;
}
}
lmywan0203
关注
  • 26
    点赞
  • 踩
  • 25
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
LeetCode上经典面试问题Java语言实现
12-21
这是个人搜集的LeetCode上一些经典面试问题的Java语言实现，涉及数组、链表、堆栈、队列、二叉树、并查集、字典树等15个维度，供各位学习参考使用！
leetcode题库-LeetCode:力扣题库
06-29
1. 数据结构：LeetCode中的问题经常涉及常见的数据结构，如数组、链表、栈、队列、堆、哈希表、树（二叉树、平衡树、红黑树等）、图等。理解并熟练运用这些数据结构是解决问题的关键。 2. 算法：包括排序（快速排序...
力扣-面试题 02.02题（Java）
qq_40467670的博客
04-27 122
题目链接：https://leetcode-cn.com/problems/kth-node-from-end-of-list-lcci/ 题目如下： /** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */ class Solution { public
【Java语言】力扣系列---- 面试题 16.11. 跳水板
一只小白的奋斗历程的博客
07-08 153
你正在使用一堆木板建造跳水板。有两种类型的木板，其中长度较短的木板长度为shorter，长度较长的木板长度为longer。你必须正好使用k块木板。编写一个方法，生成跳水板所有可能的长度。 返回的长度需要从小到大排列。 示例： 输入： shorter = 1 longer = 2 k = 3 输出： {3,4,5,6} 提示： 0 < shorter <= longer 0 <= k <= 100000 具体代码实现如下： class Solution { public int
【java刷题】力扣 程序员面试金典（第 6 版）
OAOII的博客
02-22 671
程序员面试金典（第 6 版）
【Java】力扣_每日一题_面试题01.07.旋转矩阵_中等
includei的博客
04-07 386
题目链接：https://leetcode-cn.com/problems/rotate-matrix-lcci/ 题目描述 给你一幅由 N × N 矩阵表示的图像，其中每个像素的大小为 4 字节。请你设计一种算法，将图像旋转 90 度。 不占用额外内存空间能否做到？ 第一次编辑代码： class Solution { public void rotate(int[][] matrix) ...
leetcode答案-LeetCode:力扣答案
06-30
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，旨在帮助程序员提升技能，准备面试，并在解决问题中获得乐趣。这个“leetcode答案-LeetCode:力扣答案”很可能包含了一组解决方案，涵盖了LeetCode上的各种算法...
leetcode和oj-LeetCode:力扣OJ
06-30
力扣（LeetCode）是一个非常受欢迎的在线编程挑战平台，专为程序员提升技能和准备面试而设计。"oj"通常指的是“在线判题系统”（Online Judge），在编程领域，它是一个提供问题、接收用户提交代码并进行测试的平台。...
leetcode答案-LeetCode:力扣完成题目答案
06-30
1. **数据结构**：LeetCode题目经常涉及常见的数据结构，如数组、链表、栈、队列、哈希表、树（二叉树、平衡树、堆等）、图等。解题过程中，理解并熟练运用这些数据结构是至关重要的。 2. **算法**：包括排序算法...
leetcode答案-LeetCode:我的力扣答案
06-30
力扣（LeetCode）是一个非常受欢迎的在线...此外，这也可以作为面试准备的资源，帮助你熟悉常见的编程面试题，并提升自己的编码能力。如果你遇到不理解的部分，可以参考其他人的解答，或者查阅相关资料进行深入学习。
Java面试突击-V3.0.pdf
03-18
将面试题转成PDF文档更方便复习和查看。主要有Java基础、集合容器、异常、JVM、Linux、MyBatis、Netty、Redis、SpringBoot、Spring Cloud、SpringMVC、Spring、Tomcat、ZooKeeper、消息中间件MQ与RabbitMQ等等,适合正在找校招的同学。
js代码-给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。
07-14
js代码-给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。 有效字符串需满足： 左括号必须用相同类型的右括号闭合。 左括号必须以正确的顺序闭合。
JAVA刷力扣《算法面试题汇总》
a_123456598的博客
10-23 847
JAVA刷力扣《算法面试题汇总》 一.开始之前 1.找出只出现一次的数字，其余均为两次 异或运算(^)就行了。 2.多数元素（次数多于n/2的元素，假设数组中一定存在） （1）排序法：中间位置 先排序Array.sort(nums)，然后取nums[nums.length/2] class Solution { public int majorityElement(int[] nums) { Arrays.sort(nums); return num.
力扣面试题 17.16. 按摩师——Java
yearling的博客
03-24 294
这道题不难，就是记录一下第一次双百 题目描述： 一个有名的按摩师会收到源源不断的预约请求，每个预约都可以选择接或不接。在每次预约服务之间要有休息时间，因此她不能接受相邻的预约。给定一个预约请求序列，替按摩师找到最优的预约集合（总预约时间最长），返回总的分钟数。 思路：动态规划思想解决问题。从左往右依次记录每个位置的最大时间，然后当处于i位置是时，访取i-2，i-3位置的值（当然这里要注意处理下标越...
7.Java判断和循环+面试相关力扣算法题详解
最新发布
qq_66238381的博客
01-23 8132
顺序结构语句是Java程序默认的执行流程,按照代码的先后顺序,从上到下依次执行。
Java面试突击
weixin_45278293的博客
05-31 583
JAVA面试突击（LeetCode书籍-Java面试突击 总结） 基本语法 基本数据结构 Java的基本数据类型有8种，包括6种数字类型，1种字符类型和1种布尔类型。 数字类型包括4种整数类型和2种浮点数类型，4种整数类型是byte、short、int、long，2种浮点数类型是float和double。 字符类型是char，用于表示单个字符。 布尔类型是boolean，包括true和false两种取值。 基本数据类型 存储大小 取值范围 默认值 字节数 包装类 byte 8位有符号
力扣笔试题day01
wuxudong12138的博客
08-21 441
Day01第一题：两数之和第二题：两数相加第三题：无重复字符的最长子串 第一题：两数之和 给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。 示例: 给定 nums = [2, 7, 11, 15], target = 9 因为 nums[0] ...
力扣算法Java常见面试题之二叉树的层序遍历，力扣算法学习之路
huqiankunlol的博客
12-09 326
这道题是我司小伙伴进公司面试遇到的一道题，也是力扣热题之一，难度中等，题目如下 二叉树是常见的数据结构之一，一般我们遇到的都是二叉树的 前序(先序) 中序 后续 这三种遍历方式，层序遍历就是一层一层的输出每一层节点的值，看返回的数据结构可知，一个list对象里面包含一个list对象，一个用来存放每一层的节点值，一个是所有层的节点值。 层序遍历思路理解: 用两个linkedlist对象，存在树的节点，一个是树的头节点，一个是树的左右节点, 每次取头节点放到...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值