ReaderMX.
Python技术迷

只谈月薪，程序员40K的人多吗？

PWeb前端专栏约 5 分钟

最近看到一网友发帖提问：程序员月薪40k的人多吗？诶，说到这个我就来劲了，我也很好奇，这样的薪资在程序员圈里究竟算不算牛逼的？

Image

咱们先来说说大厂的情况。说到大厂，很多人的第一反应就是“钱多事少离家近”。不过，月薪40K在一些头部公司看来，的确不算稀奇。

Image

我之前偶尔翻翻招聘信息，不少大厂开出的校招薪资都在30K以上，甚至有的能达到40K以上，但前提是你得够牛，不仅技术要硬，项目经验、解决问题的能力也得跟得上。

Image

不过，跳出大厂的圈子，情况就复杂多了。在一些小公司，或者说在二三线城市，月薪40K可就没有那么好拿了。

即便是在北上广深这样的一线城市，要么你在小公司里摸爬滚打了7、8年，或者技能特别突出，否则想要拿到40K以上的月薪也不是那么容易的事。

Image

我们可以看到网上经常有人晒出高薪，这其中当然有真有假，但在大厂工作的程序员相对更愿意分享自己的薪资。这就造成了一种错觉——似乎程序员只要稍微努力一点，月入40K就手到擒来了。

专属福利 
👉点击领取：最全Python资料合集

可事实上，这样的高薪水平并不是普遍现象。我们可以看到，网上那些晒薪资的，很多都是大厂的员工。而且别忘了，大厂的门槛本身就不低。

Image

所以，如果你问我“程序员月薪40K的人多吗？”我只能说，多的是，但也要看在哪个圈子里。而且，高薪虽好，但更重要的是找到一个能让自己不断进步，同时也能获得相应报酬的平台。

下面分享一道大厂的算法题

今日算法题，来自LeetCode的第25题：K 个一组翻转链表，很多大厂都考过，下面是我的算法思路及实现，让我们来看看吧。

K 个一组翻转链表

算法题目

给定一个链表，每K个节点一组进行翻转，请你返回翻转后的链表。K是一个正整数，它的值小于或等于链表的长度。如果节点总数不是K的整数倍，那么请将最后剩余节点保持原有顺序。

引言

翻转链表是一种常见的数据结构问题，它测试了程序员对链表操作的熟练度。将链表每K个一组进行翻转则更进一步，不仅需要熟悉链表的基本操作，还需要掌握分组、递归等技巧。

算法思路

  1. 遍历链表：首先遍历链表以确定其长度，以便我们知道是否有足够的节点可以翻转。

  2. 分组翻转：接着，我们将链表分为每组K个节点的小组，并翻转这些小组。如果链表的最后一组不足K个节点，则保持原样不翻转。

  3. 连接小组：翻转每个小组后，我们需要正确地连接它们，以确保链表的连续性。

  4. 递归或迭代：可以通过递归或迭代的方式实现上述步骤，递归方法的核心在于将问题分解成更小的子问题，而迭代方法则需要使用循环和一些临时变量来完成任务。

代码实现

JavaScript实现

function ListNode(val, next) {    this.val = (val===undefined ? 0 : val)    this.next = (next===undefined ? null : next)}
function reverseKGroup(head, k) {    if (!head || k === 1) return head;    let dummy = new ListNode(-1);    dummy.next = head;    let pre = dummy, curr = head;    let i = 0;    while (curr) {        i++;        if (i % k === 0) {            pre = reverse(pre, curr.next);            curr = pre.next;        } else {            curr = curr.next;        }    }    return dummy.next;}
function reverse(pre, next) {    let last = pre.next;    let curr = last.next;    while (curr !== next) {        last.next = curr.next;        curr.next = pre.next;        pre.next = curr;        curr = last.next;    }    return last;}
Java实现
class ListNode {    int val;    ListNode next;    ListNode(int x) { val = x; }}
public class Solution {    public ListNode reverseKGroup(ListNode head, int k) {        ListNode dummy = new ListNode(0);        dummy.next = head;        ListNode prev = dummy;        ListNode curr = head;        int length = 0;        while (curr != null) { // 计算链表长度            length++;            curr = curr.next;        }        while (length >= k) {            curr = prev.next;            ListNode next = curr;            for (int i = 0; i < k; ++i) {                next = next.next;            }            prev.next = reverse(curr, next);            prev = curr;            length -= k;        }        return dummy.next;    }    private ListNode reverse(ListNode first, ListNode last) {        ListNode prev = last;        while (first != last) {            ListNode temp = first.next;            first.next = prev;            prev = first;            first = temp;        }        return prev;    }}
Go实现
type ListNode struct {    Val int    Next *ListNode}
func reverseKGroup(head *ListNode, k int) *ListNode {    if head == nil || k == 1 {        return head    }    dummy := &ListNode{-1, head}    pre := dummy    curr := head    i := 0    for curr != nil {        i++        if i % k == 0 {            pre = reverse(pre, curr.Next)            curr = pre.Next        } else {            curr = curr.Next        }    }    return dummy.Next}
func reverse(pre, next *ListNode) *ListNode {    last := pre.Next    curr := last.Next    for curr != next {        last.Next = curr.Next        curr.Next = pre.Next        pre.Next = curr        curr = last.Next    }    return last}

算法解析

对于每个小组，我们首先检查是否有足够的节点可以翻转。如果有，我们就在当前小组内进行翻转，这通常涉及到改变节点间的链接方向。翻转完成后，我们需要确保这个小组的新尾节点能够连接到下一组的头节点。

示例和测试

以链表 1->2->3->4->5 为例，K=2 的情况下，翻转后的链表为 2->1->4->3->5。

总结

K个一组翻转链表是一个相对复杂的链表操作问题，它考察了对链表的深入理解和操作技巧。
Image
热门推荐
Image

KEEP THE THREAD GOING

更多来源文章