跳至主要內容
开始

欢迎来到我的博客！这里是我记录编程世界旅程的开始 🎉

本博客的目的

在这个博客中，我将记录我的课程学习记录，展示我的项目，并分享我在编程过程中个人的反思。我的目标是创造一个供学习和分享知识的空间，与同样热爱编程的朋友们交流。

期待的内容

  • 学习记录 🗒️: 来自我课程的笔记和见解。
  • 项目展示 💻: 对我个人项目及其开发过程的详细介绍。
  • 个人反思 📓: 在我编程旅程中所学到的思想和经验。
Ruochen Chen2024年11月2日小于 1 分钟开始旅程
关于我

陈若尘

教育背景

信息技术硕士，计算机方向
墨尔本大学
2024年2月 - 2025年12月
相关课程: 编程与软件开发，计算机网络，数据结构与算法，数据库系统，分布式系统，集群与云计算，声明式编程，机器学习，软件过程与管理，信息可视化

Ruochen Chen2024年11月1日大约 7 分钟开始简历
贪心

跳跃游戏

public boolean canJump(int[] nums) {
    if(nums.length ==1) return true;
    int coverRange = 0;
    for(int i=0; i<=coverRange; i++){ // 遍历coverRange，因为coverRange是当前可以跳跃的最大距离，所以遍历coverRange即可
        coverRange = Math.max(coverRange, i+nums[i]); // 站在第i个位置，最多可以跳nums[i]步
        if(coverRange >= nums.length-1) return true; // 如果coverRange >= nums.length-1（最后一个索引位置），则可以到达最后一个位置 
    }
    return false;
}
Ruochen Chen2025年6月25日大约 5 分钟Learning RecordsAlgorithm
链表

两个链表的交点

  • 两个链表相交，则相交点之后的节点都是相同的
  • A 走完走 B，B 走完走 A，步数一样就会相遇。
  • 举例：
A 长度 = 3 (a1 → a2 → c1 → c2 → c3)
B 长度 = 4 (b1 → b2 → b3 → c1 → c2 → c3)
pA: a1 → a2 → c1 → c2 → c3 → null → b1 → b2 → b3 → c1 ←★
pB: b1 → b2 → b3 → c1 → c2 → c3 → null → a1 → a2 → c1 ←★
最后pA和pB都走了9步，在c1相遇, 因为c1是相交点
Ruochen Chen2025年6月14日小于 1 分钟Learning RecordsAlgorithm
Haskell 常见内置函数速查

列表操作

函数 类型签名 说明 例子
head [a] -> a 取列表第一个元素 head [1,2,3] = 1
tail [a] -> [a] 去掉列表第一个元素 tail [1,2,3] = [2,3]
init [a] -> [a] 去掉列表最后一个元素 init [1,2,3] = [1,2]
last [a] -> a 取列表最后一个元素 last [1,2,3] = 3
length [a] -> Int 计算列表长度 length [1,2,3] = 3
null [a] -> Bool 判断列表是否为空 null [] = True
reverse [a] -> [a] 翻转列表 reverse [1,2,3] = [3,2,1]
take Int -> [a] -> [a] 取前 n 个元素 take 2 [1,2,3] = [1,2]
drop Int -> [a] -> [a] 丢弃前 n 个元素 drop 2 [1,2,3] = [3]
splitAt Int -> [a] -> ([a],[a]) 分割列表为两部分 splitAt 2 [1,2,3] = ([1,2],[3])
filter (a -> Bool) -> [a] -> [a] 过滤满足条件的元素 filter even [1..5] = [2,4]
map (a -> b) -> [a] -> [b] 对列表每个元素应用函数 map (+1) [1,2,3] = [2,3,4]
foldl (b -> a -> b) -> b -> [a] -> b 从左到右折叠 foldl (+) 0 [1,2,3] = 6
foldr (a -> b -> b) -> b -> [a] -> b 从右到左折叠 foldr (:) [] [1,2,3] = [1,2,3]
zip [a] -> [b] -> [(a,b)] 两个列表配对成元组列表 zip [1,2] ['a','b'] = [(1,'a'),(2,'b')]
zipWith (a -> b -> c) -> [a] -> [b] -> [c] 两个列表的对应元素分别应用一个函数，返回一个新列表 zipWith (+) [1,2] [3,4] = [4,6]
concat [[a]] -> [a] 合并列表的列表 concat [[1,2],[3]] = [1,2,3]
concatMap (a -> [b]) -> [a] -> [b] 对列表每个元素应用函数，返回一个新列表 concatMap (\x -> [x,x]) [1,2,3] = [1,1,2,2,3,3]
elem Eq a => a -> [a] -> Bool 判断元素是否在列表中 elem 3 [1,2,3] = True
notElem Eq a => a -> [a] -> Bool 判断元素不在列表中 notElem 4 [1,2,3] = True
takeWhile (a -> Bool) -> [a] -> [a] 从头取满足条件的元素 takeWhile (<3) [1,2,3] = [1,2]
dropWhile (a -> Bool) -> [a] -> [a] 从头丢弃满足条件的元素 dropWhile (<3) [1,2,3] = [3]
span (a -> Bool) -> [a] -> ([a], [a]) 从头分割列表，前部分满足条件，后部分不满足，在第一次不满足条件时停止 span (<3) [1,2,3] = ([1,2],[3])
all (a -> Bool) -> [a] -> Bool 判断列表所有元素是否满足条件 all (<3) [1,2,3] = True
\\ (a -> Bool) -> [a] -> [a] 列表差集操作符 [1,2,3] \\ [1,2] = [3]
flip (a -> b -> c) -> b -> a -> c 翻转函数参数顺序 flip (++) "word" " hello" = "hello word"
Ruochen Chen2025年6月14日大约 14 分钟Learning RecordsDeclarative Programming
Prolog 内置谓词速查表
命令 作用
help(Name) 查看某个谓词的用法简要说明
apropos(Keyword) 搜索包含某关键词的所有文档条目
listing(Name/Arity) 查看用户自定义谓词定义
predicate_property(P,Prop) 查询谓词的属性
current_predicate(Name/Arity) 查看所有当前存在的谓词
trace. / notrace. 启用/禁用调试
Ruochen Chen2025年6月14日大约 6 分钟Learning RecordsDeclarative Programming
双指针

验证回文串

  • 双指针
public boolean isPalindrome(String s) {
    if (" ".equals(s)) return true; // 如果字符串为空，则返回true 
    int left = 0, right = s.length()-1;
    while(left <= right){
        while (left < right && !Character.isLetterOrDigit(s.charAt(left))) { // 如果左指针指向的字符不是字母或数字，则移动左指针
            left++;
        }
        while (left < right && !Character.isLetterOrDigit(s.charAt(right))) { // 如果右指针指向的字符不是字母或数字，则移动右指针
            right--;
        }
        if (Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))) { // 如果左右指针指向的字符不相同，则返回false
            return false;
        }
        left++; // 移动左指针
        right--; // 移动右指针
    }
    return true;
}
Ruochen Chen2025年6月8日大约 2 分钟Learning RecordsAlgorithm
哈希

两数之和

  • 使用哈希表来存储已经遍历过的元素及其索引
  • 在遍历数组时，检查哈希表中是否存在目标值与当前元素的差值
  • 如果存在，则返回这两个数的索引
  • 如果不存在，则将当前元素及其索引添加到哈希表中
public int[] twoSum(int[] nums, int target) {
    Map<Integer, Integer> map = new HashMap<>();
    for (int i = 0; i < nums.length; i++) {
        int complement = target - nums[i]; // 计算目标值与当前元素的差值
        if (map.containsKey(complement)) { // 如果哈希表中存在目标值与当前元素的差值
            return new int[] { map.get(complement), i }; // 返回这两个数的索引
        }
        map.put(nums[i], i); // 将当前元素及其索引添加到哈希表中
    }
    return new int[] { -1, -1 };
}
Ruochen Chen2025年6月8日大约 3 分钟Learning RecordsAlgorithm
数组

二分查找

  • 明确区间，左闭右闭（包含left和right）还是左闭右开（不包含right）
  • 左闭右闭：
    • 循环条件：left <= right
    • 更新条件：left = mid + 1, right = mid - 1
  • 左闭右开：
    • 循环条件：left < right
    • 更新条件：left = mid + 1, right = mid

移除元素

  • 快慢指针
  • 快指针遍历数组，慢指针记录不重复的元素
  • 快指针遍历完，慢指针就是不重复元素的个数
  • 快指针：寻找新数组的元素 ，新数组就是不含有目标元素的数组
  • 慢指针：指向更新 新数组下标的位置
  • 返回慢指针
Ruochen Chen2025年6月3日大约 25 分钟Learning RecordsAlgorithm
二叉树

二叉树的中序遍历

  • 左中右
class Solution {
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> result = new ArrayList<>();
        inorder(root, result);
        return result;
    }

    private void inorder(TreeNode root, List<Integer> result) {
        if (root == null) {
            return;
        }
        inorder(root.left, result);
        result.add(root.val);
        inorder(root.right, result);
    }
}
Ruochen Chen2025年5月27日大约 4 分钟Learning RecordsAlgorithm
学海无涯
Copyright © 2025 Ruochen Chen