写一篇oj实验报告，要求：（1）包括五个题（2）内容包括题目来源、问题号、题目、算法思路和分析、代码、收获心得

以下是本人的一篇OJ实验报告，共涉及五个题目。

一、题目来源：LeetCode 1. Two Sum

问题号：1

题目描述：给定一个整数数组 nums 和一个目标值 target，请在数组中找出和为目标值的两个整数。假设每个输入只对应一种答案，且同样的元素不能被重复利用。

算法思路和分析：使用哈希表（Python中的字典）进行遍历，将数组中的元素作为键，元素下标作为值存入字典中，如果字典中已经存在目标值和当前遍历的元素的差值，则直接返回这两个元素在数组中的下标。

代码：

class Solution:
    def twoSum(self, nums: List[int], target: int) -> List[int]:
        d = {}
        for i, num in enumerate(nums):
            if target - num in d:
                return [d[target - num], i]
            d[num] = i
        return []

收获心得：通过这个题目，我更加熟悉了Python中的字典以及哈希表的运用，同时也加深了对于遍历的理解。

二、题目来源：LeetCode 15. 3Sum

问题号：15

题目描述：给定一个包含 n 个整数的数组 nums，判断 nums 中是否存在三个元素 a，b，c ，使得 a + b + c = 0 ？找出所有满足条件且不重复的三元组。

算法思路和分析：首先将原数组排序，然后使用双指针遍历数组，固定一个数，然后在其后面的数中使用双指针找到另外两个数，使得三数之和为0。为了避免出现重复的三元组，需要在遍历时跳过重复的数。

代码：

class Solution:
    def threeSum(self, nums: List[int]) -> List[List[int]]:
        nums.sort()
        res = []
        n = len(nums)
        for i in range(n):
            if nums[i] > 0:
                return res
            if i > 0 and nums[i] == nums[i - 1]:
                continue
            l, r = i + 1, n - 1
            while l < r:
                s = nums[i] + nums[l] + nums[r]
                if s == 0:
                    res.append([nums[i], nums[l], nums[r]])
                    while l < r and nums[l] == nums[l + 1]:
                        l += 1
                    while l < r and nums[r] == nums[r - 1]:
                        r -= 1
                    l += 1
                    r -= 1
                elif s < 0:
                    l += 1
                else:
                    r -= 1
        return res

收获心得：本题让我更加熟悉了双指针的运用，同时也加强了我对于数组排序和去重的理解。

三、题目来源：LeetCode 70. Climbing Stairs

问题号：70

题目描述：假设你正在爬楼梯。需要 n 阶你才能到达楼顶。每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

算法思路和分析：爬楼梯问题可以使用动态规划来解决，设f(n)为爬到第n阶的不同方法数，由于每次只能爬1或2个台阶，所以到达第n阶的方法数为到达第n-1阶和到达第n-2阶的方法数之和，即f(n) = f(n-1) + f(n-2)。

代码：

class Solution:
    def climbStairs(self, n: int) -> int:
        if n == 1:
            return 1
        if n == 2:
            return 2
        dp = [0] * (n + 1)
        dp[1] = 1
        dp[2] = 2
        for i in range(3, n + 1):
            dp[i] = dp[i - 1] + dp[i - 2]
        return dp[n]

收获心得：通过这个题目，我更加熟悉了动态规划的思想，同时也加强了我对于递推的理解。

四、题目来源：LeetCode 121. Best Time to Buy and Sell Stock

问题号：121

题目描述：给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。你只能选择某一天买入这只股票，并选择在未来的某一个不同的日子卖出该股票。设计一个算法来计算你所能获取的最大利润。注意：不能在买入股票前卖出股票。

算法思路和分析：使用双指针，一个指向最低价格，一个指向当前价格，遍历整个数组，更新最大利润。

代码：

class Solution:
    def maxProfit(self, prices: List[int]) -> int:
        if not prices:
            return 0
        min_price = prices[0]
        max_profit = 0
        for price in prices:
            if price < min_price:
                min_price = price
            else:
                max_profit = max(max_profit, price - min_price)
        return max_profit

收获心得：本题让我更加熟悉了双指针的运用，同时也加强了我对于数组遍历的理解。

五、题目来源：LeetCode 206. Reverse Linked List

问题号：206

题目描述：反转一个单链表。

算法思路和分析：使用三个指针，分别指向当前节点、前一个节点和后一个节点，遍历整个链表，将每个节点指向前一个节点即可。

代码：

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if not head or not head.next:
            return head
        pre = None
        cur = head
        while cur:
            tmp = cur.next
            cur.next = pre
            pre = cur
            cur = tmp
        return pre

收获心得：通过这个题目，我更加熟悉了链表的遍历，同时也加强了我对于指针的理解。

以上是我的OJ实验报告，通过这次实验，我学习到了许多算法和数据结构的知识，同时也加强了对于Python语言的熟悉程度，受益匪浅。