最新零基础的我刷力扣一周后，总结了点东西_力扣适合初学者吗，数据库开发工程师面试题

文末有福利领取哦~

👉一、Python所有方向的学习路线

Python所有方向的技术点做的整理，形成各个领域的知识点汇总，它的用处就在于，你可以按照上面的知识点去找对应的学习资源，保证自己学得较为全面。

👉二、Python必备开发工具

👉三、Python视频合集

观看零基础学习视频，看视频学习是最快捷也是最有效果的方式，跟着视频中老师的思路，从基础到深入，还是很容易入门的。

👉 四、实战案例

光学理论是没用的，要学会跟着一起敲，要动手实操，才能将自己的所学运用到实际当中去，这时候可以搞点实战案例来学习。（文末领读者福利）

👉五、Python练习题

检查学习结果。

👉六、面试资料

我们学习Python必然是为了找到高薪的工作，下面这些面试题是来自阿里、腾讯、字节等一线互联网大厂最新的面试资料，并且有阿里大佬给出了权威的解答，刷完这一套面试资料相信大家都能找到满意的工作。

👉因篇幅有限，仅展示部分资料，这份完整版的Python全套学习资料已经上传

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

正常的做法是进行嵌套循环，挨个查找，这样的时间复杂度为：O(n*2)

而如果使用双指针的方法，结合二分法就能使时间复杂度降低到：O(logn)

遍历的方法就相当于一个人在找东西，双指针的方法就好像是两个人在找东西

打个例子：

我有一块种着10棵树的地

有人告诉我，你有一棵树需要浇水了

如果只有我自己（正常遍历）

并且我不需要跑到树前面观察才能判断我的树是否需要浇水

我只能一棵一棵的找，然后判断

而如果我有一个助手（双指针）

我就可以缩短排查的时间

java：

public class Shuzu {
    public static void main(String[] args) {
        int target = 7;
        int[] arr = new int[]{1, 2, 3, 4, 5, 6, 7, 8, 9};
        System.out.println(ArrD(7,arr)+"\n"+ArrS(target,arr));
    }
    static int ArrD(int target, int[] arr) {
        // 单指针
        for (int i = 0; i < arr.length; i++) {
            if (arr[i] == target) return i;
        }
        return -1;
    }
    static int ArrS(int target, int[] arr){
        // 双指针
        int end = arr.length-1;
        int start = 0;
        while (start<end){
            if (arr[start]==target) return start;
            if (arr[end]==target) return end;
            start++;
            end--;
        }
        return -1;
    }
}

py：

def ArrD(target, arr):
    # 单指针
    for i in range(len(arr)):
        if arr[i]target: return i
    return -1;
def ArrS(target, arr):
    # 双指针
    start = 0
    end = len(arr)-1
    while start<end:
        if arr[start]==target: return start
        if arr[end]==target: return end
        start+=1
        end-=1
    return end

target = 7
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(ArrD(target, arr), "\n", ArrS(target, arr))

3. 递归

递归与其说是一种算法，不如说是一种思想。

它更类似于我们高中数学学过的数列的递推推导式：A(n) = A(n-1)+5 首项为1

让你通过这个式子计算第n项的值的话

你高中会使用它推导出一个通项公式，再将n代入求解

但是再计算机眼里就不用这么麻烦

你只需要每次调用这个公式，然后计算出值就好

在编程语言里就是 ：定义一个函数，调用自身，返回结果就是递归

就相当于计算机帮你从1开始执行了很多遍的A(n) = A(n-1)+5

无限套娃？不不不，他还是有个限度的，没法无限，哈哈哈

比如需要求A(5)，那么就是：

A(5) = A(4)+5

A(4) = A(3)+5

A(3) = A(2)+5

A(2) = A(1)+5

A(1) = 3

A(5) = 3+5+5+5+5=23

代码实现：

java代码：

public class Digui {
    public static void main(String[] args) {
        int sum = Shu(5);
        System.out.println(sum);
    }
    static int Shu(int n){
        if (n<=1) return 3;
        else return Shu(n-1)+5;
    }
}

py代码：

def Shu(n:int)->int:
    if n<=1: return 3
    else: return Shu(n-1)+5

print(Shu(5))

最后的计算结果是23

4. 数组

什么是数组？数组就是存储多个相同数据的集合，他们的内存地址是相邻的，所以可以通过数组取值。

这么说，是不是有点不好理解，那么这样呢？

我有一颗白菜，手拿着就能回家，那如果是十几颗呢？

我就可以用麻袋！麻袋！装进去，带回家！是的你要存的数据就是白菜，而这个数组就是你要用的麻袋~~~~~

麻袋中的白菜怎么拿出来我需要用的呢？

下标，数组中的下标是以0开始的，什么是下标，就是你从0开始查，查到某个你要的数据，查到几，下标就是几，就相当于，我在装白菜的时候，说“这是第0个白菜，这是第1个白菜…”，而他们也能听懂（别管他们能不能听懂，我说能就能，哈哈~~），等我需要哪一颗白菜的时候，喊一声，他就自己跳出来了

当然我们的数组一般存储的数据比较多，而计算机又不和人一样能够直接看到数组的全部元素，他只记得里面第一颗白菜的样子，所以我们在查找某个元素，但是又不知道他在哪里的时候，只能通过遍历的手段来获取了

遍历每一棵白菜，将他与我们需要找的白菜对比没如果是就不找了，如果不是就继续找。

具体的代码形式我就不多说了，这个都是知道的。

5. 字符串

字符串是我们在编程语言里面见到的第一个数据结构 hello world

当然，字符串不仅是我们滴各一人士的数据结构，也是我们在生活中用到最多的，比如我们网上聊天，就是字符串，看的小说，是字符串…

而有的字符擦混存储在文件中供计算机读取，然后输出到屏幕上给我们看。

字符串可以看成是一个字符型数组，但是又不尽相同

字符串可以遍历，查询，拼接，但是不能修改

有的时候拼接用得好也能很大程度上降低我们解决问题的难度

我们可以通过运算符号对字符串进行

运算符	作用	实例
+	拼接字符串	“a”+“a”=>“aa”
=	赋值字符串	“a”=“b”=>“b”
==	判断字符串是否相等	“a”==“b”=>false
[]	通过下标获取字符串中的字符	“asd”[0]=>“a”

说起字符串，能说的也可以很多，也可以很少

说多了有AI的NLP自然语言处理，K近邻算法，正则表达式…

这里就不多说了，先学会基本操作

6. 链表

链表是一种抽象的数据结构，他实际上是一个链表对象，头结点就是这个链表对象，而链表的没一个节点都是一个对象。

链表是一个不定长的线性表数据结构，链表没有内置方法来获取其长度，只能通过遍历来获得里面的内容。

链表实现：

java：

class ListNode{
    public int val;     // 存储的值
    public ListNode next;    // 指向下一节点
    public ListNode(int val){   // 构造函数/方法
        this.val = val;
        next = null;
    }
}

py：

class ListNode:
    def \_\_init\_\_(self,val):  # 构造函数
        self.val = val   # 存储的值
        next = None      # 指向下一节点

是的，链表就是这样实现的。我们一般只能拿到头结点，然后通过判断下一节点是否为空位约束条件来终止循环。

实例：

给你个链表[1, 2, 3, 4, 5]

求链表的长度

java代码：

package com.example.demo;

public class ListNodeStudy {
    public static void main(String[] args) {
        ListNode h1 = new ListNode(1);    // 1
        ListNode h2 = new ListNode(2);    // 2
        ListNode h3 = new ListNode(3);    // 3
        ListNode h4 = new ListNode(4);    // 4
        ListNode h5 = new ListNode(5);    // 5
        h1.next = h2;    // 下一节点
        h2.next = h3;    // 下一节点
        h3.next = h4;    // 下一节点
        h4.next = h5;    // 下一节点
        // 题目的链表是这样是实现的，不过不会让你去实现，而是给你h1让你来找长度
        System.out.println(len(h1));
    }
    static int len(ListNode head){
        int len = 0;   // 为链表长度定义变量
        while (head!=null){   // 遍历链表获取长度
            len++;
            head = head.next;
        }
        return len;
    }
}
class ListNode{
    public int val;     // 存储的值
    public ListNode next;    // 指向下一节点
    public ListNode(int val){   // 构造函数/方法
        this.val = val;
        next = null;
    }
}

py：

class ListNode:
    def \_\_init\_\_(self, val):  # 构造函数
        self.val = val  # 存储的值
        self.next = None  # 指向下一节点


h1 = ListNode(1)
h2 = ListNode(2)
h3 = ListNode(3)
h4 = ListNode(4)
h5 = ListNode(5)
h1.next = h2
h2.next = h3
h3.next = h4
h4.next = h5


def ListNodeLen(head: ListNode) -> int:
    len = 0
    while head != None:
        len += 1
        head = head.next
    return len


print(ListNodeLen(h1))

三、结语

也许我学的慢，但是我始终都在进步！那我总有一天会成功。

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！