剑指offer1-10题附带解析

1.用两个栈实现队列

用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/yong-liang-ge-zhan-shi-xian-dui-lie-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

class CQueue {
    stack<int> s1;
    stack<int> s2;
    //入队列：如果s1为空，直接在s1插入，若s1不为空，先将s1中的数据全部挪到s2，然后s1插入
    //出队列：如果s1为空，返回-1.若s1不为空，先将s2中数据全部挪到s1，再把s1的顶部删除一个数据
public:

    CQueue() 
    {

    }   
    void appendTail(int value) 
    {
        if(s1.empty())
        {
            s1.push(value);
        }
        else
        {
           while(!s1.empty())
           {
               int tmp = s1.top();
               s2.push(tmp);
               s1.pop();
           }
           s1.push(value);
        }
    }
    
    int deleteHead() 
    {
        if(s1.empty())
        {
            return -1;
        }
        while(!s2.empty())
        {
            int tmp = s2.top();
            s1.push(tmp);
            s2.pop();
        }
        int top = s1.top();
        s1.pop();
        return top;
    }
};

2.包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

class MinStack {
    stack<int> s;//作为基栈
    stack<int> min_s;//用来存最小min的栈

public:
    /** initialize your data structure here. */
    MinStack() {
    }
    
    void push(int x) {
        //插入一个数据时，如果s为空，说明第一次插入，则s和min_s都插入x
        //若s不为空，s正常插入x，然后x要和min_s的top进行比较，如果x比栈顶的数据还要小，就在min_s插入x，否则，将栈顶的值在插入一次
        if(s.empty())
        {
            s.push(x);
            min_s.push(x);
        }
        else
        {
            s.push(x);
            int min = min_s.top();
            if(min > x)
            {
                min_s.push(x);
            }
            else
            {
                min_s.push(min);
            }
        }

    }
    
    void pop() {
        s.pop();
        min_s.pop();
    }
    
    int top() {
        return s.top();

    }
    
    int min() {
        return min_s.top();
    }
};

3.从尾到头打印链表

输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。

class Solution {
    stack<int> s;//遍历链表将链表中的数据全部入栈
    vector<int> v;//出栈把数据放进vector中。一进一出，所有数据就已经逆置了
public:
    vector<int> reversePrint(ListNode* head) {
        ListNode* cur = head;
        while(cur)
        {
            s.push(cur->val);
            cur = cur -> next;
        }
        while(!s.empty())
        {
            v.push_back(s.top());
            s.pop();
        }
        return v;
    }
};

4.反转链表

定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。

class Solution {
    stack<int> s;//还是借助栈的一进一出将数据逆置
public:
    ListNode* reverseList(ListNode* head) {
        ListNode* cur = head;
        while(cur)//第一次遍历链表，将链表元素入栈
        {
            s.push(cur->val);
            cur = cur->next;
        }
        cur = head;
        while(cur)//第二次遍历链表，将栈中的数据出栈放进链表中
        {
            cur->val = s.top();
            cur = cur->next;
            s.pop();
        }
        return head;
    }
};

5. 复杂链表的复制请实现

copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。

class Solution {
public:
    Node* copyRandomList(Node* head) {
        if(head == nullptr)
        {
            return nullptr;
        }
        Node* cur = head;
        while(cur)//第一次遍历原链表，把新链表的val解决，并将新链表的每一个元素链接的原链表的每一个元素后面
        {
            Node* newnode = new Node(cur->val);
            newnode->next = cur->next;
            cur->next = newnode;
            cur = newnode->next;
        }
        cur = head;
        while(cur)//第二次遍历原链表，把新链表的random解决，newnode的dandom就是cur->random->next
        {
            if(cur->random != nullptr)
            {
                Node* newnode = cur->next;
                newnode->random = cur->random->next;
            }
            cur = cur->next->next;
        }
        cur = head;
        Node* newhead = cur->next;
        while(cur->next->next)//第三次遍历新链表，将新链表与原链表解绑，解决新链表的next,并将原链表复原
        {
            Node* newnode = cur->next;
            Node* Next = newnode->next;
            newnode->next = Next->next;
            cur->next = Next;
            cur = Next;
        }
        cur->next = nullptr;

        return newhead;

    }
};

6.替换空格

请实现一个函数，把字符串 s 中的每个空格替换成"%20"。

class Solution {
public:
    string replaceSpace(string s) 
    {
        int count = 0;
        int len = s.size();
        for(auto c : s)
        {
            if(c == ' ')
            {
                count++;
            }
        }
        s.resize(len + 2*count);//先数空格数量扩容至原长加2*空格数量；
        int i = len - 1;
        int j = s.size() - 1;
        while(i < j)//i
        {
            if(s[i] == ' ')//如果s[i]是空格，要改成%20
            {
                s[j] = '0';
                s[j-1] = '2';
                s[j-2] = '%';
                j -= 3;
                i--;
            }
            else//s[i]不是空格，需要把当前位置的元素向后挪动
            {
                s[j] = s[i];
                i--;
                j--;
            }
        }
        return s;
    }
    
};

7.左旋转字符串

字符串的左旋转操作是把字符串前面的若干个字符转移到字符串的尾部。请定义一个函数实现字符串左旋转操作的功能。比如，输入字符串"abcdefg"和数字2，该函数将返回左旋转两位得到的结果"cdefgab"。

class Solution {
public:
    string reverseLeftWords(string s, int n) {
        //三次逆置
        reverse(s.begin(), s.begin() + n);
        reverse(s.begin() + n, s.end());
        reverse(s.begin(), s.end());
        return s;
    }
};

8.数组中重复的数字

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

class Solution {
    vector<int> v;
public:
    int findRepeatNumber(vector<int>& nums) {
        v.resize(nums.size(), -1);
        for(int i = 0;i < nums.size();i++)
        {
            int index = nums[i];
            if(v[index] == -1)
            {
                v[index] = index;
            }
            else
            {
                return index;
            }
        }
        return -1;
    }
};

9.在排序数组中查找数字 I

统计一个数字在排序数组中出现的次数。

class Solution {
public:
    int search(vector<int>& nums, int target) {

        int count = 0;
        int left = 0;
        int right = nums.size()-1;
        while(left <= right)//二分查找
        {
            int mid = (left + right) / 2;
            if(nums[mid] > target)
            {
                right = mid - 1;
            }
            else if(nums[mid] < target)
            {
                left = mid + 1;
            }
            else
            {
                count++;//此时我们找到一个与target相等的值
                //数组中可能不止一个target，但是由于非降序排列，其余可能存在的target一定在当前位置的左右
                //我们只需要从当前位置分别像左右遍历，如果还有target，count就++
                for(int i = mid-1;i >= left; i--)//往左面找
                {
                    if(nums[i] == target)
                    {
                        count++;
                    }
                }
                for(int i = mid+1;i <= right; i++)//往右面找
                {
                    if(nums[i] == target)
                    {
                        count++;
                    }
                }
                break;  
            }
        }
        return count;
    }
};

10.0～n-1中缺失的数字

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

class Solution {
public:
    int missingNumber(vector<int>& nums) {
        int len = nums.size();
        int right = len-1;
        int left = 0;
        if(nums[right] == right)//此时缺的一定是最后一个数，也就是len。
        {
            return len;
        }
        while(left <= right)
        {
            int mid = (left + right) / 2;
            if(nums[mid] == mid)
            {
                left = mid+1;
            }
            else//只有一种可能就是nums[mid] > mid且大1,而不可能nums[mid]
            {
                right = mid -1;
            }
        }
        return left;
    }
};