From 8f8f6319af4f5e64e1aa4ff37506b69494ce2fcd Mon Sep 17 00:00:00 2001 From: krahets Date: Tue, 8 Nov 2022 02:58:42 +0800 Subject: [PATCH] Add Java codes, and license. --- .gitignore | 3 +- .../chapter_array_and_linkedlist/array.java | 100 ++++++++++++ .../linked_list.java | 80 ++++++++++ .../chapter_array_and_linkedlist/list.java | 62 ++++++++ .../chapter_array_and_linkedlist/my_list.java | 136 ++++++++++++++++ .../space_complexity_types.java | 100 ++++++++++++ .../space_time_tradeoff/leetcode_two_sum.java | 47 ++++++ .../time_complexity_types.java | 149 ++++++++++++++++++ .../worst_best_time_complexity.java | 42 +++++ codes/java/include/ListNode.java | 41 +++++ codes/java/include/PrintUtil.java | 88 +++++++++++ codes/java/include/TreeNode.java | 80 ++++++++++ deploy.sh | 2 +- docs/index.md | 22 ++- mkdocs.yml | 17 +- 15 files changed, 952 insertions(+), 17 deletions(-) create mode 100644 codes/java/chapter_array_and_linkedlist/array.java create mode 100644 codes/java/chapter_array_and_linkedlist/linked_list.java create mode 100644 codes/java/chapter_array_and_linkedlist/list.java create mode 100644 codes/java/chapter_array_and_linkedlist/my_list.java create mode 100644 codes/java/chapter_computational_complexity/space_complexity/space_complexity_types.java create mode 100644 codes/java/chapter_computational_complexity/space_time_tradeoff/leetcode_two_sum.java create mode 100644 codes/java/chapter_computational_complexity/time_complexity/time_complexity_types.java create mode 100644 codes/java/chapter_computational_complexity/time_complexity/worst_best_time_complexity.java create mode 100755 codes/java/include/ListNode.java create mode 100755 codes/java/include/PrintUtil.java create mode 100755 codes/java/include/TreeNode.java diff --git a/.gitignore b/.gitignore index 54c0e4a14..fbf1224ca 100644 --- a/.gitignore +++ b/.gitignore @@ -7,5 +7,6 @@ # mkdocs files overrides/ site/ -codes/ +codes/python +codes/cpp docs/chapter_* \ No newline at end of file diff --git a/codes/java/chapter_array_and_linkedlist/array.java b/codes/java/chapter_array_and_linkedlist/array.java new file mode 100644 index 000000000..1a1c673ba --- /dev/null +++ b/codes/java/chapter_array_and_linkedlist/array.java @@ -0,0 +1,100 @@ +package chapter_array_and_linkedlist; + +import java.util.*; +import java.util.concurrent.ThreadLocalRandom; + +public class array { + /* 随机返回一个数组元素 */ + static int randomAccess(int[] nums) { + // 在区间 [0, nums.length) 中随机抽取一个数字 + int randomIndex = ThreadLocalRandom.current(). + nextInt(0, nums.length); + // 获取并返回随机元素 + int randomNum = nums[randomIndex]; + return randomNum; + } + + /* 扩展数组长度 */ + static int[] extend(int[] nums, int enlarge) { + // 初始化一个扩展长度后的数组 + int[] res = new int[nums.length + enlarge]; + // 将原数组中的所有元素复制到新数组 + for (int i = 0; i < nums.length; i++) { + res[i] = nums[i]; + } + // 返回扩展后的新数组 + return res; + } + + /* 在数组的索引 index 处插入元素 num */ + static void insert(int[] nums, int num, int index) { + // 把索引 index 以及之后的所有元素向后移动一位 + for (int i = nums.length - 1; i >= index; i--) { + nums[i] = nums[i - 1]; + } + // 将 num 赋给 index 处元素 + nums[index] = num; + } + + /* 删除索引 index 处元素 */ + static void remove(int[] nums, int index) { + // 把索引 index 之后的所有元素向前移动一位 + for (int i = index; i < nums.length - 1; i++) { + nums[i] = nums[i + 1]; + } + } + + /* 遍历数组 */ + static void traverse(int[] nums) { + int count = 0; + // 通过索引遍历数组 + for (int i = 0; i < nums.length; i++) { + count++; + } + // 直接遍历数组 + for (int num : nums) { + count++; + } + } + + /* 在数组中查找指定元素 */ + static int find(int[] nums, int target) { + for (int i = 0; i < nums.length; i++) { + if (nums[i] == target) + return i; + } + return -1; + } + + /* Driver Code */ + public static void main(String[] args) { + /* 初始化数组 */ + int[] arr = new int[5]; + System.out.println("数组 arr = " + Arrays.toString(arr)); + int[] nums = { 1, 3, 2, 5, 4 }; + System.out.println("数组 nums = " + Arrays.toString(nums)); + + /* 随机访问 */ + int randomNum = randomAccess(nums); + System.out.println("在 nums 中获取随机元素 " + randomNum); + + /* 长度扩展 */ + nums = extend(nums, 3); + System.out.println("将数组长度扩展至 8 ，得到 nums = " + Arrays.toString(nums)); + + /* 插入元素 */ + insert(nums, 6, 3); + System.out.println("在索引 3 处插入数字 6 ，得到 nums = " + Arrays.toString(nums)); + + /* 删除元素 */ + remove(nums, 2); + System.out.println("删除索引 2 处的元素，得到 nums = " + Arrays.toString(nums)); + + /* 遍历数组 */ + traverse(nums); + + /* 查找元素 */ + int index = find(nums, 3); + System.out.println("在 nums 中查找元素 3 ，得到索引 = " + index); + } +} diff --git a/codes/java/chapter_array_and_linkedlist/linked_list.java b/codes/java/chapter_array_and_linkedlist/linked_list.java new file mode 100644 index 000000000..9a1dedbc5 --- /dev/null +++ b/codes/java/chapter_array_and_linkedlist/linked_list.java @@ -0,0 +1,80 @@ +package chapter_array_and_linkedlist; + +import include.*; + +public class linked_list { + /* 在链表的结点 n0 之后插入结点 P */ + static void insert(ListNode n0, ListNode P) { + ListNode n1 = n0.next; + n0.next = P; + P.next = n1; + } + + /* 删除链表的结点 n0 之后的首个结点 */ + static void remove(ListNode n0) { + if (n0.next == null) + return; + // n0 -> P -> n1 + ListNode P = n0.next; + ListNode n1 = P.next; + n0.next = n1; + } + + /* 访问链表中索引为 index 的结点 */ + static ListNode access(ListNode head, int index) { + for (int i = 0; i < index; i++) { + head = head.next; + if (head == null) + return null; + } + return head; + } + + /* 在链表中查找值为 target 的首个结点 */ + static int find(ListNode head, int target) { + int index = 0; + while (head != null) { + if (head.val == target) + return index; + head = head.next; + index++; + } + return -1; + } + + /* Driver Code */ + public static void main(String[] args) { + /* 初始化链表 */ + // 初始化各个结点 + ListNode n0 = new ListNode(1); + ListNode n1 = new ListNode(3); + ListNode n2 = new ListNode(2); + ListNode n3 = new ListNode(5); + ListNode n4 = new ListNode(4); + // 构建引用指向 + n0.next = n1; + n1.next = n2; + n2.next = n3; + n3.next = n4; + System.out.println("初始化的链表为"); + PrintUtil.printLinkedList(n0); + + /* 插入结点 */ + insert(n0, new ListNode(0)); + System.out.println("插入结点后的链表为"); + PrintUtil.printLinkedList(n0); + + /* 删除结点 */ + remove(n0); + System.out.println("删除结点后的链表为"); + PrintUtil.printLinkedList(n0); + + /* 访问结点 */ + ListNode node = access(n0, 3); + System.out.println("链表中索引 3 处的结点的值 = " + node.val); + + /* 查找结点 */ + int index = find(n0, 2); + System.out.println("链表中值为 2 的结点的索引 = " + index); + } +} diff --git a/codes/java/chapter_array_and_linkedlist/list.java b/codes/java/chapter_array_and_linkedlist/list.java new file mode 100644 index 000000000..1a478ea07 --- /dev/null +++ b/codes/java/chapter_array_and_linkedlist/list.java @@ -0,0 +1,62 @@ +package chapter_array_and_linkedlist; + +import java.util.*; + +public class list { + public static void main(String[] args) { + /* 初始化列表 */ + // 注意数组的元素类型是 int[] 的包装类 Integer[] + Integer[] numbers = new Integer[] { 1, 3, 2, 5, 4 }; + List list = new ArrayList<>(Arrays.asList(numbers)); + System.out.println("列表 list = " + Arrays.toString(list.toArray())); + + /* 访问元素 */ + int num = list.get(1); + System.out.println("访问索引 1 处的元素，得到 num = " + num); + + /* 更新元素 */ + list.set(1, 0); + System.out.println("将索引 1 处的元素更新为 0 ，得到 list = " + Arrays.toString(list.toArray())); + + /* 清空列表 */ + list.clear(); + System.out.println("清空列表后 list = " + Arrays.toString(list.toArray())); + + /* 尾部添加元素 */ + list.add(1); + list.add(3); + list.add(2); + list.add(5); + list.add(4); + System.out.println("添加元素后 list = " + Arrays.toString(list.toArray())); + + /* 中间插入元素 */ + list.add(3, 6); + System.out.println("在索引 3 处插入数字 6 ，得到 list = " + Arrays.toString(list.toArray())); + + /* 删除元素 */ + list.remove(3); + System.out.println("删除索引 3 处的元素，得到 list = " + Arrays.toString(list.toArray())); + + /* 通过索引遍历列表 */ + int count = 0; + for (int i = 0; i < list.size(); i++) { + count++; + } + + /* 直接遍历列表元素 */ + count = 0; + for (int n : list) { + count++; + } + + /* 拼接两个列表 */ + List list1 = new ArrayList<>(Arrays.asList(new Integer[] { 6, 8, 7, 10, 9 })); + list.addAll(list1); + System.out.println("将列表 list1 拼接到 list 之后，得到 list = " + Arrays.toString(list.toArray())); + + /* 排序列表 */ + Collections.sort(list); + System.out.println("排序列表后 list = " + Arrays.toString(list.toArray())); + } +} diff --git a/codes/java/chapter_array_and_linkedlist/my_list.java b/codes/java/chapter_array_and_linkedlist/my_list.java new file mode 100644 index 000000000..67b255410 --- /dev/null +++ b/codes/java/chapter_array_and_linkedlist/my_list.java @@ -0,0 +1,136 @@ +package chapter_array_and_linkedlist; + +import java.util.*; + +/* 列表类简易实现 */ +class MyList { + int[] nums; // 数组（存储列表元素） + int initialCapacity = 10; // 列表初始容量 + int size = 0; // 列表长度（即当前元素数量） + int extendRatio = 2; // 每次列表扩容的倍数 + + /* 构造函数 */ + public MyList() { + nums = new int[initialCapacity]; + } + + /* 获取列表容量 */ + public int size() { + return size; + } + + /* 获取列表长度（即当前元素数量） */ + public int capacity() { + return nums.length; + } + + /* 访问元素 */ + public int get(int index) { + // 索引如果越界则抛出异常，下同 + if (index >= size) + throw new IndexOutOfBoundsException("索引越界"); + return nums[index]; + } + + /* 更新元素 */ + public void set(int index, int num) { + if (index >= size) + throw new IndexOutOfBoundsException("索引越界"); + nums[index] = num; + } + + /* 尾部添加元素 */ + public void add(int num) { + // 元素数量超出容量时，触发扩容机制 + if (size == nums.length) + extendCapacity(); + nums[size] = num; + // 更新元素数量 + size++; + } + + /* 中间插入元素 */ + public void add(int index, int num) { + if (index >= size) + throw new IndexOutOfBoundsException("索引越界"); + // 元素数量超出容量时，触发扩容机制 + if (size == nums.length) + extendCapacity(); + // 索引 i 以及之后的元素都向后移动一位 + for (int j = size - 1; j >= index; j--) { + nums[j + 1] = nums[j]; + } + nums[index] = num; + // 更新元素数量 + size++; + } + + /* 删除元素 */ + public void remove(int index) { + if (index >= size) + throw new IndexOutOfBoundsException("索引越界"); + // 索引 i 之后的元素都向前移动一位 + for (int j = index; j < size - 1; j++) { + nums[j] = nums[j + 1]; + } + // 更新元素数量 + size--; + } + + /* 列表扩容 */ + public void extendCapacity() { + // 新建一个长度为 size 的数组，并将原数组拷贝到新数组 + nums = Arrays.copyOf(nums, nums.length * extendRatio); + } + + /* 将列表转换为数组 */ + public int[] toArray() { + int size = size(); + // 仅转换有效长度范围内的列表元素 + int[] nums = new int[size]; + for (int i = 0; i < size; i++) { + nums[i] = get(i); + } + return nums; + } +} + +public class my_list { + /* Driver Code */ + public static void main(String[] args) { + /* 初始化列表 */ + MyList list = new MyList(); + /* 尾部添加元素 */ + list.add(1); + list.add(3); + list.add(2); + list.add(5); + list.add(4); + System.out.println("列表 list = " + Arrays.toString(list.toArray()) + + " ，容量 = " + list.capacity() + " ，长度 = " + list.size()); + + /* 中间插入元素 */ + list.add(3, 6); + System.out.println("在索引 3 处插入数字 6 ，得到 list = " + Arrays.toString(list.toArray())); + + /* 删除元素 */ + list.remove(3); + System.out.println("删除索引 3 处的元素，得到 list = " + Arrays.toString(list.toArray())); + + /* 访问元素 */ + int num = list.get(1); + System.out.println("访问索引 1 处的元素，得到 num = " + num); + + /* 更新元素 */ + list.set(1, 0); + System.out.println("将索引 1 处的元素更新为 0 ，得到 list = " + Arrays.toString(list.toArray())); + + /* 测试扩容机制 */ + for (int i = 0; i < 10; i++) { + // 在 i = 5 时，列表长度将超出列表容量，此时触发扩容机制 + list.add(i); + } + System.out.println("扩容后的列表 list = " + Arrays.toString(list.toArray()) + + " ，容量 = " + list.capacity() + " ，长度 = " + list.size()); + } +} diff --git a/codes/java/chapter_computational_complexity/space_complexity/space_complexity_types.java b/codes/java/chapter_computational_complexity/space_complexity/space_complexity_types.java new file mode 100644 index 000000000..fdbf3b74a --- /dev/null +++ b/codes/java/chapter_computational_complexity/space_complexity/space_complexity_types.java @@ -0,0 +1,100 @@ +package chapter_computational_complexity.space_complexity; + +import include.*; +import java.util.*; + +public class space_complexity_types { + /* 函数 */ + static int function() { + // do something + return 0; + } + + /* 常数阶 */ + static void constant(int n) { + // 常量、变量、对象占用 O(1) 空间 + final int a = 0; + int b = 0; + int[] nums = new int[10000]; + ListNode node = new ListNode(0); + // 循环中的变量占用 O(1) 空间 + for (int i = 0; i < n; i++) { + int c = 0; + } + // 循环中的函数占用 O(1) 空间 + for (int i = 0; i < n; i++) { + function(); + } + } + + /* 线性阶 */ + static void linear(int n) { + // 长度为 n 的数组占用 O(n) 空间 + int[] nums = new int[n]; + // 长度为 n 的列表占用 O(n) 空间 + List nodes = new ArrayList<>(); + for (int i = 0; i < n; i++) { + nodes.add(new ListNode(i)); + } + // 长度为 n 的哈希表占用 O(n) 空间 + Map map = new HashMap<>(); + for (int i = 0; i < n; i++) { + map.put(i, String.valueOf(i)); + } + } + + /* 线性阶（递归实现） */ + static void linearRecur(int n) { + System.out.println("递归 n = " + n); + if (n == 1) return; + linearRecur(n - 1); + } + + /* 平方阶 */ + static void quadratic(int n) { + // 矩阵占用 O(n^2) 空间 + int numMatrix[][] = new int[n][n]; + // 二维列表占用 O(n^2) 空间 + List> numList = new ArrayList<>(); + for (int i = 0; i < n; i++) { + List tmp = new ArrayList<>(); + for (int j = 0; j < n; j++) { + tmp.add(0); + } + numList.add(tmp); + } + } + + /* 平方阶（递归实现） */ + static int quadraticRecur(int n) { + if (n <= 0) return 0; + int[] nums = new int[n]; + System.out.println("递归 n = " + n + " 中的 nums 长度 = " + nums.length); + return quadraticRecur(n - 1); + } + + /* 指数阶（建立满二叉树） */ + static TreeNode buildTree(int n) { + if (n == 0) return null; + TreeNode root = new TreeNode(0); + root.left = buildTree(n - 1); + root.right = buildTree(n - 1); + return root; + } + + /* Driver Code */ + public static void main(String[] args) { + int n = 5; + // 常数阶 + constant(n); + // 线性阶 + linear(n); + linearRecur(n); + // 平方阶 + quadratic(n); + quadraticRecur(n); + // 指数阶 + TreeNode tree = buildTree(n); + PrintUtil.printTree(tree); + } +} diff --git a/codes/java/chapter_computational_complexity/space_time_tradeoff/leetcode_two_sum.java b/codes/java/chapter_computational_complexity/space_time_tradeoff/leetcode_two_sum.java new file mode 100644 index 000000000..786574d69 --- /dev/null +++ b/codes/java/chapter_computational_complexity/space_time_tradeoff/leetcode_two_sum.java @@ -0,0 +1,47 @@ +package chapter_computational_complexity.space_time_tradeoff; + +import java.util.*; + +class solution_brute_force { + public int[] twoSum(int[] nums, int target) { + int size = nums.length; + for (int i = 0; i < size - 1; i++) { + for (int j = i + 1; j < size; j++) { + if (nums[i] + nums[j] == target) + return new int[] { i, j }; + } + } + return new int[0]; + } +} + +class solution_hash_map { + public int[] twoSum(int[] nums, int target) { + int size = nums.length; + Map dic = new HashMap<>(); + for (int i = 0; i < size; i++) { + if (dic.containsKey(target - nums[i])) { + return new int[] { dic.get(target - nums[i]), i }; + } + dic.put(nums[i], i); + } + return new int[0]; + } +} + +public class leetcode_two_sum { + public static void main(String[] args) { + // ======= Test Case ======= + int[] nums = { 2,7,11,15 }; + int target = 9; + + // ====== Driver Code ====== + solution_brute_force slt1 = new solution_brute_force(); + int[] res = slt1.twoSum(nums, target); + System.out.println(Arrays.toString(res)); + + solution_hash_map slt2 = new solution_hash_map(); + res = slt2.twoSum(nums, target); + System.out.println(Arrays.toString(res)); + } +} diff --git a/codes/java/chapter_computational_complexity/time_complexity/time_complexity_types.java b/codes/java/chapter_computational_complexity/time_complexity/time_complexity_types.java new file mode 100644 index 000000000..f3956947f --- /dev/null +++ b/codes/java/chapter_computational_complexity/time_complexity/time_complexity_types.java @@ -0,0 +1,149 @@ +package chapter_computational_complexity.time_complexity; + +public class time_complexity_types { + /* 常数阶 */ + static int constant(int n) { + int count = 0; + int size = 100000; + for (int i = 0; i < size; i++) + count++; + return count; + } + + /* 线性阶 */ + static int linear(int n) { + int count = 0; + for (int i = 0; i < n; i++) + count++; + return count; + } + + /* 线性阶（遍历数组） */ + static int arrayTraversal(int[] nums) { + int count = 0; + // 循环次数与数组长度成正比 + for (int num : nums) { + // System.out.println(num); + count++; + } + return count; + } + + /* 平方阶 */ + static int quadratic(int n) { + int count = 0; + for (int i = 0; i < n; i++) { + for (int j = 0; j < n; j++) { + count++; + } + } + return count; + } + + /* 平方阶（冒泡排序） */ + static void bubbleSort(int[] nums) { + int n = nums.length; + for (int i = 0; i < n - 1; i++) { + for (int j = 0; j < n - 1 - i; j++) { + if (nums[j] > nums[j + 1]) { + // 交换 nums[j] 和 nums[j + 1] + int tmp = nums[j]; + nums[j] = nums[j + 1]; + nums[j + 1] = tmp; + } + } + } + } + + /* 指数阶（循环实现） */ + static int exponential(int n) { + int count = 0, base = 1; + // cell 每轮一分为二，形成数列 1, 2, 4, 8, ..., 2^(n-1) + for (int i = 0; i < n; i++) { + for (int j = 0; j < base; j++) { + count++; + } + base *= 2; + } + // count = 1 + 2 + 4 + 8 + .. + 2^(n-1) = 2^n - 1 + return count; + } + + /* 指数阶（递归实现） */ + static int expRecur(int n) { + if (n == 1) return 1; + return expRecur(n - 1) + expRecur(n - 1) + 1; + } + + /* 对数阶（循环实现） */ + static int logarithmic(float n) { + int count = 0; + while (n > 1) { + n = n / 2; + count++; + } + return count; + } + + /* 对数阶（递归实现） */ + static int logRecur(float n) { + if (n <= 1) return 0; + return logRecur(n / 2) + 1; + } + + /* 线性对数阶 */ + static int linearLogRecur(float n) { + if (n <= 1) return 1; + int count = linearLogRecur(n / 2) + + linearLogRecur(n / 2); + for (int i = 0; i < n; i++) { + count++; + } + return count; + } + + /* 阶乘阶（递归实现） */ + static int factorialRecur(int n) { + if (n == 0) return 1; + int count = 0; + // 从 1 个分裂出 n 个 + for (int i = 0; i < n; i++) { + count += factorialRecur(n - 1); + } + return count; + } + + /* Driver Code */ + public static void main(String[] args) { + // 可以修改 n 运行，体会一下各种复杂度的操作数量变化趋势 + int n = 8; + System.out.println("输入数据大小 n = " + n); + + int count = constant(n); + System.out.println("常数阶的计算操作数量 = " + count); + + count = linear(n); + System.out.println("线性阶的计算操作数量 = " + count); + count = arrayTraversal(new int[n]); + System.out.println("线性阶（遍历数组）的计算操作数量 = " + count); + + count = quadratic(n); + System.out.println("平方阶的计算操作数量 = " + count); + + count = exponential(n); + System.out.println("指数阶（循环实现）的计算操作数量 = " + count); + count = expRecur(n); + System.out.println("指数阶（递归实现）的计算操作数量 = " + count); + + count = logarithmic((float) n); + System.out.println("对数阶（循环实现）的计算操作数量 = " + count); + count = logRecur((float) n); + System.out.println("对数阶（递归实现）的计算操作数量 = " + count); + + count = linearLogRecur((float) n); + System.out.println("线性对数阶（递归实现）的计算操作数量 = " + count); + + count = factorialRecur(n); + System.out.println("阶乘阶（递归实现）的计算操作数量 = " + count); + } +} diff --git a/codes/java/chapter_computational_complexity/time_complexity/worst_best_time_complexity.java b/codes/java/chapter_computational_complexity/time_complexity/worst_best_time_complexity.java new file mode 100644 index 000000000..d9def6d87 --- /dev/null +++ b/codes/java/chapter_computational_complexity/time_complexity/worst_best_time_complexity.java @@ -0,0 +1,42 @@ +package chapter_computational_complexity.time_complexity; + +import java.util.*; + +public class worst_best_time_complexity { + /* 生成一个数组，元素为 { 1, 2, ..., n }，顺序被打乱 */ + static int[] randomNumbers(int n) { + Integer[] nums = new Integer[n]; + // 生成数组 nums = { 1, 2, 3, ..., n } + for (int i = 0; i < n; i++) { + nums[i] = i + 1; + } + // 随机打乱数组元素 + Collections.shuffle(Arrays.asList(nums)); + // Integer[] -> int[] + int[] res = new int[n]; + for (int i = 0; i < n; i++) { + res[i] = nums[i]; + } + return res; + } + + /* 查找数组 nums 中数字 1 所在索引 */ + static int findOne(int[] nums) { + for (int i = 0; i < nums.length; i++) { + if (nums[i] == 1) + return i; + } + return -1; + } + + /* Driver Code */ + public static void main(String[] args) { + for (int i = 0; i < 10; i++) { + int n = 100; + int[] nums = randomNumbers(n); + int index = findOne(nums); + System.out.println("\n数组 [ 1, 2, ..., n ] 被打乱后 = " + Arrays.toString(nums)); + System.out.println("数字 1 的索引为 " + index); + } + } +} diff --git a/codes/java/include/ListNode.java b/codes/java/include/ListNode.java new file mode 100755 index 000000000..c8a2283a9 --- /dev/null +++ b/codes/java/include/ListNode.java @@ -0,0 +1,41 @@ +package include; + +/** + * Definition for a singly-linked list node + */ +public class ListNode { + public int val; + public ListNode next; + + public ListNode(int x) { + val = x; + } + + /** + * Generate a linked list with an array + * @param arr + * @return + */ + public static ListNode arrToLinkedList(int[] arr) { + ListNode dum = new ListNode(0); + ListNode head = dum; + for (int val : arr) { + head.next = new ListNode(val); + head = head.next; + } + return dum.next; + } + + /** + * Get a list node with specific value from a linked list + * @param head + * @param val + * @return + */ + public static ListNode getListNode(ListNode head, int val) { + while (head != null && head.val != val) { + head = head.next; + } + return head; + } +} diff --git a/codes/java/include/PrintUtil.java b/codes/java/include/PrintUtil.java new file mode 100755 index 000000000..ea715910a --- /dev/null +++ b/codes/java/include/PrintUtil.java @@ -0,0 +1,88 @@ +package include; + +import java.util.*; + +class Trunk { + Trunk prev; + String str; + + Trunk(Trunk prev, String str) { + this.prev = prev; + this.str = str; + } +}; + +public class PrintUtil { + /** + * Print a linked list + * @param head + */ + public static void printLinkedList(ListNode head) { + List list = new ArrayList<>(); + while (head != null) { + list.add(String.valueOf(head.val)); + head = head.next; + } + System.out.println(String.join(" -> ", list)); + } + + /** + * The interface of the tree printer + * This tree printer is borrowed from TECHIE DELIGHT + * https://www.techiedelight.com/c-program-print-binary-tree/ + * @param root + */ + public static void printTree(TreeNode root) { + printTree(root, null, false); + } + + /** + * Print a binary tree + * @param root + * @param prev + * @param isLeft + */ + public static void printTree(TreeNode root, Trunk prev, boolean isLeft) { + if (root == null) { + return; + } + + String prev_str = " "; + Trunk trunk = new Trunk(prev, prev_str); + + printTree(root.right, trunk, true); + + if (prev == null) { + trunk.str = "———"; + } else if (isLeft) { + trunk.str = "/———"; + prev_str = " |"; + } else { + trunk.str = "\\———"; + prev.str = prev_str; + } + + showTrunks(trunk); + System.out.println(" " + root.val); + + if (prev != null) { + prev.str = prev_str; + } + trunk.str = " |"; + + printTree(root.left, trunk, false); + } + + /** + * Helper function to print branches of the binary tree + * @param p + */ + public static void showTrunks(Trunk p) { + if (p == null) { + return; + } + + showTrunks(p.prev); + System.out.print(p.str); + } +} diff --git a/codes/java/include/TreeNode.java b/codes/java/include/TreeNode.java new file mode 100755 index 000000000..e7daebb02 --- /dev/null +++ b/codes/java/include/TreeNode.java @@ -0,0 +1,80 @@ +package include; + +import java.util.*; + +/** + * Definition for a binary tree node. + */ +public class TreeNode { + public int val; + public TreeNode left; + public TreeNode right; + + public TreeNode(int x) { + val = x; + } + + /** + * Generate a binary tree with an array + * @param arr + * @return + */ + public static TreeNode arrToTree(Integer[] arr) { + TreeNode root = new TreeNode(arr[0]); + Queue queue = new LinkedList<>() {{ add(root); }}; + int i = 1; + while(!queue.isEmpty()) { + TreeNode node = queue.poll(); + if(arr[i] != null) { + node.left = new TreeNode(arr[i]); + queue.add(node.left); + } + i++; + if(arr[i] != null) { + node.right = new TreeNode(arr[i]); + queue.add(node.right); + } + i++; + } + return root; + } + + /** + * Serialize a binary tree to a list + * @param root + * @return + */ + public static List treeToList(TreeNode root) { + List list = new ArrayList<>(); + if(root == null) return list; + Queue queue = new LinkedList<>() {{ add(root); }}; + while(!queue.isEmpty()) { + TreeNode node = queue.poll(); + if(node != null) { + list.add(node.val); + queue.add(node.left); + queue.add(node.right); + } + else { + list.add(null); + } + } + return list; + } + + /** + * Get a tree node with specific value in a binary tree + * @param root + * @param val + * @return + */ + public static TreeNode getTreeNode(TreeNode root, int val) { + if (root == null) + return null; + if (root.val == val) + return root; + TreeNode left = getTreeNode(root.left, val); + TreeNode right = getTreeNode(root.right, val); + return left != null ? left : right; + } +} diff --git a/deploy.sh b/deploy.sh index f41a0e7fa..c77fcaca0 100644 --- a/deploy.sh +++ b/deploy.sh @@ -3,5 +3,5 @@ cd site git init git add -A git commit -m 'deploy' -git push -f git@github.com:krahets/dsa-021.git master:gh-pages +git push -f git@github.com:krahets/hello-algo.git master:gh-pages cd - diff --git a/docs/index.md b/docs/index.md index d05ab3087..9cc991f82 100644 --- a/docs/index.md +++ b/docs/index.md @@ -1,17 +1,23 @@ --- +comments: true hide: - footer --- -# Data Structure And Algorithm: From 0 to 1 +# Hello，算法！ -## Update Log +TODO -To be updated... +## 更新日志 -| Chapter | Date | +| 更新内容 | 日期 | | ------------ | ---------- | -| 数组与链表 | 2022-10-15 | -| 数据结构简介 | 2022-10-20 | -| 前言 | 2022-10-23 | -| 计算复杂度 | 2022-11-03 | +| 新增：算法无处不在 | 2022-10-10 | +| 新增：数组与链表 | 2022-10-15 | +| 新增：数据结构简介 | 2022-10-20 | +| 新增：前言 | 2022-10-23 | +| 新增：计算复杂度 | 2022-11-03 | +| 更新：配图 | 2022-11-04 | +| 新增：数据与内存 | 2022-11-05 | +| 更新：各章节 Java 代码 | 2022-11-06 | +| 更新：列表 Java 代码、配图 | 2022-11-07 | diff --git a/mkdocs.yml b/mkdocs.yml index fcd06d71b..e79aedea1 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -1,11 +1,11 @@ # Project information -site_name: 算法入门速成 -site_url: https://krahets.github.io/dsa-021/ +site_name: Hello 算法 +site_url: https://krahets.github.io/hello-algo/ site_author: Krahets site_description: Your first book to learn Data Structure And Algorithm. # Repository -repo_name: krahets/dsa-021 -repo_url: https://github.com/krahets/dsa-021 +repo_name: krahets/hello-algo +repo_url: https://github.com/krahets/hello-algo # Copyright copyright: Copyright © 2020 - 2022 Krahets @@ -115,17 +115,18 @@ extra_css: nav: - 关于本书: - chapter_about/index.md - - 前言: + - 算法无处不在: - chapter_introduction/index.md - 计算复杂度: - chapter_computational_complexity/index.md - 算法效率评估: chapter_computational_complexity/performance_evaluation.md - 时间复杂度: chapter_computational_complexity/time_complexity.md - 空间复杂度: chapter_computational_complexity/space_complexity.md + - 权衡时间与空间: chapter_computational_complexity/space_time_tradeoff.md - 小结: chapter_computational_complexity/summary.md - 数据结构简介: - chapter_data_structure/index.md - - 数据与内存: chapter_data_structure/computer_memory.md + - 数据与内存: chapter_data_structure/data_and_memory.md - 数据结构分类: chapter_data_structure/classification_of_data_strcuture.md - 小结: chapter_data_structure/summary.md - 数组与链表: @@ -133,4 +134,6 @@ nav: - 数组: chapter_array_and_linkedlist/array.md - 链表: chapter_array_and_linkedlist/linked_list.md - 列表: chapter_array_and_linkedlist/list.md - - 小结: chapter_array_and_linkedlist/summary.md \ No newline at end of file + - 小结: chapter_array_and_linkedlist/summary.md + - License: + - chapter_license/index.md \ No newline at end of file