leetcode 3

    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        for (int i = 0 ; i < n; i++) {
            for (int j = 0; j < i; j++) {
                swap(matrix[i][j], matrix[j][n - i - 1]);
            }
        }
    } }; ```
    解答错误 
    执行用时: 0 ms 
    Case 1 
    输入 matrix = [[1,2,3],[4,5,6],[7,8,9]] 
    输出               [[7,4,3],[8,5,6],[1,2,9]] 
    预期结果        [[7,4,1],[8,5,2],[9,6,3]]

看了解题思路，需要水平翻转 + 主对角线翻转
水平翻转：

主对角线翻转：

对于水平轴翻转而言，我们只需要枚举矩阵上半部分的元素，和下半部分的元素进行交换，即
matrix[i][j] ==> matrix[n - i - 1][j]
对于主对角线翻转而言，我们只需要枚举对角线左侧的元素，和右侧的元素进行交换，即
matrix[i][j] ==> matrix[j][i]
联立可得：
matrix[i][j] ==> matrix[j][n - i - 1]

class Solution {
public:
    void rotate(vector<vector<int>>& matrix) {
        int n = matrix.size();
        for (int i = 0 ; i < n / 2; i++) {
            for (int j = 0; j < n; j++) {
                swap(matrix[i][j], matrix[n - i - 1][j]);
            }
        }

        for (int i = 0 ; i < n ; i++) {
            for (int j = 0; j < i; j++) {
                swap(matrix[i][j], matrix[j][i]);
            }
        }
    }
};

二.链表

1. 相交链表

相交链表
当链表 headA和 headB 都不为空时，创建两个指针 pA 和 pB，初始时分别指向两个链表的头节点 headA 和 headB，然后将两个指针依次遍历两个链表的每个节点。具体做法如下：

• 每步操作需要同时更新指针 pA 和 pB。
• 如果指针 pA 不为空，则将指针 pA 移到下一个节点；如果指针 pB 不为空，则将指针 pB 移到下一个节点。
• 如果指针 pA 为空，则将指针 pA 移到链表 headB 的头节点；如果指针 pB 为空，则将指针 pB 移到链表 headA 的头节点。
• 当指针 pA 和 pB 指向同一个节点或者都为空时，返回它们指向的节点或者 null。

/\*\*
 \* Definition for singly-linked list.
 \* struct ListNode {
 \* int val;
 \* ListNode \*next;
 \* ListNode(int x) : val(x), next(NULL) {}
 \* };
 \*/
class Solution {
public:
    ListNode \*getIntersectionNode(ListNode \*headA, ListNode \*headB) {
        if (headA == nullptr || headB == nullptr) {
            return nullptr;
        }
        
        ListNode \*pa = headA, \*pb = headB;
        while (pa != pb) {
            pa = pa == nullptr ? headB : pa->next;
            pb = pb == nullptr ? headA : pb->next;
        }
        return pa;
    }
};

2.反转链表

反转链表
假设链表为 1→2→3→∅1，我们想要把它改成 ∅←1←2←3。

在遍历链表时，将当前节点的 next 指针改为指向前一个节点。由于节点没有引用其前一个节点，因此必须事先存储其前一个节点。在更改引用之前，还需要存储后一个节点。最后返回新的头引用。

1.保存后继节点 tmp = cur->next
2.让当前节点指向pre节点 cur->next = pre
3.暂存当前节点，这是后继节点需要指向的pre, pre = cur
4.访问下一个节点 cur = tmp

pre最终保存的是头节点

/\*\*
 \* 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\* pre = nullptr;
        ListNode\* cur = head;
        while(cur != nullptr) { 
            ListNode\* nextnode = cur->next;
            cur->next = pre;
            pre = cur;
            cur = nextnode;
        }
        return pre;
    }
};

3.回文链表

回文链表
存数组中进行比较，但是空间复杂度为o(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:
    bool isPalindrome(ListNode\* head) {
        vector<int> ans;
        while(head != nullptr) {
            ans.push\_back(head->val);
            head = head->next;
        }
        int n = ans.size();
        for (int i = 0, j = n - 1; i < j; i++, j--) {
            if (ans[i] != ans[j]) return false;
        }
        return true;
    }
跳槽是每个人的职业生涯中都要经历的过程，不论你是搜索到的这篇文章还是无意中浏览到的这篇文章，希望你没有白白浪费停留在这里的时间，能给你接下来或者以后的笔试面试带来一些帮助。



也许是互联网未来10年中最好的一年。WINTER IS COMING。但是如果你不真正的自己去尝试尝试，你永远不知道市面上的行情如何。这次找工作下来，我自身感觉市场并没有那么可怕，也拿到了几个大厂的offer。在此进行一个总结，给自己，也希望能帮助到需要的同学。

### 面试准备



面试准备根据每个人掌握的知识不同，准备的时间也不一样。现在对于前端岗位，以前也许不是很重视算法这块，但是现在很多公司也都会考。建议大家平时有空的时候多刷刷leetcode。算法的准备时间比较长，是一个长期的过程。需要在掌握了大部分前端基础知识的情况下，再有针对性的去复习算法。面试的时候算法能做出来肯定加分，但做不出来也不会一票否决，面试官也会给你提供一些思路。