10.16刷题小结

三道剑指offer一道LeetCode。

1.顺时针打印矩阵，很经典的题，面试被问过

a:每次都是打印一个矩阵的边界，那么矩阵只要知道左上角和右下角的坐标就可以了，四个边依次打印即可，每次打印完四个边然后左上角的坐标++，右下角的坐标--，矩阵小一圈。接着重复操作。

b:两个特殊情况只有一行或者只有一列单独处理一下即可。

vector<int> printMatrix(vector<vector<int> > matrix) {
        int n=matrix.size();
        vector<int>res;
        if(n<=0)
        {
            return res;
        }
        int m=matrix[0].size();
        int currl=0;int curcl=0;
        int currr=n-1;int curcr=m-1;
        while(currl<=currr&&curcl<=curcr)
        {
            if(currl==currr)
            {
                int tmpc=curcl;
                while(tmpc<=curcr)
                {
                    res.push_back(matrix[currl][tmpc++]);
                }
            }
            else if(curcl==curcr)
            {
                int tmpr=currl;
                while(tmpr<=currr)
                {
                    res.push_back(matrix[tmpr++][curcl]);
                }
            }
            else
            {
                int tmpc=curcl;
                int tmpr=currl;
                while(tmpc<curcr)
                {
                    res.push_back(matrix[currl][tmpc++]);
                }
                while(tmpr<currr)
                {
                    res.push_back(matrix[tmpr++][tmpc]);
                }
                while(tmpc>curcl)
                {
                    res.push_back(matrix[tmpr][tmpc--]);
                }
                while(tmpr>currl)
                {
                    res.push_back(matrix[tmpr--][tmpc]);
                }
            }
            currl++;curcl++;currr--;curcr--;
        }
        return res;
    }

2.实现一个求栈中元素最小值函数，O（1）时间复杂度

申请一个辅助栈存放压入当前元素下，栈中元素的最小值为多少即可，如果压入的数字大于等于辅助栈栈顶值，那么辅助栈再压入一个栈顶值即可，小于的话，就把压入数字压入辅助栈。记得弹出操作辅助栈也得跟着弹出。

void push(int value) {
        s1.push(value);
        if(s2.empty()||s2.top()>=value)
        {
            s2.push(value);
        }
        else
        {
            s2.push(s2.top());
        }
    }
    void pop() {
        if(!s1.empty()&&!s2.empty())
        {
            s1.pop();
            s2.pop();
        }
    }
    int top() {
        if(!s1.empty())
        {
            return s1.top();
        }
    }
    int min() {
        if(!s2.empty())
        {
            return s2.top();
        }
    }
    stack<int>s1;
    stack<int>s2;

3.栈的压入和弹出，给定两个数组，一个是栈的压入数组的顺序，判断另外一个数组是否有可能是弹出的序列。

遍历弹出序列的节点，并准备一个辅助栈，如果当前栈为空或者当前栈顶的值不等于弹出序列当前被遍历的点，那么就把压入数组的值压到栈中。如果相等可以把栈顶弹出，继续遍历下一个弹出数组的元素。遍历完任意一个数组都可以跳出这个操作。

最后判断下栈是否为空，如果为空，说明弹出序列是一种可能的情况，否则不可能。

bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack<int>s;
        int j=0;
        for(int i=0;i<popV.size()&&j<=pushV.size();)
        {
            if(s.empty())
            {
                if(j<pushV.size())
                {
                    s.push(pushV[j++]);
                }
                else
                {
                    break;
                }
            }
            if(s.top()==popV[i])
            {
                s.pop();
                i++;
            }
            else{
                if(j<pushV.size())
                {
                    s.push(pushV[j++]);
                }
                else
                {
                    break;
                }
            }
        }
        if(!s.empty())
        {
            return false;
        }
        return true;
    }

4.将给定的单链表L： L 0→L 1→…→L n-1→L n,重新排序为： L 0→L n →L 1→L n-1→L 2→L n-2→…

要求使用原地算法，并且不改变节点的值。例如：对于给定的单链表{1,2,3,4}，将其重新排序为{1,4,2,3}

a:快慢指针找到中间位置。

b:将后半段链表反转

c:重新链接链表。注意：先保存下两个链表的next指针，将第一个指针的next指针赋值为第二个指针之后，更新第一个节点后，注意把第二个指针的next指针指向更新的第一个节点，再更新第二个节点。

void reorderList(ListNode *head) {
        if(!head||!head->next||!head->next->next)
        {
            return;
        }
        ListNode *fastnode=head->next;
        ListNode *slownode=head;
        while(fastnode&&fastnode->next)//快慢指针找到中间节点
        {
            slownode=slownode->next;
            fastnode=fastnode->next->next;
        }
       
        ListNode *phead=slownode->next;
        slownode->next=nullptr;
        ListNode *pre=nullptr;
        ListNode *pnext=phead->next;
        while(phead)
        {
            phead->next=pre;
            pre=phead;
            phead=pnext;
            if(phead)
            {
                pnext=phead->next;
            }
            else
            {
                break;
            }
        }
        ListNode *p1=head;
        ListNode *p2=pre;
        ListNode *tmp1=p1->next;
        ListNode *tmp2=p2->next;
        while(p1&&p2)
        {
            tmp1=p1->next;
            tmp2=p2->next;
            p1->next=p2;
            p1=tmp1;
            p2->next=p1;
            p2=tmp2;
        }
    }