【leetcode top100】0926 删除链表的倒数第N个节点，旋转排序数组

目录

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

33. 搜索旋转排序数组 - 力扣（LeetCode）

---

 

思路：使用双指针找到要删除节点的前一个节点，之后删除节点，本问题的难点在于指针初始化问题，不能将指针初始化指向head，若指向head，则考虑特殊情况下，链表中只有一个节点，要删除这个节点时无法使left指针指向该节点的前一个节点，同时这种情况也告诉我们，right节点应该指向链表末尾的nullptr节点。所以，新建一个dummyHead 哑结点，将指针初始化为哑结点，指针迭代时的边界也应该设置为right == nullptr。最后停止迭代的时候：left指向删除节点的前一个节点，right指针指向链表末尾的nullptr。

/**
 * 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) {
        //使用双指针找到需要删除节点的前一个节点
        if (!head) return head;
        ListNode* dummpyHead = new ListNode(-1);
        dummpyHead->next = head;
        ListNode* left = dummpyHead,*right = dummpyHead;
        for (int i = 0;i < n + 1;i++) right = right->next; // 需要注意
        while (right){
            left = left->next;
            right = right->next;
        }
        ListNode* delNode = left->next;
        left->next = delNode->next;
        delete delNode;
        return dummpyHead->next;
    }
};

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        #双指针
        # 边界
        if not head: return head
        dummpyHead = ListNode(-1)
        dummpyHead.next = head
        left,right = dummpyHead,dummpyHead
        for _ in range(n+1): right = right.next
        while right:
            left = left.next
            right = right.next
        delNode = left.next
        left.next = delNode.next
        del delNode
        return dummpyHead.next

注：时间复杂度：O(L)，L是链表的长度；空间复杂度：O(1)

33. 搜索旋转排序数组 - 力扣（LeetCode）

思路： ，能想到二分法。通过题目知道数组进行了旋转，现在的问题是二分法找到重点之后不知道左右哪一个区间是有序的，但是可以确定的是肯定有一边是有序的，现在去判断左边还是右边区间是否是有序的，若左边有序，判断target是否在当前区间中，若在，使用二分法进行搜索；若右边有序，判断target是否在当前曲建忠，若在，使用二分法进行搜索。

class Solution {
public:
    int search(vector<int>& nums, int target) {
        int n = nums.size();
        if (!n) return -1;
        if (n == 1) return nums[0] == target ? 0 : -1;
        int left = 0,right = n-1;
        while (left <= right){
            int mid = left + (right-left) / 2;
            if (target == nums[mid]) return mid;
            else if (nums[0] <= nums[mid]){
                if (nums[0] <= target && target < nums[mid]) right = mid-1;
                else left = mid+1;
            }
            else {
                if (nums[mid] < target && target <= nums[n-1]) left = mid+1;
                else right = mid-1;
            }
        }
        return -1;
    }
};