acwing-01

acwing-01

翻转链表（简单）

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

思考题：

• 请同时实现迭代版本和递归版本。

样例

输入:1->2->3->4->5->NULL

输出:5->4->3->2->1->NULL

题解：

• 迭代版本

  利用三个指针：

  p作为活动指针用于遍历链表

  pre用于指向活动指针的前一个结点

  cur用于获取活动指针的下一个结点

  反转后继结点指针实现反转链表的功能

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* reverseList(ListNode* head) {
        ListNode *pre=NULL,*p=head,*cur=head;
        while(p!=NULL){
            cur=p->next;
            p->next=pre;
            pre=p;p=cur;
        }
       return pre;
    }
};

• 递归版本

  主要思路：ListNode* reverseList(ListNode* head)该函数作为获取当前链表中最后一个结点

  修改链表最后一个结点为NULL，实现反转链表的功能

class Solution {
public:
    ListNode* reverseList(ListNode* head) {
       ListNode *pre=NULL,p=head;
       if(p==NULL||p->next==NULL)return p;
       while(p->next!=NULL){
            pre=p;
            p=p->next;
       }
       pre->next=NULL;
       p->next=reverseList(head);
       return p;
    }
};

链表中环的入口结点（中等）

给定一个链表，若其中包含环，则输出环的入口节点。

若其中不包含环，则输出null。

样例

给定如上所示的链表：
[1, 2, 3, 4, 5, 6]
2
注意，这里的2表示编号是2的节点，节点编号从0开始。所以编号是2的节点就是val等于3的节点。

则输出环的入口节点3.

题解

• 设置快慢指针font和rear

• font每次在链表上走一步，rear每次在链表上走两步

• 如果rear出现NULL 的情况，那说明该链表不出现环

• 如果两个指针指向了同一节点，说明，两者相遇是在链表的环上的

• 通过再次推进rear指针并计数，当两个指针再次相遇的时候，得到链表环上的结点个数n

• 初始化快慢指针font和rear

• 让rear指针先走n步，之后font指针再走，当两个指针相遇的时候那个结点便是入口结点

class Solution {
public:
    ListNode *entryNodeOfLoop(ListNode *head) {
        ListNode *f=head,*r=head;
        if(head==NULL)return NULL;
        int cnt=0;
        do{
            if(r->next==NULL||r->next->next==NULL)return NULL;
            r=r->next;
            f=f->next;
        }while(f==r);
        do{
            r=r->next;
            cnt++;
        }while(r==f);
        ListNode *a=head,*b=head;
        while(cnt--){
            a=a->next;
        }
        while(a!=b){
            a=a->next;
            b=b->next;
        }
        return a;
    }
};

顺时针打印矩阵（中等）

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

样例

输入：
[
  [1, 2, 3, 4],
  [5, 6, 7, 8],
  [9,10,11,12]
]

输出：[1,2,3,4,8,12,11,10,9,5,6,7]

题解

• 采用根据左下右上的方法遍历二维数组
• 依据遍历的顺序依次将得到的数组中的元素放入结果中
• 这里用vis数组判断数组中的元素是否已经访问

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> res;
        int n=matrix.size();
        if(n==0)return res;
        int m=matrix[0].size();
        if(m==0)return res;
        int xx[4]={0,1,0,-1},yy[4]={1,0,-1,0};
        int x=0,y=0;
        int k=n*m,i=0;
        vector<vector<bool > > vis(n,vector<bool>(m,false));
        res.push_back(matrix[x][y]);vis[x][y]=true;k--;
        while(k>0){
            while((y+yy[i])>=0&&(y+yy[i])<m&&(x+xx[i])>=0&&(x+xx[i])<n&&!vis[x+xx[i]][y+yy[i]]){
                x=x+xx[i];y=y+yy[i];k--;
                res.push_back(matrix[x][y]);
                vis[x][y]=true;
            }
            i++;
            i=i%4;
        }
        return res;
    }
};