diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000..618bdd6 Binary files /dev/null and b/.DS_Store differ diff --git a/.idea/dataSources.local.xml b/.idea/dataSources.local.xml index c0dfd56..1767467 100644 --- a/.idea/dataSources.local.xml +++ b/.idea/dataSources.local.xml @@ -1,6 +1,6 @@ - + #@ diff --git a/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0.xml b/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0.xml deleted file mode 100644 index a38f773..0000000 --- a/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0.xml +++ /dev/null @@ -1,14 +0,0 @@ - - - - - - - - - - - - - - \ No newline at end of file diff --git a/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0/storage_v2/_src_/schema/mysql.osA4Bg.meta b/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0/storage_v2/_src_/schema/mysql.osA4Bg.meta new file mode 100644 index 0000000..86a53f1 --- /dev/null +++ b/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0/storage_v2/_src_/schema/mysql.osA4Bg.meta @@ -0,0 +1,2 @@ +#n:mysql +! [null, 0, null, null, -2147483648, -2147483648] diff --git a/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0/storage_v2/_src_/schema/performance_schema.kIw0nw.meta b/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0/storage_v2/_src_/schema/performance_schema.kIw0nw.meta new file mode 100644 index 0000000..9394db1 --- /dev/null +++ b/.idea/dataSources/268b08ac-a860-48da-aa22-12d69675f3e0/storage_v2/_src_/schema/performance_schema.kIw0nw.meta @@ -0,0 +1,2 @@ +#n:performance_schema +! [null, 0, null, null, -2147483648, -2147483648] diff --git a/.idea/libraries/itextpdf_5_1_0.xml b/.idea/libraries/itextpdf_5_1_0.xml new file mode 100644 index 0000000..add1ffd --- /dev/null +++ b/.idea/libraries/itextpdf_5_1_0.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/libraries/itextpdf_5_5_9.xml b/.idea/libraries/itextpdf_5_5_9.xml new file mode 100644 index 0000000..584aec3 --- /dev/null +++ b/.idea/libraries/itextpdf_5_5_9.xml @@ -0,0 +1,9 @@ + + + + + + + + + \ No newline at end of file diff --git a/.idea/vcs.xml b/.idea/vcs.xml new file mode 100644 index 0000000..35eb1dd --- /dev/null +++ b/.idea/vcs.xml @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/.idea/workspace.xml b/.idea/workspace.xml index 964e8b1..7c630ed 100644 --- a/.idea/workspace.xml +++ b/.idea/workspace.xml @@ -3,8 +3,37 @@ + + + + + + + + + + + + + + + + + + + - - - - + + + + @@ -51,34 +81,41 @@ + + + + - - + + + - - + + + + + + + + - + - - - - - + + + + + + + + + + + + + + + + + + @@ -183,13 +259,31 @@ - - + @@ -475,6 +513,16 @@ + + + + + + + + + + @@ -488,7 +536,19 @@ - + + + - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - @@ -605,11 +586,6 @@ 107 diff --git a/SomeTest.iml b/SomeTest.iml index 1fe31a9..8833f02 100644 --- a/SomeTest.iml +++ b/SomeTest.iml @@ -41,8 +41,8 @@ - + @@ -324,5 +324,7 @@ + + \ No newline at end of file diff --git a/bin/execl/CalCount.class b/bin/execl/CalCount.class index 2eb3904..d6a0253 100644 Binary files a/bin/execl/CalCount.class and b/bin/execl/CalCount.class differ diff --git a/bin/execl/DisposeData.class b/bin/execl/DisposeData.class index 027dbc4..e74d9cd 100644 Binary files a/bin/execl/DisposeData.class and b/bin/execl/DisposeData.class differ diff --git a/bin/execl/DisposeData2.class b/bin/execl/DisposeData2.class index e8d5ba6..ae772fc 100644 Binary files a/bin/execl/DisposeData2.class and b/bin/execl/DisposeData2.class differ diff --git a/bin/execl/DisposeDataRelease.class b/bin/execl/DisposeDataRelease.class index 2da38ea..1cf900d 100644 Binary files a/bin/execl/DisposeDataRelease.class and b/bin/execl/DisposeDataRelease.class differ diff --git a/bin/execl/DisposeDataReleaseTwo.class b/bin/execl/DisposeDataReleaseTwo.class index e370dfe..9afcaab 100644 Binary files a/bin/execl/DisposeDataReleaseTwo.class and b/bin/execl/DisposeDataReleaseTwo.class differ diff --git a/bin/execl/ExeclParse.class b/bin/execl/ExeclParse.class index cf3365f..a97c921 100644 Binary files a/bin/execl/ExeclParse.class and b/bin/execl/ExeclParse.class differ diff --git a/bin/execl/TimeFormat.class b/bin/execl/TimeFormat.class index d19a050..41829db 100644 Binary files a/bin/execl/TimeFormat.class and b/bin/execl/TimeFormat.class differ diff --git a/bin/imagesToPDF/JpgToPdf.class b/bin/imagesToPDF/JpgToPdf.class new file mode 100644 index 0000000..cc8692c Binary files /dev/null and b/bin/imagesToPDF/JpgToPdf.class differ diff --git a/bin/itinterview/stackandqueue/StackGetMin.class b/bin/itinterview/stackandqueue/StackGetMin.class index 7053b8c..9507e59 100644 Binary files a/bin/itinterview/stackandqueue/StackGetMin.class and b/bin/itinterview/stackandqueue/StackGetMin.class differ diff --git a/bin/itinterview/stackandqueue/StackSortStack.class b/bin/itinterview/stackandqueue/StackSortStack.class index affd5cb..30ef75d 100644 Binary files a/bin/itinterview/stackandqueue/StackSortStack.class and b/bin/itinterview/stackandqueue/StackSortStack.class differ diff --git a/bin/itinterview/stackandqueue/TwoStackQueue.class b/bin/itinterview/stackandqueue/TwoStackQueue.class index b667294..823633d 100644 Binary files a/bin/itinterview/stackandqueue/TwoStackQueue.class and b/bin/itinterview/stackandqueue/TwoStackQueue.class differ diff --git a/bin/leetcode/easy/IntegerToRoman.class b/bin/leetcode/easy/IntegerToRoman.class index 3fc9735..d958a4f 100644 Binary files a/bin/leetcode/easy/IntegerToRoman.class and b/bin/leetcode/easy/IntegerToRoman.class differ diff --git a/bin/leetcode/easy/ListNode.class b/bin/leetcode/easy/ListNode.class deleted file mode 100644 index 7f8e5f4..0000000 Binary files a/bin/leetcode/easy/ListNode.class and /dev/null differ diff --git a/bin/leetcode/easy/MergeTwoLists.class b/bin/leetcode/easy/MergeTwoLists.class index 9c3f6b6..2275797 100644 Binary files a/bin/leetcode/easy/MergeTwoLists.class and b/bin/leetcode/easy/MergeTwoLists.class differ diff --git a/bin/leetcode/naive/DelLinkedListElement.class b/bin/leetcode/naive/DelLinkedListElement.class index a3f6e70..8d97860 100644 Binary files a/bin/leetcode/naive/DelLinkedListElement.class and b/bin/leetcode/naive/DelLinkedListElement.class differ diff --git a/bin/leetcode/naive/IntegerSort.class b/bin/leetcode/naive/IntegerSort.class index b1604dc..5a0c559 100644 Binary files a/bin/leetcode/naive/IntegerSort.class and b/bin/leetcode/naive/IntegerSort.class differ diff --git a/bin/leetcode/naive/ListNode.class b/bin/leetcode/naive/ListNode.class index d324876..44ab158 100644 Binary files a/bin/leetcode/naive/ListNode.class and b/bin/leetcode/naive/ListNode.class differ diff --git a/bin/leetcodeNZ/easy/13_Roman_to_Integer.py b/bin/leetcodeNZ/easy/13_Roman_to_Integer.py new file mode 100644 index 0000000..b734587 --- /dev/null +++ b/bin/leetcodeNZ/easy/13_Roman_to_Integer.py @@ -0,0 +1,84 @@ +# Roman numerals are represented by seven different symbols: I, V, X, L, C, D and M. +# +# Symbol Value +# I 1 +# V 5 +# X 10 +# L 50 +# C 100 +# D 500 +# M 1000 +# For example, two is written as II in Roman numeral, just two one's added together. Twelve is written as, XII, which is simply X + II. The number twenty seven is written as XXVII, which is XX + V + II. +# +# Roman numerals are usually written largest to smallest from left to right. However, the numeral for four is not IIII. Instead, the number four is written as IV. Because the one is before the five we subtract it making four. The same principle applies to the number nine, which is written as IX. There are six instances where subtraction is used: +# +# I can be placed before V (5) and X (10) to make 4 and 9. +# X can be placed before L (50) and C (100) to make 40 and 90. +# C can be placed before D (500) and M (1000) to make 400 and 900. +# Given a roman numeral, convert it to an integer. Input is guaranteed to be within the range from 1 to 3999. +# +# Example 1: +# +# Input: "III" +# Output: 3 + +# Example 2: +# +# Input: "IV" +# Output: 4 + +# Example 3: +# +# Input: "IX" +# Output: 9 + +# Example 4: +# +# Input: "LVIII" +# Output: 58 +# Explanation: L = 50, V= 5, III = 3. + +# Example 5: +# +# Input: "MCMXCIV" +# Output: 1994 +# Explanation: M = 1000, CM = 900, XC = 90 and IV = 4. + +class Solution: + def romanToInt(self, s: str) -> int: + rCharMap = { + "M": 1000, + "D": 500, + "C": 100, + "L": 50, + "X": 10, + "V": 5, + "I": 1, + } + + index = 0 + length = len(s) + result = 0 + while index < length: + currentNum = rCharMap[s[index]] + nextIndex = index + 1 + if nextIndex < length: + nextNum = rCharMap[s[index + 1]] + else: + nextNum = 0 + if nextNum > currentNum: + result -= currentNum + else: + result += currentNum + index += 1 + return result + + +s = Solution() +print("ssss " + str(s.romanToInt("MCMXCIV"))) +print(s.romanToInt("LVIII")) +print(s.romanToInt("IX")) +print(s.romanToInt("IV")) + + + diff --git a/bin/leetcodeNZ/easy/14_Longest_Common_Prefix.py b/bin/leetcodeNZ/easy/14_Longest_Common_Prefix.py new file mode 100644 index 0000000..6375d08 --- /dev/null +++ b/bin/leetcodeNZ/easy/14_Longest_Common_Prefix.py @@ -0,0 +1,108 @@ +# Write a function to find the longest common prefix string amongst an array of strings. +# +# If there is no common prefix, return an empty string "". +# +# Example 1: +# +# Input: ["flower","flow","flight"] +# Output: "fl" +# Example 2: +# +# Input: ["dog","racecar","car"] +# Output: "" +# Explanation: There is no common prefix among the input strings. +# Note: +# +# All given inputs are in lowercase letters a-z. + + +from typing import List + + +# def getCommonPrefixFromTwoStrs(str_one, str_two) -> str: +# commonPrefix = "" +# str_one_len = len(str_one) +# str_two_len = len(str_two) +# +# index = 0 +# if str_one_len > str_two_len: +# loopStr = str_two +# compareStr = str_one +# shorter_len = str_two_len +# else: +# loopStr = str_one +# compareStr = str_two +# shorter_len = str_one_len +# +# cursor = 0 +# cursorLen = 1 +# while index <= shorter_len: +# cursorStr = loopStr[cursor: cursorLen] +# findIndex = compareStr.find(cursorStr) +# if findIndex >= 0: +# cursorLen += 1 +# commonPrefix = cursorStr +# else: +# cursor += cursorLen +# index = cursor + cursorLen +# +# return commonPrefix + +def getCommonPrefixFromTwoStrs(str_one, str_two) -> str: + commonPrefix = "" + str_one_len = len(str_one) + str_two_len = len(str_two) + + if str_one_len <= 0 or str_two_len <= 0 or str_one[0] != str_two[0]: + print("str_one " + str_one + " str_two " + str_two) + return "" + + index = 0 + if str_one_len > str_two_len: + loopStr = str_two + compareStr = str_one + shorter_len = str_two_len + else: + loopStr = str_one + compareStr = str_two + shorter_len = str_one_len + + cursor = 0 + cursorLen = 1 + while index <= shorter_len: + cursorStr = loopStr[cursor: cursorLen] + findIndex = compareStr.find(cursorStr) + if findIndex == 0: + cursorLen += 1 + commonPrefix = cursorStr + else: + cursor += cursorLen + index = cursor + cursorLen + return commonPrefix + +class Solution: + + def longestCommonPrefix(self, strs: List[str]) -> str: + listLength = len(strs) + if listLength <= 0: + return "" + if listLength == 1: + return strs[0] + commonPrefix = getCommonPrefixFromTwoStrs(strs[0], strs[1]) + print("commonprefix 111 " + commonPrefix + " strs[0] " + strs[0] + " strs[1] " + strs[1]) + index = 2 + while index < listLength: + itemStr = strs[index] + print("commonprefix 2222 commonPrefix " + commonPrefix + " itemStr " + itemStr) + commonPrefix = getCommonPrefixFromTwoStrs(commonPrefix, itemStr) + print("commonprefix 33333 " + commonPrefix) + index += 1 + return commonPrefix + + + +s = Solution() +print(s.longestCommonPrefix(["flower", "flow", "flight"])) +print(s.longestCommonPrefix(["ca", "a"])) +print(s.longestCommonPrefix(["abca","aba","aaab"])) + diff --git a/bin/leetcodeNZ/easy/20_Valid_Parentheses.py b/bin/leetcodeNZ/easy/20_Valid_Parentheses.py new file mode 100644 index 0000000..b41d403 --- /dev/null +++ b/bin/leetcodeNZ/easy/20_Valid_Parentheses.py @@ -0,0 +1,59 @@ +# Given a string containing just the characters '(', ')', '{', '}', '[' and ']', determine if the input string is valid. +# +# An input string is valid if: +# +# Open brackets must be closed by the same type of brackets. +# Open brackets must be closed in the correct order. +# Note that an empty string is also considered valid. +# +# Example 1: +# +# Input: "()" +# Output: true +# Example 2: +# +# Input: "()[]{}" +# Output: true +# Example 3: +# +# Input: "(]" +# Output: false +# Example 4: +# +# Input: "([)]" +# Output: false +# Example 5: +# +# Input: "{[]}" +# Output: true + + +class Solution: + def isValid(self, s: str) -> bool: + while True: + isContainRoundBracket = s.find("()") >= 0 + if isContainRoundBracket: + s = s.replace("()", "") + + isContainCurlyBracket = s.find("{}") >= 0 + if isContainCurlyBracket: + s = s.replace("{}", "") + + isContainSquareBracket = s.find("[]") >= 0 + if isContainSquareBracket: + s = s.replace("[]", "") + + if not isContainRoundBracket and not isContainCurlyBracket and not isContainSquareBracket: + break + + if len(s) > 0: + return False + else: + return True + +s = Solution() +s.isValid("()") +s.isValid("()[]{}") +s.isValid("(]") +s.isValid("([)]") +s.isValid("{[]}") diff --git a/bin/leetcodeNZ/easy/21_Merge_Two_Sorted_Lists.py b/bin/leetcodeNZ/easy/21_Merge_Two_Sorted_Lists.py new file mode 100644 index 0000000..4488d41 --- /dev/null +++ b/bin/leetcodeNZ/easy/21_Merge_Two_Sorted_Lists.py @@ -0,0 +1,66 @@ +# Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists. + +# Example: + +# Input: 1 -> 2 -> 4, 1 -> 3 -> 4 +# Output: 1 -> 1 -> 2 -> 3 -> 4 -> 4 + + +# Definition for singly-linked list. +class ListNode: + def __init__(self, x): + self.val = x + self.next = None + + +class Solution: + def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode: + if not l1 and not l2: + return None + + if not l1: + return l2 + + if not l2: + return l1 + + head = mergedNode = ListNode(0) + while mergedNode is not None: + if l1 is None: + mergedNode.next = l2 + return head.next + if l2 is None: + mergedNode.next = l1 + return head.next + val1 = l1.val + val2 = l2.val + if val1 < val2: + newNode = ListNode(val1) + l1 = l1.next + else: + newNode = ListNode(val2) + l2 = l2.next + mergedNode.next = newNode + mergedNode = mergedNode.next + +node1 = ListNode(4) +node2 = ListNode(2) +node2.next = node1 +node3 = ListNode(1) +node3.next = node2 + +nodeA = ListNode(4) +nodeB = ListNode(3) +nodeB.next = nodeA +nodeC = ListNode(1) +nodeC.next = nodeB + +s = Solution() +print("---------------------BEGIN------------ ") +resultNode = s.mergeTwoLists(node3, nodeC) + +while resultNode is not None: + print(resultNode.val) + resultNode = resultNode.next + +print("---------------------END------------ ") diff --git a/bin/leetcodeNZ/easy/26_Remove_Duplicates_From_Sorted_Array.py b/bin/leetcodeNZ/easy/26_Remove_Duplicates_From_Sorted_Array.py new file mode 100644 index 0000000..55765df --- /dev/null +++ b/bin/leetcodeNZ/easy/26_Remove_Duplicates_From_Sorted_Array.py @@ -0,0 +1,62 @@ +# https://leetcode.com/problems/remove-duplicates-from-sorted-array/ + +# Given a sorted array nums, remove the duplicates in-place such that each element appear only once and return the new length. + +# Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory. + +# Example 1: + +# Given nums = [1, 1, 2], + +# Your function should return length = 2, with the first two elements of nums being 1 and 2 respectively. + +# It doesn't matter what you leave beyond the returned length. +# Example 2: + +# Given nums = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4], + +# Your function should return length = 5, with the first five elements of nums being modified to 0, 1, 2, 3, and 4 respectively. + +# It doesn't matter what values are set beyond the returned length. +# Clarification: + +# Confused why the returned value is an integer but your answer is an array? + +# Note that the input array is passed in by reference, which means modification to the input array will be known to the caller as well. + +# Internally you can think of this: + +# // nums is passed in by reference. (i.e., without making a copy) +# int len = removeDuplicates(nums) + +# // any modification to nums in your function would be known by the caller. +# // using the length returned by your function, it prints the first len elements. +# for (int i=0 +# i < len +# i++) { +# print(nums[i]) +# } +from typing import List + +class Solution: + def removeDuplicates(self, nums: List[int]) -> int: + numsLen = len(nums) + if numsLen == 0: + return 0 + + unduplicatedLen = 0 + for i in range(1, numsLen): + if nums[unduplicatedLen] == nums[i]: + continue + else: + unduplicatedLen += 1 + nums[unduplicatedLen] = nums[i] + return unduplicatedLen + 1 + + + +s = Solution() +len1 = s.removeDuplicates([1, 1, 2]) +print("------------------------------------------------") +len2 = s.removeDuplicates([0, 0, 1, 1, 1, 2, 2, 3, 3, 4]) +# print("len1 " + str(len1) + " len2 " + str(len2)) diff --git a/bin/leetcodeNZ/easy/28_Implement_strStr.py b/bin/leetcodeNZ/easy/28_Implement_strStr.py new file mode 100644 index 0000000..596b500 --- /dev/null +++ b/bin/leetcodeNZ/easy/28_Implement_strStr.py @@ -0,0 +1,51 @@ +# https://leetcode.com/problems/implement-strstr/ + +# Implement strStr(). + +# Return the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack. + +# Example 1: + +# Input: haystack = "hello", needle = "ll" +# Output: 2 +# Example 2: + +# Input: haystack = "aaaaa", needle = "bba" +# Output: -1 +# Clarification: + +# What should we return when needle is an empty string? This is a great question to ask during an interview. + +# For the purpose of this problem, we will return 0 when needle is an empty string. This is consistent to C's strstr() and Java's indexOf(). + +class Solution: + + def strStr(self, haystack: str, needle: str) -> int: + + haystackLen = len(haystack) + needleLen = len(needle) + + if haystackLen <= 0 and needleLen <= 0 or needleLen <= 0: + return 0 + if haystackLen <= 0 or needleLen > haystackLen: + return -1 + + map = {} + + index = 0 + while index < haystackLen - needleLen + 1: + if haystack[index] == needle[0]: + map[index] = haystack[index: index + needleLen] + index += 1 + + for key in map: + if map[key] == needle: + return key + + return -1 + +s = Solution() +print(s.strStr("hellolodloeloflkjlkilmnlkjlhf", "ll")) +print(s.strStr("commonmjmkmnmhmjmkmlmnmnmnmvmvm", "mo")) +print(s.strStr("aaaaabhjhbbbhjbghbghbghbvcbvcbvcbvcxbvcxzbfrdbgyh", "bba")) +print(s.strStr("bba", "aaaaa")) diff --git a/bin/leetcodeNZ/easy/38_Count_And_Say.py b/bin/leetcodeNZ/easy/38_Count_And_Say.py new file mode 100644 index 0000000..7f9b0ae --- /dev/null +++ b/bin/leetcodeNZ/easy/38_Count_And_Say.py @@ -0,0 +1,74 @@ +# https: // leetcode.com/problems/count-and-say/ + +# The count-and-say sequence is the sequence of integers with the first five terms as following: + +# 1. 1 +# 2. 11 +# 3. 21 +# 4. 1211 +# 5. 111221 +# 1 is read off as "one 1" or 11. +# 11 is read off as "two 1s" or 21. +# 21 is read off as "one 2, then one 1" or 1211. + +# Given an integer n where 1 ≤ n ≤ 30, generate the nth term of the count-and-say sequence. You can do so recursively, in other words from the previous member read off the digits, counting the number of digits in groups of the same digit. + +# Note: Each term of the sequence of integers will be represented as a string. + + +# Example 1: + +# Input: 1 +# Output: "1" +# Explanation: This is the base case. +# Example 2: + +# Input: 4 +# Output: "1211" +# Explanation: For n = 3 the term was "21" in which we have two groups "2" and "1", "2" can be read as "12" which means frequency = 1 and value = 2, the same way "1" is read as "11", so the answer is the concatenation of "12" and "11" which is "1211". + +from typing import List + + +def splitStr(strByIndex: str) -> List: + splitArray = [] + strLen = len(strByIndex) + if strLen <= 1: + return strByIndex + + index = 0 + arrayItem = strByIndex[0] + while index < strLen - 1: + curChar = strByIndex[index] + nextChar = strByIndex[index + 1] + + if curChar == nextChar: + arrayItem += nextChar + else: + splitArray.append(arrayItem) + arrayItem = nextChar + index += 1 + if len(arrayItem) > 0: + splitArray.append(arrayItem) + + return splitArray + + +def countAndSay(n: int) -> str: + if n <= 1: + return "1" + count = 0 + strOfCountAndSay = "1" + while count < n - 1: + splitArray = splitStr(strOfCountAndSay) + strOfCountAndSay = "" + for index in range(len(splitArray)): + strOfCountAndSay += str(len(splitArray[index])) + splitArray[index][0] + count += 1 + return strOfCountAndSay + + +i = 1 +while i <= 30: + print(countAndSay(i)) + i += 1 diff --git a/bin/leetcodeNZ/easy/53_Maximum_Subarry.py b/bin/leetcodeNZ/easy/53_Maximum_Subarry.py new file mode 100644 index 0000000..380009c --- /dev/null +++ b/bin/leetcodeNZ/easy/53_Maximum_Subarry.py @@ -0,0 +1,33 @@ +# https: // leetcode.com/problems/maximum-subarray/ + +# Given an integer array nums, find the contiguous subarray(containing at least one number) which has the largest sum and return its sum. + +# Example: + +# Input: [-2, 1, -3, 4, -1, 2, 1, -5, 4], +# Output: 6 +# Explanation: [4, -1, 2, 1] has the largest sum = 6. +# Follow up: + +# If you have figured out the O(n) solution, try coding another solution using the divide and conquer approach, +# which is more subtle. + +from typing import List + + +class Solution: + def maxSubArray(self, nums: List[int]) -> int: + listLen = len(nums) + if listLen <= 0: + return 0 + max_current = max_global = nums[0] + index = 1 + while index < listLen: + max_current = max(nums[index], nums[index] + max_current) + max_global = max(max_current, max_global) + index += 1 + return max_global + + +s = Solution() +print(s.maxSubArray([-2, 1, -3, 4, -1, 2, 1, -5, 4])) diff --git a/bin/leetcodeNZ/easy/66_Plus_One.py b/bin/leetcodeNZ/easy/66_Plus_One.py new file mode 100644 index 0000000..85f42a0 --- /dev/null +++ b/bin/leetcodeNZ/easy/66_Plus_One.py @@ -0,0 +1,45 @@ +# https: // leetcode.com/problems/plus-one/ + +# Given a non-empty array of digits representing a non-negative integer, plus one to the integer. + +# The digits are stored such that the most significant digit is at the head of the list, and each element in the array contain a single digit. + +# You may assume the integer does not contain any leading zero, except the number 0 itself. + +# Example 1: + +# Input: [1, 2, 3] +# Output: [1, 2, 4] +# Explanation: The array represents the integer 123. +# Example 2: + +# Input: [4, 3, 2, 1] +# Output: [4, 3, 2, 2] +# Explanation: The array represents the integer 4321. + +from typing import List + +class Solution: + def plusOne(self, digits: List[int]) -> List[int]: + if not digits: + return [] + + digitsLen = len(digits) + + index = digitsLen - 1 + + while index > -1: + if digits[index] < 9: + digits[index] += 1 + return digits + else: + digits[index] = 0 + index -= 1 + digits.insert(0, 1) + return digits + +s = Solution() +print(s.plusOne([1, 2, 3])) +print(s.plusOne([4, 3, 2, 1])) +print(s.plusOne([9, 9, 9])) +print(s.plusOne([8, 9, 9])) diff --git a/bin/leetcodeNZ/easy/9_Palindrome_number.py b/bin/leetcodeNZ/easy/9_Palindrome_number.py new file mode 100644 index 0000000..38d4c68 --- /dev/null +++ b/bin/leetcodeNZ/easy/9_Palindrome_number.py @@ -0,0 +1,35 @@ +# Determine whether an integer is a palindrome. An integer is a palindrome when it reads the same backward as forward. +# +# Example 1: +# +# Input: 121 +# Output: true +# Example 2: +# +# Input: -121 +# Output: false +# Explanation: From left to right, it reads -121. From right to left, it becomes 121-. Therefore it is not a palindrome. +# Example 3: +# +# Input: 10 +# Output: false +# Explanation: Reads 01 from right to left. Therefore it is not a palindrome. + +class Solution: + def isPalindrome(self, num: int) -> bool: + if num < 0: + return False + elif 0 <= num < 10: + return True + else: + originalNum = num + newNum = 0 + while num > 0: + newNum *= 10 + newNum += num % 10 + num = int(num / 10) + return not (originalNum - newNum) + + +s = Solution() +print(s.isPalindrome(2827282)) diff --git a/bin/leetcodeNZ/easy/EASY_7_Reverse_Integer.class b/bin/leetcodeNZ/easy/EASY_7_Reverse_Integer.class index fed404d..3940af0 100644 Binary files a/bin/leetcodeNZ/easy/EASY_7_Reverse_Integer.class and b/bin/leetcodeNZ/easy/EASY_7_Reverse_Integer.class differ diff --git a/bin/leetcodeNZ/example/LinkedListStack.class b/bin/leetcodeNZ/example/LinkedListStack.class new file mode 100644 index 0000000..e544e9d Binary files /dev/null and b/bin/leetcodeNZ/example/LinkedListStack.class differ diff --git a/bin/leetcodeNZ/example/ModifiedTreeNodePrint.class b/bin/leetcodeNZ/example/ModifiedTreeNodePrint.class new file mode 100644 index 0000000..aacd65b Binary files /dev/null and b/bin/leetcodeNZ/example/ModifiedTreeNodePrint.class differ diff --git a/bin/leetcodeNZ/example/Node.class b/bin/leetcodeNZ/example/Node.class new file mode 100644 index 0000000..5f7a83b Binary files /dev/null and b/bin/leetcodeNZ/example/Node.class differ diff --git a/bin/leetcodeNZ/example/PrintLevelOrder.class b/bin/leetcodeNZ/example/PrintLevelOrder.class new file mode 100644 index 0000000..978cf4b Binary files /dev/null and b/bin/leetcodeNZ/example/PrintLevelOrder.class differ diff --git a/bin/leetcodeNZ/example/Stack.class b/bin/leetcodeNZ/example/Stack.class new file mode 100644 index 0000000..af20148 Binary files /dev/null and b/bin/leetcodeNZ/example/Stack.class differ diff --git a/bin/leetcodeNZ/example/StackNode.class b/bin/leetcodeNZ/example/StackNode.class new file mode 100644 index 0000000..025b995 Binary files /dev/null and b/bin/leetcodeNZ/example/StackNode.class differ diff --git a/bin/leetcodeNZ/example/Tree.class b/bin/leetcodeNZ/example/Tree.class new file mode 100644 index 0000000..8f2605a Binary files /dev/null and b/bin/leetcodeNZ/example/Tree.class differ diff --git a/bin/leetcodeNZ/example/TreeNodePrint.class b/bin/leetcodeNZ/example/TreeNodePrint.class new file mode 100644 index 0000000..7703c16 Binary files /dev/null and b/bin/leetcodeNZ/example/TreeNodePrint.class differ diff --git a/bin/leetcodeNZ/hard/HARD_10_Regular_Expression_Matching.class b/bin/leetcodeNZ/hard/HARD_10_Regular_Expression_Matching.class index 53b2460..3e9e839 100644 Binary files a/bin/leetcodeNZ/hard/HARD_10_Regular_Expression_Matching.class and b/bin/leetcodeNZ/hard/HARD_10_Regular_Expression_Matching.class differ diff --git a/bin/leetcodeNZ/hard/HARD_140_Word_Break_II.class b/bin/leetcodeNZ/hard/HARD_140_Word_Break_II.class index 22d836c..764bf52 100644 Binary files a/bin/leetcodeNZ/hard/HARD_140_Word_Break_II.class and b/bin/leetcodeNZ/hard/HARD_140_Word_Break_II.class differ diff --git a/bin/leetcodeNZ/medium/ListNode.class b/bin/leetcodeNZ/medium/ListNode.class deleted file mode 100644 index 6f2682b..0000000 Binary files a/bin/leetcodeNZ/medium/ListNode.class and /dev/null differ diff --git a/bin/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.class b/bin/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.class index ce8454e..bac4330 100644 Binary files a/bin/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.class and b/bin/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.class differ diff --git a/bin/leetcodeNZ/medium/MEDIUM_3_LONGEST_NO_REPEAT_C.class b/bin/leetcodeNZ/medium/MEDIUM_3_LONGEST_NO_REPEAT_C.class deleted file mode 100644 index 229e4e4..0000000 Binary files a/bin/leetcodeNZ/medium/MEDIUM_3_LONGEST_NO_REPEAT_C.class and /dev/null differ diff --git a/bin/leetcodeNZ/medium/Medium_3_longest_no_repeat_character.class b/bin/leetcodeNZ/medium/Medium_3_longest_no_repeat_character.class new file mode 100644 index 0000000..db10ddf Binary files /dev/null and b/bin/leetcodeNZ/medium/Medium_3_longest_no_repeat_character.class differ diff --git a/bin/leetcodeNZ/medium/MEDIUM_6_ZIGZAG_CONVERSION.class b/bin/leetcodeNZ/medium/Medium_6_zigzag_coversion.class similarity index 54% rename from bin/leetcodeNZ/medium/MEDIUM_6_ZIGZAG_CONVERSION.class rename to bin/leetcodeNZ/medium/Medium_6_zigzag_coversion.class index b8a92f9..ea7988e 100644 Binary files a/bin/leetcodeNZ/medium/MEDIUM_6_ZIGZAG_CONVERSION.class and b/bin/leetcodeNZ/medium/Medium_6_zigzag_coversion.class differ diff --git a/bin/leetcodeNZ/model/ListNode.class b/bin/leetcodeNZ/model/ListNode.class new file mode 100644 index 0000000..0a343fa Binary files /dev/null and b/bin/leetcodeNZ/model/ListNode.class differ diff --git a/bin/leetcodeNZ/model/TreeNode.class b/bin/leetcodeNZ/model/TreeNode.class new file mode 100644 index 0000000..5a973ae Binary files /dev/null and b/bin/leetcodeNZ/model/TreeNode.class differ diff --git a/bin/leetcodeNZ/tags/array/easy/Array_27_Remove_Element.class b/bin/leetcodeNZ/tags/array/easy/Array_27_Remove_Element.class new file mode 100644 index 0000000..674a68c Binary files /dev/null and b/bin/leetcodeNZ/tags/array/easy/Array_27_Remove_Element.class differ diff --git a/bin/leetcodeNZ/tags/array/hard/Array_4_Median_of_Two_Sorted_Arrays.class b/bin/leetcodeNZ/tags/array/hard/Array_4_Median_of_Two_Sorted_Arrays.class new file mode 100644 index 0000000..5f1bb80 Binary files /dev/null and b/bin/leetcodeNZ/tags/array/hard/Array_4_Median_of_Two_Sorted_Arrays.class differ diff --git a/bin/leetcodeNZ/tags/array/medium/Array_11_Container_With_Most_Water.class b/bin/leetcodeNZ/tags/array/medium/Array_11_Container_With_Most_Water.class new file mode 100644 index 0000000..069f325 Binary files /dev/null and b/bin/leetcodeNZ/tags/array/medium/Array_11_Container_With_Most_Water.class differ diff --git a/bin/leetcodeNZ/tags/array/medium/Array_15_3Sum.class b/bin/leetcodeNZ/tags/array/medium/Array_15_3Sum.class new file mode 100644 index 0000000..778dd32 Binary files /dev/null and b/bin/leetcodeNZ/tags/array/medium/Array_15_3Sum.class differ diff --git a/bin/leetcodeNZ/tags/dynamicProgramming/DP_1137_N_th_Tribonacci_Number.class b/bin/leetcodeNZ/tags/dynamicProgramming/DP_1137_N_th_Tribonacci_Number.class new file mode 100644 index 0000000..ca1d459 Binary files /dev/null and b/bin/leetcodeNZ/tags/dynamicProgramming/DP_1137_N_th_Tribonacci_Number.class differ diff --git a/bin/leetcodeNZ/tags/dynamicProgramming/DP_509_Fibonacci_Number.class b/bin/leetcodeNZ/tags/dynamicProgramming/DP_509_Fibonacci_Number.class new file mode 100644 index 0000000..1f6c0a0 Binary files /dev/null and b/bin/leetcodeNZ/tags/dynamicProgramming/DP_509_Fibonacci_Number.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer.class new file mode 100644 index 0000000..0681dcf Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_203_Remove_Linked_List_Elements.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_203_Remove_Linked_List_Elements.class new file mode 100644 index 0000000..f1c3c2d Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_203_Remove_Linked_List_Elements.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_206_Reverse_Linked_List.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_206_Reverse_Linked_List.class new file mode 100644 index 0000000..b4be080 Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_206_Reverse_Linked_List.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_237_Delete_Node_in_a_Linked_List.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_237_Delete_Node_in_a_Linked_List.class new file mode 100644 index 0000000..cfdf5fb Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_237_Delete_Node_in_a_Linked_List.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_705_Design_HashSet.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_705_Design_HashSet.class new file mode 100644 index 0000000..afbbbd9 Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_705_Design_HashSet.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_83_Remove_Duplicates_from_Sorted_List.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_83_Remove_Duplicates_from_Sorted_List.class new file mode 100644 index 0000000..144e73f Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_83_Remove_Duplicates_from_Sorted_List.class differ diff --git a/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_876_Middle_of_the_Linked_List.class b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_876_Middle_of_the_Linked_List.class new file mode 100644 index 0000000..80f419b Binary files /dev/null and b/bin/leetcodeNZ/tags/linkedlist/easy/LinkedList_876_Middle_of_the_Linked_List.class differ diff --git a/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_101_Symmetric_Tree.class b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_101_Symmetric_Tree.class new file mode 100644 index 0000000..30cf05e Binary files /dev/null and b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_101_Symmetric_Tree.class differ diff --git a/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_118_Pascal_s_Triangle.class b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_118_Pascal_s_Triangle.class new file mode 100644 index 0000000..099fe69 Binary files /dev/null and b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_118_Pascal_s_Triangle.class differ diff --git a/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_121_Best_Time_to_Buy_and_Sell_Stock.class b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_121_Best_Time_to_Buy_and_Sell_Stock.class new file mode 100644 index 0000000..e2e0870 Binary files /dev/null and b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_121_Best_Time_to_Buy_and_Sell_Stock.class differ diff --git a/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_125_Valid_Palindrome.class b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_125_Valid_Palindrome.class new file mode 100644 index 0000000..333a26c Binary files /dev/null and b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_125_Valid_Palindrome.class differ diff --git a/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_70_Climbing_Stairs.class b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_70_Climbing_Stairs.class new file mode 100644 index 0000000..cf47a4a Binary files /dev/null and b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_70_Climbing_Stairs.class differ diff --git a/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_88_Merge_Sorted_Array.class b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_88_Merge_Sorted_Array.class new file mode 100644 index 0000000..cd12bd6 Binary files /dev/null and b/bin/leetcodeNZ/tags/topInterviewQuestions/TIQ_88_Merge_Sorted_Array.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Node.class b/bin/leetcodeNZ/tags/tree/easy/Node.class new file mode 100644 index 0000000..4ee014e Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Node.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_100_Same_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_100_Same_Tree.class new file mode 100644 index 0000000..f070c77 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_100_Same_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_104_Maximum_Depth_of_Binary_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_104_Maximum_Depth_of_Binary_Tree.class new file mode 100644 index 0000000..fb1f775 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_104_Maximum_Depth_of_Binary_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_108_convert_sorted_array_to_binary_search_tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_108_convert_sorted_array_to_binary_search_tree.class new file mode 100644 index 0000000..9dcc6b3 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_108_convert_sorted_array_to_binary_search_tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_144_Binary_Tree_Preorder_Traversal.class b/bin/leetcodeNZ/tags/tree/easy/Tree_144_Binary_Tree_Preorder_Traversal.class new file mode 100644 index 0000000..4ae67b3 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_144_Binary_Tree_Preorder_Traversal.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_145_Binary_Tree_Postorder_Traversal.class b/bin/leetcodeNZ/tags/tree/easy/Tree_145_Binary_Tree_Postorder_Traversal.class new file mode 100644 index 0000000..b8448e3 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_145_Binary_Tree_Postorder_Traversal.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_2236_Root_Equals_Sum_Of_Children.class b/bin/leetcodeNZ/tags/tree/easy/Tree_2236_Root_Equals_Sum_Of_Children.class new file mode 100644 index 0000000..8fbe793 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_2236_Root_Equals_Sum_Of_Children.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_226_Invert_Binary_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_226_Invert_Binary_Tree.class new file mode 100644 index 0000000..625fe0b Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_226_Invert_Binary_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.class new file mode 100644 index 0000000..287b7d5 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_257_Binary_Tree_Paths.class b/bin/leetcodeNZ/tags/tree/easy/Tree_257_Binary_Tree_Paths.class new file mode 100644 index 0000000..943e1ff Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_257_Binary_Tree_Paths.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_559_Maximum_Depth_of_N_ary_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_559_Maximum_Depth_of_N_ary_Tree.class new file mode 100644 index 0000000..91a3603 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_559_Maximum_Depth_of_N_ary_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_563_Binary_Tree_Tilt.class b/bin/leetcodeNZ/tags/tree/easy/Tree_563_Binary_Tree_Tilt.class new file mode 100644 index 0000000..20ff465 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_563_Binary_Tree_Tilt.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_589_N_ary_Tree_Preorder_Traversal.class b/bin/leetcodeNZ/tags/tree/easy/Tree_589_N_ary_Tree_Preorder_Traversal.class new file mode 100644 index 0000000..b15ae07 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_589_N_ary_Tree_Preorder_Traversal.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_590_N_ary_Tree_Postorder_Traversal.class b/bin/leetcodeNZ/tags/tree/easy/Tree_590_N_ary_Tree_Postorder_Traversal.class new file mode 100644 index 0000000..2b16efd Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_590_N_ary_Tree_Postorder_Traversal.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_606_Construct_String_from_Binary_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_606_Construct_String_from_Binary_Tree.class new file mode 100644 index 0000000..4ae60bd Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_606_Construct_String_from_Binary_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_617_merge_two_binary_tress.class b/bin/leetcodeNZ/tags/tree/easy/Tree_617_merge_two_binary_tress.class new file mode 100644 index 0000000..85ccd93 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_617_merge_two_binary_tress.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_637_Average_of_Levels_in_Binary_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_637_Average_of_Levels_in_Binary_Tree.class new file mode 100644 index 0000000..e5f38d9 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_637_Average_of_Levels_in_Binary_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_653_Two_Sum_IV_Input_is_a_BST.class b/bin/leetcodeNZ/tags/tree/easy/Tree_653_Two_Sum_IV_Input_is_a_BST.class new file mode 100644 index 0000000..1c1322f Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_653_Two_Sum_IV_Input_is_a_BST.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_700_Search_in_a_Binary_Search_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_700_Search_in_a_Binary_Search_Tree.class new file mode 100644 index 0000000..ce00be5 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_700_Search_in_a_Binary_Search_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_872_Leaf_Similar_Trees.class b/bin/leetcodeNZ/tags/tree/easy/Tree_872_Leaf_Similar_Trees.class new file mode 100644 index 0000000..29cf82c Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_872_Leaf_Similar_Trees.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_897_Increasing_Order_Search_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_897_Increasing_Order_Search_Tree.class new file mode 100644 index 0000000..5a3d81b Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_897_Increasing_Order_Search_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_938_Range_Sum_of_BST.class b/bin/leetcodeNZ/tags/tree/easy/Tree_938_Range_Sum_of_BST.class new file mode 100644 index 0000000..803a75e Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_938_Range_Sum_of_BST.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_94_Binary_Tree_Inorder_Traversal.class b/bin/leetcodeNZ/tags/tree/easy/Tree_94_Binary_Tree_Inorder_Traversal.class new file mode 100644 index 0000000..a392952 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_94_Binary_Tree_Inorder_Traversal.class differ diff --git a/bin/leetcodeNZ/tags/tree/easy/Tree_965_Univalued_Binary_Tree.class b/bin/leetcodeNZ/tags/tree/easy/Tree_965_Univalued_Binary_Tree.class new file mode 100644 index 0000000..b0c726d Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/easy/Tree_965_Univalued_Binary_Tree.class differ diff --git a/bin/leetcodeNZ/tags/tree/hard/Tree_1028_Recover_a_Tree_From_Preorder_Traversal.class b/bin/leetcodeNZ/tags/tree/hard/Tree_1028_Recover_a_Tree_From_Preorder_Traversal.class new file mode 100644 index 0000000..49a1dd3 Binary files /dev/null and b/bin/leetcodeNZ/tags/tree/hard/Tree_1028_Recover_a_Tree_From_Preorder_Traversal.class differ diff --git a/bin/leetcodeNZ/test/jj.puml b/bin/leetcodeNZ/test/jj.puml deleted file mode 100644 index 80b4f52..0000000 --- a/bin/leetcodeNZ/test/jj.puml +++ /dev/null @@ -1,20 +0,0 @@ -@startuml -:Main Admin: as Admin -(Use the application) as (Use) - -User -> (Start) -User --> (Use) - -Admin ---> (Use) - -note right of Admin : This is an example. - -note right of (Use) -A note can also -be on several lines -end note - -note "This note is connected\nto several objects." as N2 -(Start) .. N2 -N2 .. (Use) -@enduml \ No newline at end of file diff --git a/bin/leetcodeNZ/util/TreeNodePrintUtil.class b/bin/leetcodeNZ/util/TreeNodePrintUtil.class new file mode 100644 index 0000000..396ef22 Binary files /dev/null and b/bin/leetcodeNZ/util/TreeNodePrintUtil.class differ diff --git a/bin/lib/itextpdf-5.1.0.jar b/bin/lib/itextpdf-5.1.0.jar new file mode 100644 index 0000000..e84ae38 Binary files /dev/null and b/bin/lib/itextpdf-5.1.0.jar differ diff --git a/bin/test/Cat.class b/bin/test/Cat.class deleted file mode 100644 index c9d4d6a..0000000 Binary files a/bin/test/Cat.class and /dev/null differ diff --git a/bin/test/Dog.class b/bin/test/Dog.class deleted file mode 100644 index 1013b92..0000000 Binary files a/bin/test/Dog.class and /dev/null differ diff --git a/bin/test/GsonTest.class b/bin/test/GsonTest.class index 12e1bcd..758c05d 100644 Binary files a/bin/test/GsonTest.class and b/bin/test/GsonTest.class differ diff --git a/bin/test/NBTest.class b/bin/test/NBTest.class index e169197..fea8337 100644 Binary files a/bin/test/NBTest.class and b/bin/test/NBTest.class differ diff --git a/bin/test/PackageCostV4.class b/bin/test/PackageCostV4.class new file mode 100644 index 0000000..88e0755 Binary files /dev/null and b/bin/test/PackageCostV4.class differ diff --git a/bin/test/Reactor.class b/bin/test/Reactor.class index bd4ff5a..61eba1c 100644 Binary files a/bin/test/Reactor.class and b/bin/test/Reactor.class differ diff --git a/bin/test/SocketReadHandler.class b/bin/test/SocketReadHandler.class index 5d7086d..c66811e 100644 Binary files a/bin/test/SocketReadHandler.class and b/bin/test/SocketReadHandler.class differ diff --git a/bin/test/Test$1.class b/bin/test/Test$1.class index 9424fae..7906b96 100644 Binary files a/bin/test/Test$1.class and b/bin/test/Test$1.class differ diff --git a/bin/test/Test.class b/bin/test/Test.class index 16767e5..69d93dc 100644 Binary files a/bin/test/Test.class and b/bin/test/Test.class differ diff --git a/bin/test180105/ThreadPoolTestOne.class b/bin/test180105/ThreadPoolTestOne.class index 14e37fd..4d9c86c 100644 Binary files a/bin/test180105/ThreadPoolTestOne.class and b/bin/test180105/ThreadPoolTestOne.class differ diff --git a/bin/word/ReadWordDoc$NewRequirementInfo.class b/bin/word/ReadWordDoc$NewRequirementInfo.class index c84d9cd..aa84a51 100644 Binary files a/bin/word/ReadWordDoc$NewRequirementInfo.class and b/bin/word/ReadWordDoc$NewRequirementInfo.class differ diff --git a/bin/word/ReadWordDoc$RequirementInfo.class b/bin/word/ReadWordDoc$RequirementInfo.class index 0775769..1b7440e 100644 Binary files a/bin/word/ReadWordDoc$RequirementInfo.class and b/bin/word/ReadWordDoc$RequirementInfo.class differ diff --git a/bin/word/ReadWordDoc.class b/bin/word/ReadWordDoc.class index 127c323..1a54ec6 100644 Binary files a/bin/word/ReadWordDoc.class and b/bin/word/ReadWordDoc.class differ diff --git a/bin/word/Sort.class b/bin/word/Sort.class index b86ee29..7ff39fe 100644 Binary files a/bin/word/Sort.class and b/bin/word/Sort.class differ diff --git a/bin/youTap/SecondHighestNumberInArray.class b/bin/youTap/SecondHighestNumberInArray.class new file mode 100644 index 0000000..d79fab5 Binary files /dev/null and b/bin/youTap/SecondHighestNumberInArray.class differ diff --git a/bin/youtubeSrtToTxt/SrtToTxtUtil.class b/bin/youtubeSrtToTxt/SrtToTxtUtil.class index ffb4750..34b913a 100644 Binary files a/bin/youtubeSrtToTxt/SrtToTxtUtil.class and b/bin/youtubeSrtToTxt/SrtToTxtUtil.class differ diff --git a/projectFilesBackup/.idea/workspace.xml b/projectFilesBackup/.idea/workspace.xml new file mode 100644 index 0000000..e4cd58f --- /dev/null +++ b/projectFilesBackup/.idea/workspace.xml @@ -0,0 +1,732 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + project + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + 1512526474618 + + + + + + + + + + + + + + + + + + + + + + + + + + file://$PROJECT_DIR$/src/leetcode/easy/ImplementStrStr.java + 62 + + + file://$PROJECT_DIR$/src/leetcodeNZ/easy/EASY_1_Two_Sum.java + 10 + + + file://$PROJECT_DIR$/src/leetcodeNZ/easy/EASY_1_Two_Sum.java + 48 + + + file://$PROJECT_DIR$/src/leetcodeNZ/easy/EASY_1_Two_Sum.java + 88 + + + file://$PROJECT_DIR$/src/leetcodeNZ/easy/EASY_1_Two_Sum.java + 107 + + + file://$PROJECT_DIR$/src/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.java + 112 + + + file://$PROJECT_DIR$/src/leetcodeNZ/medium/MEDIUM_3_LONGEST_NO_REPEAT_C.java + 22 + + + file://$PROJECT_DIR$/src/leetcodeNZ/medium/MEDIUM_6_ZIGZAG_CONVERSION.java + 22 + + + file://$PROJECT_DIR$/src/leetcodeNZ/util/ModifiedTreeNodePrint.java + 87 + + + + + + + + + + + + + + + + + + + No facets are configured + + + + + + + + + + + + + + + 1.7 + + + + + + + + SomeTest + + + + + + + + 1.7 + + + + + + + + smack-core-4.2.2 + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/src/imagesToPDF/JpgToPdf.java b/src/imagesToPDF/JpgToPdf.java new file mode 100644 index 0000000..e75da5d --- /dev/null +++ b/src/imagesToPDF/JpgToPdf.java @@ -0,0 +1,72 @@ +package imagesToPDF; + +/** + * @author Simon-the-coder + * @date 12/12/21 6:04 PM + */ +import com.itextpdf.text.Document; +import com.itextpdf.text.Image; +import com.itextpdf.text.pdf.PdfWriter; + +import java.io.File; +import java.io.FileOutputStream; +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +public class JpgToPdf { + public static void main(String arg[]) throws Exception { + String rootPath = "/Users/simon-youtap/Documents/github/flutter-tips-and-tricks/tipsandtricks/"; + File root = new File(rootPath); + String outputFile = "flutterTipsImages.pdf"; + + Document document = new Document(); + PdfWriter.getInstance(document, new FileOutputStream(new File(root, outputFile))); + document.open(); + + File[] fa = root.listFiles(); + List imageNameList = new ArrayList<>(); + for (File file : fa) { + if (file.isDirectory()) imageNameList.add(file.getName()); + } + System.out.println("imageNameList.size() ===> " + imageNameList.size()); + Collections.sort(imageNameList); + int count = 0; + for (String imageName : imageNameList) { + + File file = new File(rootPath + imageName + "/" + imageName + ".jpg"); + if (file.exists()) { + imageName = imageName + "/" + imageName + ".jpg"; + } else { + imageName = imageName + "/" + imageName + ".jpeg"; + } + + document.newPage(); + Image image = Image.getInstance(new File(root, imageName).getAbsolutePath()); + float aspectRatio = image.getWidth() / image.getHeight(); + float scaler = ((document.getPageSize().getWidth() - document.leftMargin() - document.rightMargin()) / image.getWidth()); + if (aspectRatio >= 1.414) { + scaler = ((document.getPageSize().getHeight() - document.leftMargin() - document.rightMargin()) / image.getWidth()); + image.setRotationDegrees(90); + float scaledWidth = image.getWidth() * scaler; + document.left((document.getPageSize().getWidth() - scaledWidth) / 2); + } else { + float scaledHeight = image.getHeight() * scaler; + document.top((document.getPageSize().getHeight() - scaledHeight) / 2); + } + image.scalePercent(scaler * 100); + System.out.println("aspectRatio " + aspectRatio + " scaler " + scaler + " Current Image Name ===> " + imageName + " image.width " + image.getWidth() + " image.height " + image.getHeight()); + document.add(image); + count++; + } + System.out.println("document.getPageSize().getWidth() " + document.getPageSize().getWidth()); + System.out.println("document.getPageSize().getHeight() " + document.getPageSize().getHeight()); + System.out.println("document.leftMargin() " + document.leftMargin()); + System.out.println("document.rightMargin() " + document.rightMargin()); + System.out.println("document.topMargin() " + document.topMargin()); + System.out.println("document.bottomMargin() " + document.bottomMargin()); + + document.close(); + System.out.println("DONE ----- count = " + count); + } +} diff --git a/src/leetcode/easy/MergeTwoLists.java b/src/leetcode/easy/MergeTwoLists.java index fb8a260..637bdcf 100644 --- a/src/leetcode/easy/MergeTwoLists.java +++ b/src/leetcode/easy/MergeTwoLists.java @@ -1,13 +1,6 @@ package leetcode.easy; -class ListNode { - int val; - ListNode next; - - ListNode(int x) { - val = x; - } -} +import leetcodeNZ.model.ListNode; public class MergeTwoLists { /* @@ -15,7 +8,7 @@ public class MergeTwoLists { * @param l2: ListNode l2 is the head of the linked list * @return: ListNode head of linked list */ - public ListNode mergeTwoLists2(ListNode l1, ListNode l2) + public ListNode mergeTwoLists2(ListNode l1, ListNode l2) { if(l1 == null) return l2; if(l2 == null) return l1; diff --git a/src/leetcodeNZ/example/ModifiedTreeNodePrint.java b/src/leetcodeNZ/example/ModifiedTreeNodePrint.java new file mode 100644 index 0000000..4ff8cdf --- /dev/null +++ b/src/leetcodeNZ/example/ModifiedTreeNodePrint.java @@ -0,0 +1,243 @@ +package leetcodeNZ.example; + +/** + * this class is modified from https://prismoskills.appspot.com/lessons/Binary_Trees/Tree_printing.jsp + */ + +import java.util.LinkedList; + +/** + * @author Simon-the-coder + * @date 21/08/20 5:41 pm + */ +public class ModifiedTreeNodePrint { + + public int idata; + + public ModifiedTreeNodePrint left; + public ModifiedTreeNodePrint right; + public ModifiedTreeNodePrint parent; + + // variables needed to print the tree like a tree + int depth=0; + int level=0; + int drawPos=0; + + + /******** Functions to create a random binary search tree *********/ + + public static int RANDOM_RANGE = 1000; + + public static ModifiedTreeNodePrint createRandomIntegerTree (int numNodes) + { + RANDOM_RANGE = 10*numNodes; + + ModifiedTreeNodePrint root = new ModifiedTreeNodePrint (); + root.idata = (int)(Math.random()*RANDOM_RANGE); + + int treeSize = countNodes(root); + while (treeSize < numNodes) + { + int count = numNodes - treeSize; + while (count-- > 0) + root.insertInteger((int)(Math.random()*RANDOM_RANGE)); + treeSize = countNodes (root); + } + return root; + } + + + // Inserts a given number into the BST + void insertInteger(int data) + { + if (this.idata == data) + return; + if (this.idata < data) + { + if (this.right == null) + { + this.right = new ModifiedTreeNodePrint(); + this.right.idata = data; + this.right.parent = this; + } + else + { + this.right.insertInteger(data); + } + } + else + { + if (this.left == null) + { + this.left = new ModifiedTreeNodePrint(); + this.left.idata = data; + this.left.parent = this; + } + else + { + this.left.insertInteger(data); + } + } + } + + + + // Creates a random tree and prints it like a tree + public static void main(String[] args) + { + ModifiedTreeNodePrint root = createRandomIntegerTree(20); + root.inOrderInteger(", "); + drawTree (root); + } + + + /************ Actual functions that print the tree like a tree ********************/ + static void drawTree(ModifiedTreeNodePrint root) + { + + System.out.println("\n\nLevel order traversal of tree:"); + int depth = depth(root); + setLevels (root, 0); + + int depthChildCount[] = new int [depth+1]; + + + LinkedList q = new LinkedList (); + q.add(root.left); + q.add(root.right); + + // draw root first + root.drawPos = (int)Math.pow(2, depth-1)*H_SPREAD; + currDrawLevel = root.level; + currSpaceCount = root.drawPos; + System.out.print(getSpace(root.drawPos) + root.idata); + + while (!q.isEmpty()) + { + ModifiedTreeNodePrint ele = q.pollFirst(); + drawElement (ele, depthChildCount, depth, q); + if (ele == null) + continue; + q.add(ele.left); + q.add(ele.right); + } + System.out.println(); + } + + static int currDrawLevel = -1; + static int currSpaceCount = -1; + static final int H_SPREAD = 3; + static void drawElement(ModifiedTreeNodePrint ele, int depthChildCount[], int depth, LinkedList q) + { + if (ele == null) + return; + + if (ele.level != currDrawLevel) + { + currDrawLevel = ele.level; + currSpaceCount = 0; + System.out.println(); + for (int i=0; i<(depth-ele.level+1); i++) + { + int drawn = 0; + if (ele.parent.left != null) + { + drawn = ele.parent.drawPos - 2*i - 2; + System.out.print(getSpace(drawn) + "/"); + } + if (ele.parent.right != null) + { + int drawn2 = ele.parent.drawPos + 2*i + 2; + System.out.print(getSpace(drawn2 - drawn) + "\\"); + drawn = drawn2; + } + + ModifiedTreeNodePrint doneParent = ele.parent; + for (ModifiedTreeNodePrint sibling: q) + { + if (sibling == null) + continue; + if (sibling.parent == doneParent) + continue; + doneParent = sibling.parent; + if (sibling.parent.left != null) + { + int drawn2 = sibling.parent.drawPos - 2*i - 2; + System.out.print(getSpace(drawn2-drawn-1) + "/"); + drawn = drawn2; + } + + if (sibling.parent.right != null) + { + int drawn2 = sibling.parent.drawPos + 2*i + 2; + System.out.print(getSpace(drawn2-drawn-1) + "\\"); + drawn = drawn2; + } + } + System.out.println(); + } + } + int offset=0; + int numDigits = (int)Math.ceil(Math.log10(ele.idata)); + if (ele.parent.left == ele) + { + ele.drawPos = ele.parent.drawPos - H_SPREAD*(depth-currDrawLevel+1); + //offset = 2; + offset += numDigits/2; + } + else + { + ele.drawPos = ele.parent.drawPos + H_SPREAD*(depth-currDrawLevel+1); + //offset = -2; + offset -= numDigits; + } + + System.out.print (getSpace(ele.drawPos - currSpaceCount + offset) + ele.idata); + currSpaceCount = ele.drawPos + numDigits/2; + } + + + // Utility functions + public void inOrderInteger (String sep) + { + if (left != null) + left.inOrderInteger(sep); + System.out.print(idata + sep); + if (right != null) + right.inOrderInteger(sep); + } + + public static int depth (ModifiedTreeNodePrint n) + { + if (n == null) + return 0; + n.depth = 1 + Math.max(depth(n.left), depth(n.right)); + return n.depth; + } + + + public static int countNodes (ModifiedTreeNodePrint n) + { + if (n == null) + return 0; + return 1 + countNodes(n.left) + countNodes(n.right); + } + + static void setLevels (ModifiedTreeNodePrint r, int level) + { + if (r == null) + return; + r.level = level; + setLevels (r.left, level+1); + setLevels (r.right, level+1); + } + + static String getSpace (int i) + { + String s = ""; + while (i-- > 0) + s += " "; + return s; + } + +} diff --git a/src/leetcodeNZ/example/PrintLevelOrder.java b/src/leetcodeNZ/example/PrintLevelOrder.java new file mode 100644 index 0000000..f9ed249 --- /dev/null +++ b/src/leetcodeNZ/example/PrintLevelOrder.java @@ -0,0 +1,82 @@ +package leetcodeNZ.example; + +import leetcodeNZ.model.TreeNode; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * @author Simon-the-coder + * @date 1/05/22 10:16 AM + */ +public class PrintLevelOrder { + public static void main(String args[]){ + TreeNode n1 = new TreeNode(1, null, null); + TreeNode n2 = new TreeNode(2, n1, null); + TreeNode n4 = new TreeNode(4, null, null); + TreeNode n6 = new TreeNode(6, null, null); + TreeNode n5 = new TreeNode(5, n4, n6); + TreeNode n3 = new TreeNode(3, n2, n5); + TreeNode n10 = new TreeNode(10, null, null); + TreeNode n11 = new TreeNode(11, n10, null); + TreeNode n9 = new TreeNode(9, null, n11); + TreeNode n8 = new TreeNode(8, null, n9); + TreeNode n7 = new TreeNode(7, n3, n8); + + printLevelOrderDFS(n7); + printLevelOrderBFS(n7); + } + + public static void printLevelOrderBFS(TreeNode root){ + Queue queue = new LinkedList<>(); + queue.add(root); + int currentLevelCount = 1; + int nextLevelCount = 0; + + while(!queue.isEmpty()){ + TreeNode n = queue.remove(); + System.out.print(n.val + " "); + if(n.left != null){ + queue.add(n.left); + nextLevelCount++; + } + if(n.right != null){ + queue.add(n.right); + nextLevelCount++; + } + currentLevelCount--; + if(currentLevelCount == 0){ + System.out.println(""); + currentLevelCount = nextLevelCount; + nextLevelCount = 0; + } + } + } + + public static void printLevelOrderDFS(TreeNode root){ + int height = maxHeight(root); + for( int i = 0; i < height; i++){ + printLevel(root, i); + System.out.println(); + } + } + + public static void printLevel(TreeNode node, int level){ + if(node == null) + return; + if(level == 0){ + System.out.print(node.val+" "); + }else{ + printLevel(node.left, level - 1); + printLevel(node.right, level - 1); + } + + + } + + public static int maxHeight(TreeNode root){ + if (root == null) + return 0; + return 1 + Math.max(maxHeight(root.left), maxHeight(root.right)); + } +} diff --git a/src/leetcodeNZ/example/Tree.java b/src/leetcodeNZ/example/Tree.java new file mode 100644 index 0000000..4f99cea --- /dev/null +++ b/src/leetcodeNZ/example/Tree.java @@ -0,0 +1,255 @@ +package leetcodeNZ.example; +import java.io.*; +import java.util.*; + +/** + * @author Simon-the-coder + * @date 1/05/22 10:46 AM + */ + +class Node { + int key; + Node leftChild, rightChild; + + public Node(int data){ + key = data; + leftChild = rightChild = null; + } +} + +//class Node +//{ +// public int item; +// public Node leftChild; +// public Node rightChild; +// public void displayNode() +// { +// System.out.print("["); +// System.out.print(item); +// System.out.print("]"); +// } +//} + +class StackNode +{ + public Node item; + public StackNode next; + public StackNode(Node val) + { + item = val; + } + +} +class LinkedListStack +{ + private StackNode first; + public LinkedListStack() + { + first = null; + } + public boolean isEmpty() + { + return (first==null); + } + public void insert(Node key)//inserts at beginning of list + { + StackNode newLLNode = new StackNode(key); + newLLNode.next = first; + first = newLLNode; + } + public Node delete()//deletes at beginning of list + { + StackNode temp = first; + first = first.next; + return temp.item; + } +} +class Stack +{ + private LinkedListStack listObj; + public Stack() + { + listObj = new LinkedListStack(); + } + public void push(Node num) + { + listObj.insert(num); + } + public Node pop() + { + return listObj.delete(); + } + public boolean isEmpty() + { + return listObj.isEmpty(); + } +} + +class Tree +{ + public Node root; + public Tree() + { root = null; } + public Node returnRoot() + { + return root; + } + + // insert a node in BST + void insert(int key) { + root = insert_Recursive(root, key); + } + + //recursive insert function + Node insert_Recursive(Node root, int key) { + //tree is empty + if (root == null) { + root = new Node(key); + return root; + } + //traverse the tree + if (key < root.key) //insert in the left subtree + root.leftChild = insert_Recursive(root.leftChild, key); + else if (key > root.key) //insert in the right subtree + root.rightChild = insert_Recursive(root.rightChild, key); + // return pointer + return root; + } + + public void preOrder(Node root) + { + if(root != null) + { + System.out.print(root.key + " "); + preOrder(root.leftChild); + preOrder(root.rightChild); + } + } + + public void inOrder(Node root) + { + if(root != null) + { + inOrder(root.leftChild); + System.out.print(root.key + " "); + inOrder(root.rightChild); + } + } + public void postOrder(Node root) + { + if(root != null) + { + postOrder(root.leftChild); + postOrder(root.rightChild); + System.out.print(root.key + " "); + } + } + + public void byLevel(Node root){ + Queue level = new LinkedList<>(); + level.add(root); + + while(!level.isEmpty()){ + Node node = level.poll(); + System.out.print(node.key + " "); + if(node.leftChild!= null) + level.add(node.leftChild); + if(node.rightChild!= null) + level.add(node.rightChild); + } + } + + public void displayTree() + { + Stack globalStack = new Stack(); + globalStack.push(root); + int emptyLeaf = 32; + boolean isRowEmpty = false; + System.out.println("****......................................................****"); + while(isRowEmpty==false) + { + + Stack localStack = new Stack(); + isRowEmpty = true; + for(int j=0; j 0) + root.insertInteger((int)(Math.random()*RANDOM_RANGE)); + treeSize = countNodes (root); + } + return root; + } + + + // Inserts a given number into the BST + void insertInteger(int data) + { + if (this.idata == data) + return; + if (this.idata < data) + { + if (this.right == null) + { + this.right = new TreeNodePrint(); + this.right.idata = data; + this.right.parent = this; + } + else + { + this.right.insertInteger(data); + } + } + else + { + if (this.left == null) + { + this.left = new TreeNodePrint(); + this.left.idata = data; + this.left.parent = this; + } + else + { + this.left.insertInteger(data); + } + } + } + + + + // Creates a random tree and prints it like a tree + public static void main(String[] args) + { + TreeNodePrint root = createRandomIntegerTree(20); + root.inOrderInteger(", "); + drawTree (root); + } + + + /************ Actual functions that print the tree like a tree ********************/ + static void drawTree(TreeNodePrint root) + { + + System.out.println("\n\nLevel order traversal of tree:"); + int depth = depth(root); + setLevels (root, 0); + + int depthChildCount[] = new int [depth+1]; + + + LinkedList q = new LinkedList (); + q.add(root.left); + q.add(root.right); + + // draw root first + root.drawPos = (int)Math.pow(2, depth-1)*H_SPREAD; + currDrawLevel = root.level; + currSpaceCount = root.drawPos; + System.out.print(getSpace(root.drawPos) + root.idata); + + while (!q.isEmpty()) + { + TreeNodePrint ele = q.pollFirst(); + drawElement (ele, depthChildCount, depth, q); + if (ele == null) + continue; + q.add(ele.left); + q.add(ele.right); + } + System.out.println(); + } + + static int currDrawLevel = -1; + static int currSpaceCount = -1; + static final int H_SPREAD = 3; + static void drawElement(TreeNodePrint ele, int depthChildCount[], int depth, LinkedList q) + { + if (ele == null) + return; + + if (ele.level != currDrawLevel) + { + currDrawLevel = ele.level; + currSpaceCount = 0; + System.out.println(); + for (int i=0; i<(depth-ele.level+1); i++) + { + int drawn = 0; + if (ele.parent.left != null) + { + drawn = ele.parent.drawPos - 2*i - 2; + System.out.print(getSpace(drawn) + "/"); + } + if (ele.parent.right != null) + { + int drawn2 = ele.parent.drawPos + 2*i + 2; + System.out.print(getSpace(drawn2 - drawn) + "\\"); + drawn = drawn2; + } + + TreeNodePrint doneParent = ele.parent; + for (TreeNodePrint sibling: q) + { + if (sibling == null) + continue; + if (sibling.parent == doneParent) + continue; + doneParent = sibling.parent; + if (sibling.parent.left != null) + { + int drawn2 = sibling.parent.drawPos - 2*i - 2; + System.out.print(getSpace(drawn2-drawn-1) + "/"); + drawn = drawn2; + } + + if (sibling.parent.right != null) + { + int drawn2 = sibling.parent.drawPos + 2*i + 2; + System.out.print(getSpace(drawn2-drawn-1) + "\\"); + drawn = drawn2; + } + } + System.out.println(); + } + } + int offset=0; + int numDigits = (int)Math.ceil(Math.log10(ele.idata)); + if (ele.parent.left == ele) + { + ele.drawPos = ele.parent.drawPos - H_SPREAD*(depth-currDrawLevel+1); + //offset = 2; + offset += numDigits/2; + } + else + { + ele.drawPos = ele.parent.drawPos + H_SPREAD*(depth-currDrawLevel+1); + //offset = -2; + offset -= numDigits; + } + + System.out.print (getSpace(ele.drawPos - currSpaceCount + offset) + ele.idata); + currSpaceCount = ele.drawPos + numDigits/2; + } + + + // Utility functions + public void inOrderInteger (String sep) + { + if (left != null) + left.inOrderInteger(sep); + System.out.print(idata + sep); + if (right != null) + right.inOrderInteger(sep); + } + + public static int depth (TreeNodePrint n) + { + if (n == null) + return 0; + n.depth = 1 + Math.max(depth(n.left), depth(n.right)); + return n.depth; + } + + + public static int countNodes (TreeNodePrint n) + { + if (n == null) + return 0; + return 1 + countNodes(n.left) + countNodes(n.right); + } + + static void setLevels (TreeNodePrint r, int level) + { + if (r == null) + return; + r.level = level; + setLevels (r.left, level+1); + setLevels (r.right, level+1); + } + + static String getSpace (int i) + { + String s = ""; + while (i-- > 0) + s += " "; + return s; + } + +} diff --git a/src/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.java b/src/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.java index 4fa0b2d..9136e94 100644 --- a/src/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.java +++ b/src/leetcodeNZ/medium/MEDIUM_2_Add_Two_Numbers.java @@ -1,5 +1,9 @@ package leetcodeNZ.medium; +import java.util.Stack; + +import leetcodeNZ.model.ListNode; + /** * Created by hanshihui on 16/01/19. * @@ -16,102 +20,125 @@ Explanation: 342 + 465 = 807. */ -class ListNode { - int val; - ListNode next; - ListNode(int x) { val = x; } -} - -public class Medium_2_Add_Two_Numbers { - public ListNode addTwoNumbers(ListNode l1, ListNode l2) { - - String str1 = ""; - String str2 = ""; - - while (l1 != null) - { - str1 += l1.val; - l1 = l1.next; +class Medium_2_Add_Two_Numbers { + +// public ListNode addTwoNumbers(ListNode node1, ListNode node2) { +// long listNodeToInt1 = 0; +// long listNodeToInt2 = 0; +// long index = 1; +// while (node1 != null) { +// listNodeToInt1 += node1.val * index; +// node1 = node1.next; +// index *= 10; +// } +// index = 1; +// while (node2 != null) { +// listNodeToInt2 += node2.val * index; +// System.out.println("listNodeToInt2 " + listNodeToInt2 + " node2.val " + node2.val); +// System.out.println("listNodeToInt2 " + Long.MAX_VALUE + " index " + index + " node2.val * index " + (node2.val * index)); +// node2 = node2.next; +// index *= 10; +// } +// +// long sum = listNodeToInt1 + listNodeToInt2; +// System.out.println("listNodeToInt1 " + listNodeToInt1); +// System.out.println("listNodeToInt2 " + listNodeToInt2); +// System.out.println("sum " + sum); +// if (sum == 0) return new ListNode(0); +// ListNode newNode = null; +// ListNode tempNode; +// for (long i = sum; i > 0;) { +// int value = (int) (i % 10); +// if(newNode == null) { +// newNode = new ListNode(value); +// } else { +// tempNode = newNode; +// while (tempNode.next != null) { +// tempNode = tempNode.next; +// } +// tempNode.next = new ListNode(value); +// } +// i = i / 10; +// } +// return newNode; +// } + + public ListNode addTwoNumbers(ListNode node1, ListNode node2) { + Stack stack1 = new Stack<>(); + Stack stack2 = new Stack<>(); + while (node1 != null) { + stack1.push(node1.val); + node1 = node1.next; } - while (l2 != null) - { - str2 += l2.val; - l2 = l2.next; + while (node2 != null) { + stack2.push(node2.val); + node2 = node2.next; } - - str2 = String.valueOf(Integer.parseInt(str1) + Integer.parseInt(str2)); - - ListNode node = null; - int strLength = str2.length(); - for (int i = 0; i < strLength; i++) - { - String singleNum = str2.substring(strLength -1 - i, strLength - i); - Integer curVal = Integer.parseInt(singleNum); - if(node == null) - { - node = new ListNode(curVal); + System.out.println("stack1 " + stack1); + System.out.println("stack2 " + stack2); + ListNode newNode = null; + ListNode tempNode; + System.out.println("====================="); + int value1 = 0; + int value2 = 0; + while (!stack1.isEmpty() && !stack2.isEmpty()) { + + if (!stack1.isEmpty()) { + value1 += stack1.pop(); } - else - { - ListNode tempNode = node; - while (tempNode.next != null) - { - tempNode = node.next; - } - - tempNode.next = new ListNode(curVal); + System.out.println("value1 " + value1); + if (!stack2.isEmpty()) { + value2 += stack2.pop(); } - } - return node; - } - - private ListNode insertNode(int[] arr) - { - if(arr == null || arr.length <= 0) - { - return null; - } - - ListNode node = null; - ListNode tempNode = null; - for(int i : arr) - { - if(node == null) - { - node = new ListNode(i); + System.out.println("value2 " + value2); + int newNodeValue = value1 + value2; + if (newNodeValue < 10) { + value1 = 0; + value2 = 0; + } else { + value1 = 1; + value2 = 1; + newNodeValue %= 10; } - else - { - tempNode = node; - while (tempNode.next != null) - { + System.out.println("newNodeValue " + newNodeValue); + if(newNode == null) { + newNode = new ListNode(newNodeValue); + } else { + tempNode = newNode; + while (tempNode.next != null) { tempNode = tempNode.next; } - - tempNode.next = new ListNode(i); + tempNode.next = new ListNode(newNodeValue); } } - - return node; + return newNode; } public static void main(String[] args) { -// int[] array1 = {2,4,3}; -// int[] array2 = {5,6,4}; - int[] array1 = {1,8}; - int[] array2 = {0}; + int[] array1 = {2,4,3}; + int[] array2 = {5,6,4}; +// int[] array1 = {0}; +// int[] array2 = {0}; +// int[] array1 = {5}; +// int[] array2 = {3}; +// int[] array1 = {9,9,9,9,9,9,9}; +// int[] array2 = {9,9,9,9}; +// int[] array1 = {2,4,9}; +// int[] array2 = {5,6,4,9}; +// int[] array1 = {9}; +// int[] array2 = {1,9,9,9,9,9,9,9,9,9}; Medium_2_Add_Two_Numbers m = new Medium_2_Add_Two_Numbers(); - ListNode node2 = m.insertNode(array1); + ListNode node2 = ListNode.insertNode(array1); - ListNode node5 = m.insertNode(array2); + ListNode node5 = ListNode.insertNode(array2); ListNode resultNode = m.addTwoNumbers(node2,node5); - + System.out.println("&&&&&&&&&&&&&&&&&"); while (resultNode != null) { - System.out.println(resultNode.val); + System.out.print(resultNode.val + " "); resultNode = resultNode.next; } } diff --git a/src/leetcodeNZ/medium/Tree_94_Binary_Tree_Inorder_Traversal.java b/src/leetcodeNZ/medium/Tree_94_Binary_Tree_Inorder_Traversal.java deleted file mode 100644 index 8720f1f..0000000 --- a/src/leetcodeNZ/medium/Tree_94_Binary_Tree_Inorder_Traversal.java +++ /dev/null @@ -1,124 +0,0 @@ -package leetcodeNZ.medium; - -import java.util.ArrayList; -import java.util.List; -import java.util.Stack; - -/* - * Given a binary tree, return the inorder traversal of its nodes' values. - - Example: - - Input: [1,null,2,3] - 1 - \ - 2 - / - 3 - - Output: [1,3,2] - Follow up: Recursive solution is trivial, could you do it iteratively? - */ - -public class Tree_94_Binary_Tree_Inorder_Traversal { - - private String stackToString(Stack s) { - String result = ""; - - for(int i = 0; i < s.size(); i++) { - TreeNode node = s.get(i); - result += node.val + " "; - } - return result; - } - - public List inorderTraversal(TreeNode root) { - List list = new ArrayList<>(); - Stack s = new Stack(); - TreeNode currentNode = root; - boolean done = false; - int index = 0; - while (!done) { - System.out.println("this is-------------000----------- index " + index); - if (currentNode != null) { - System.out.println("this is-----------1111------------- currentNode.val " + currentNode.val); - s.push(currentNode); - System.out.println("this is-----------2222------------- stack " + stackToString(s)); - currentNode = currentNode.left; - if(currentNode == null) { - System.out.println("this is-----------4444------------- currentNode.left is null "); - } else { - System.out.println("this is-----------5555------------- currentNode.left.val " + currentNode.val); - } - - } else { - if (s.isEmpty()) { - done = true; - } else { - currentNode = s.pop(); - System.out.println("this is-----------6666------------- currentNode.val " + currentNode.val + " stack " + stackToString(s)); - list.add(currentNode.val); - currentNode = currentNode.right; - if(currentNode == null) { - System.out.println("this is-----------7777------------- currentNode.right is null "); - } else { - System.out.println("this is-----------8888------------- currentNode.right.val " + currentNode.val); - } - } - } - System.out.println("############################################################################################################ " + stackToString(s)); - index++; - } - return list; - } - - public static void main(String[] args) { - TreeNode t1 = new TreeNode(1); - TreeNode t2 = new TreeNode(2); - TreeNode t3 = new TreeNode(3); - TreeNode t4 = new TreeNode(4); - TreeNode t5 = new TreeNode(5); - TreeNode t6 = new TreeNode(6); - TreeNode t7 = new TreeNode(7); - TreeNode t8 = new TreeNode(8); - TreeNode t9 = new TreeNode(9); - TreeNode t10 = new TreeNode(10); - TreeNode t11 = new TreeNode(11); - t1.left = t2; - t1.right = t3; - t2.left = t4; - t2.right = t5; - t3.left = t6; - t3.right = t7; - t4.left = t8; - t4.right = t9; - t5.left = t10; - t5.right = t11; - - Tree_94_Binary_Tree_Inorder_Traversal obj = new Tree_94_Binary_Tree_Inorder_Traversal(); - List list = obj.inorderTraversal(t1); - System.out.println(list); - } - -} - -//Definition for a binary tree node. -class TreeNode { - int val; - TreeNode left; - TreeNode right; - - TreeNode() { - - } - - TreeNode(int val) { - this.val = val; - } - - TreeNode(int val, TreeNode left, TreeNode right) { - this.val = val; - this.left = left; - this.right = right; - } -} diff --git a/src/leetcodeNZ/model/ListNode.java b/src/leetcodeNZ/model/ListNode.java new file mode 100644 index 0000000..9cdfc77 --- /dev/null +++ b/src/leetcodeNZ/model/ListNode.java @@ -0,0 +1,51 @@ +package leetcodeNZ.model; + +public class ListNode { + public int val; + public ListNode next; + + public ListNode(int x) { + val = x; + } + + public static void printLinedList(ListNode node, String tag) { + ListNode tempNewHead = node; + System.out.print(tag + ": "); + while (tempNewHead != null) { + System.out.print(tempNewHead.val + " -> "); + tempNewHead = tempNewHead.next; + } + System.out.print("null"); + System.out.println(); + } + + public static ListNode insertNode(int[] arr) + { + if(arr == null || arr.length <= 0) + { + return null; + } + + ListNode node = null; + ListNode tempNode = null; + for(int i : arr) + { + if(node == null) + { + node = new ListNode(i); + } + else + { + tempNode = node; + while (tempNode.next != null) + { + tempNode = tempNode.next; + } + + tempNode.next = new ListNode(i); + } + } + + return node; + } +} \ No newline at end of file diff --git a/src/leetcodeNZ/model/TreeNode.java b/src/leetcodeNZ/model/TreeNode.java new file mode 100644 index 0000000..b829003 --- /dev/null +++ b/src/leetcodeNZ/model/TreeNode.java @@ -0,0 +1,47 @@ +/** + * + */ +package leetcodeNZ.model; + +import java.util.LinkedList; +import java.util.Queue; + +/** + * @author simonhan + * 16 Aug 2020 + */ +//Definition for a binary tree node. +public class TreeNode { + public Integer val; + public TreeNode left; + public TreeNode right; + + public TreeNode(Integer val) { + this.val = val; + } + + public TreeNode(Integer val, TreeNode left, TreeNode right) { + this.val = val; + this.left = left; + this.right = right; + } + + public static TreeNode fromArray(Integer[] tree) { + if (tree == null || tree.length == 0) return null; + TreeNode root = new TreeNode(tree[0]); + Queue q = new LinkedList<>(); + q.add(root); + int i = 1; + while (i < tree.length) { + TreeNode node = q.peek(); + if (node != null) { + node.left = tree[i] == null ? null : new TreeNode(tree[i]); i++; if (i > (tree.length - 1)) break; + node.right = tree[i] == null ? null : new TreeNode(tree[i]); i++; if (i > (tree.length - 1)) break; + if (node.left != null) q.add(node.left); + if (node.right != null) q.add(node.right); + } + q.remove(node); + } + return root; + } +} diff --git a/src/leetcodeNZ/tags/array/easy/Array_27_Remove_Element.java b/src/leetcodeNZ/tags/array/easy/Array_27_Remove_Element.java new file mode 100644 index 0000000..b076563 --- /dev/null +++ b/src/leetcodeNZ/tags/array/easy/Array_27_Remove_Element.java @@ -0,0 +1,12 @@ +package leetcodeNZ.tags.array.easy; + +public class Array_27_Remove_Element { + public int removeElement(int[] nums, int val) { + return 0; + } + + public static void main(String[] args) { + Array_27_Remove_Element object = new Array_27_Remove_Element(); + object.removeElement(null, 1); + } +} diff --git a/src/leetcodeNZ/tags/array/hard/Array_4_Median_of_Two_Sorted_Arrays.java b/src/leetcodeNZ/tags/array/hard/Array_4_Median_of_Two_Sorted_Arrays.java new file mode 100644 index 0000000..9934b17 --- /dev/null +++ b/src/leetcodeNZ/tags/array/hard/Array_4_Median_of_Two_Sorted_Arrays.java @@ -0,0 +1,91 @@ +package leetcodeNZ.tags.array.hard; + +/** + * @author Simon-the-coder + * @date 4/10/20 12:44 pm + * @TO_DO + */ + +import java.lang.reflect.Array; +import java.text.DecimalFormat; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.LinkedList; +import java.util.List; + +/** + * Given two sorted arrays nums1 and nums2 of size m and n respectively, return the median of the two sorted arrays. + * + * Follow up: The overall run time complexity should be O(log (m+n)). + * + * + * + * Example 1: + * + * Input: nums1 = [1,3], nums2 = [2] + * Output: 2.00000 + * Explanation: merged array = [1,2,3] and median is 2. + * + * Example 2: + * + * Input: nums1 = [1,2], nums2 = [3,4] + * Output: 2.50000 + * Explanation: merged array = [1,2,3,4] and median is (2 + 3) / 2 = 2.5. + * + * Example 3: + * + * Input: nums1 = [0,0], nums2 = [0,0] + * Output: 0.00000 + * + * Example 4: + * + * Input: nums1 = [], nums2 = [1] + * Output: 1.00000 + * + * Example 5: + * + * Input: nums1 = [2], nums2 = [] + * Output: 2.00000 + * + * + * Constraints: + * + * nums1.length == m + * nums2.length == n + * 0 <= m <= 1000 + * 0 <= n <= 1000 + * 1 <= m + n <= 2000 + * -1000000 <= nums1[i], nums2[i] <= 1000000 + */ +public class Array_4_Median_of_Two_Sorted_Arrays { + + public double findMedianSortedArrays(int[] nums1, int[] nums2) { + double result = 0; + List list = new ArrayList<>(); + int num1Length = nums1.length; + int num2Length = nums2.length; + if (num1Length == 0) Collections.addAll(list, nums2); + if (num2Length == 0) Collections.addAll(list, nums1); + if (num1Length > 0 && num2Length > 0) { + for (int i = 0; i < num1Length; i++) { + int tempNum1Item = nums1[i]; + boolean isInsert = false; + for (int j = 0; j < num2Length; j++) { + int tempNum2Item = nums2[j]; + if (tempNum2Item < tempNum1Item) { + + } + } + } + } + return result; + } + + public static void main(String[] args) { + int num1[] = {1, 2}; + int num2[] = {3, 4}; + Array_4_Median_of_Two_Sorted_Arrays object = new Array_4_Median_of_Two_Sorted_Arrays(); + System.out.println(object.findMedianSortedArrays(num1, num2)); + } +} diff --git a/src/leetcodeNZ/tags/array/medium/Array_11_Container_With_Most_Water.java b/src/leetcodeNZ/tags/array/medium/Array_11_Container_With_Most_Water.java new file mode 100644 index 0000000..66c7bd6 --- /dev/null +++ b/src/leetcodeNZ/tags/array/medium/Array_11_Container_With_Most_Water.java @@ -0,0 +1,43 @@ +package leetcodeNZ.tags.array.medium; + +public class Array_11_Container_With_Most_Water { + + +// System.out.println("i " + i + " j " + j + " areaHeight " + areaHeight + " areaWidth " + areaWidth + " area " + area); + +// public int maxArea(int[] height) { +// int maxArea = 0; +// for (int i = height.length - 1; i > 0 ; i--) { +// for (int j = 0; j < i; j++) { +// int areaHeight = Math.min(height[i], height[j]); +// int areaWidth = i - j; +// int area = areaHeight * areaWidth; +// if (area > maxArea) maxArea = area; +// } +// } +// return maxArea; +// } + + public int maxArea(int[] height) { + int maxArea = 0; +// for (int i = height.length - 1; i > 0 ; i--) { +// for (int j = 0; j < i; j++) { +// int areaHeight = Math.min(height[i], height[j]); +// int areaWidth = i - j; +// int area = areaHeight * areaWidth; +// if (area > maxArea) maxArea = area; +// } +// } + for (int i = 0; i < height.length; i++) { + + } + return maxArea; + } + + public static void main(String[] args) { + int[] height = {1,8,6,2,5,4,8,3,7}; +// int[] height = {1,1}; + Array_11_Container_With_Most_Water object = new Array_11_Container_With_Most_Water(); + System.out.println(object.maxArea(height)); + } +} diff --git a/src/leetcodeNZ/tags/array/medium/Array_15_3Sum.java b/src/leetcodeNZ/tags/array/medium/Array_15_3Sum.java new file mode 100644 index 0000000..d98dcae --- /dev/null +++ b/src/leetcodeNZ/tags/array/medium/Array_15_3Sum.java @@ -0,0 +1,12 @@ +package leetcodeNZ.tags.array.medium; + +import java.util.List; + +public class Array_15_3Sum { + + public List> threeSum(int[] nums) { + return null; + } + + +} diff --git a/src/leetcodeNZ/tags/dynamicProgramming/DP_1137_N_th_Tribonacci_Number.java b/src/leetcodeNZ/tags/dynamicProgramming/DP_1137_N_th_Tribonacci_Number.java new file mode 100644 index 0000000..e56b13d --- /dev/null +++ b/src/leetcodeNZ/tags/dynamicProgramming/DP_1137_N_th_Tribonacci_Number.java @@ -0,0 +1,30 @@ +package leetcodeNZ.tags.dynamicProgramming; + +import java.util.HashMap; +import java.util.Map; + +public class DP_1137_N_th_Tribonacci_Number { + private Map resultMap; + public int tribonacci(int n) { + if (resultMap == null) resultMap = new HashMap<>(); + if (resultMap.containsKey(n)) return resultMap.get(n); + if (n == 0 || n == 1) { + resultMap.put(n, n); + return n; + } + if (n == 2) { + resultMap.put(n, 1); + return 1; + } + int result = tribonacci(n - 1) + tribonacci(n - 2) + tribonacci(n - 3); + resultMap.put(n, result); + return result; + } + + public static void main(String[] args) { + DP_1137_N_th_Tribonacci_Number obj = new DP_1137_N_th_Tribonacci_Number(); + for (int i = 0; i < 38; i++) { + System.out.println(i + "====>>> " +obj.tribonacci(i)); + } + } +} diff --git a/src/leetcodeNZ/tags/dynamicProgramming/DP_509_Fibonacci_Number.java b/src/leetcodeNZ/tags/dynamicProgramming/DP_509_Fibonacci_Number.java new file mode 100644 index 0000000..2332ef8 --- /dev/null +++ b/src/leetcodeNZ/tags/dynamicProgramming/DP_509_Fibonacci_Number.java @@ -0,0 +1,8 @@ +package leetcodeNZ.tags.dynamicProgramming; + +public class DP_509_Fibonacci_Number { + public int fib(int n) { + if (n == 0 || n == 1) return n; + else return fib(n - 1) + fib(n -2); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer.java new file mode 100644 index 0000000..f419fd8 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer.java @@ -0,0 +1,36 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer { + + private int dValue = 0; + private int count = 0; + private void traversal(ListNode head) { + if (head == null) return; + traversal(head.next); + int temp = 1; + for (int i = 0; i < count; i++) { + temp *= 2 * head.val; + } + dValue += temp * head.val; + count++; + } + + public int getDecimalValue(ListNode head) { + traversal(head); + return dValue; + } + + public static void main(String[] args) { + +// int[] array = {1, 0, 1}; +// int[] array = {1, 1, 1}; +// int[] array = {0}; + int[] array = {1, 0, 1, 1}; +// int[] array = {1,2,3}; + ListNode node = ListNode.insertNode(array); + LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer object = new LinkedList_1290_Convert_Binary_Number_in_a_Linked_List_to_Integer(); + System.out.println(object.getDecimalValue(node)); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_203_Remove_Linked_List_Elements.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_203_Remove_Linked_List_Elements.java new file mode 100644 index 0000000..8945bb9 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_203_Remove_Linked_List_Elements.java @@ -0,0 +1,72 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_203_Remove_Linked_List_Elements { + + + +// public ListNode removeElements(ListNode head, int val) { +// ListNode newHead = head; +// while (head != null) { +// ListNode.printLinedList(head, "current node"); +// if (head.next != null && head.next.val == val) { +// if (head.next.next != null) { +// ListNode.printLinedList(head, "=------111------>"); +// ListNode newNext = head; +// head.next = newNext.next.next; +// ListNode.printLinedList(newNext, "=-----2222------->"); +//// head = ; +// ListNode.printLinedList(head, "8==============?"); +// } else { +// System.out.println("3333333"); +// head = head.next; +// } +// } else if(head.val == val) { +// System.out.println("4444444"); +// newHead = head.next; +// head = newHead; +// } else { +// System.out.println("555555"); +// head = head.next; +// } +// } +// return newHead; +// } + +// public ListNode removeElements(ListNode head, int val) { +// ListNode newHead = head; +// while (head != null) { +// if (head.next!=null && head.next.val == val) { +// ListNode tempNode = head.next.next; +// head.next = tempNode; +// } else { +// head = head.next; +// } +// } +// if(newHead != null && newHead.val == val) { +// ListNode tempNewHead = newHead.next; +// newHead = tempNewHead; +// } +// return newHead; +// } + + public ListNode removeElements(ListNode head, int val) { + if(head == null) return null; + ListNode next = removeElements(head.next, val); + if(head.val == val) return next; + head.next = next; + return head; + } + + public static void main(String[] args) { + int[] array = {1,2,3,4,5,4}; +// int[] array = {7,7,7,7,7}; + ListNode node = ListNode.insertNode(array); + LinkedList_203_Remove_Linked_List_Elements object = new LinkedList_203_Remove_Linked_List_Elements(); + ListNode.printLinedList(node, "original node"); + ListNode newNode = object.removeElements(node, 4); + System.out.println("**------------------------------**"); + ListNode.printLinedList(newNode, "newNode"); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_206_Reverse_Linked_List.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_206_Reverse_Linked_List.java new file mode 100644 index 0000000..d57be06 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_206_Reverse_Linked_List.java @@ -0,0 +1,55 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import java.util.ArrayList; +import java.util.List; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_206_Reverse_Linked_List { + +// public ListNode reverseList(ListNode head) { +// List list = new ArrayList<>(); +// ListNode tempNode = head; +// while (tempNode != null) { +// ListNode curNode = tempNode; +// tempNode = tempNode.next; +// curNode.next = null; +// list.add(curNode); +// } +// if (list.isEmpty()) return null; +// else { +// ListNode newNode = list.get(list.size() - 1); +// tempNode = newNode; +// for (int i = list.size() - 2; i >= 0; i--) { +// newNode.next = list.get(i); +// newNode = newNode.next; +// } +// return tempNode; +// } +// } + + private ListNode reverseListInt(ListNode head, ListNode newHead) { + ListNode.printLinedList(newHead, "new head"); + if (head == null) + return newHead; + ListNode.printLinedList(head, "head"); + ListNode next = head.next; + head.next = newHead; + return reverseListInt(next, head); + } + + public ListNode reverseList(ListNode head) { + /* recursive solution */ + return reverseListInt(head, null); + } + + public static void main(String[] args) { + int[] array = {1,2,3,4,5}; + ListNode node = ListNode.insertNode(array); + LinkedList_206_Reverse_Linked_List object = new LinkedList_206_Reverse_Linked_List(); + ListNode.printLinedList(node, "original node"); + ListNode reverseNode = object.reverseList(node); + System.out.println("**------------------------------**"); + ListNode.printLinedList(reverseNode, "reversed node"); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_237_Delete_Node_in_a_Linked_List.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_237_Delete_Node_in_a_Linked_List.java new file mode 100644 index 0000000..91c8d05 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_237_Delete_Node_in_a_Linked_List.java @@ -0,0 +1,26 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_237_Delete_Node_in_a_Linked_List { // this is not a good question :) + public void deleteNode(ListNode node) { + + } + + public static void main(String[] args) { + int[] array = {1,2,3,4,5}; + ListNode node = ListNode.insertNode(array); + + ListNode tempNode = node; + while (tempNode != null) { + if (tempNode.val == 3) { +// if (tempNode.next ) + } + tempNode = tempNode.next; + } + + + LinkedList_237_Delete_Node_in_a_Linked_List object = new LinkedList_237_Delete_Node_in_a_Linked_List(); + object.deleteNode(node); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_705_Design_HashSet.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_705_Design_HashSet.java new file mode 100644 index 0000000..493cb65 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_705_Design_HashSet.java @@ -0,0 +1,51 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_705_Design_HashSet { + + + + public LinkedList_705_Design_HashSet() { } + + private ListNode node; + public void add(int key) { + if (node == null) node = new ListNode(key); + else { + ListNode tempNode = node; + tempNode.next = new ListNode(key); + node = tempNode; + } + } + + private ListNode removeElement(ListNode head, int val) { + if(head == null) return null; + ListNode next = removeElement(head.next, val); + if(head.val == val) return next; + head.next = next; + return head; + } + + public void remove(int key) { + if (node == null) return; + node = removeElement(node, key); + } + + public boolean contains(int key) { + ListNode tempNode = node; + while (tempNode != null) { + if (tempNode.val == key) { + return true; + } + } + return false; + } + + public static void main(String[] args) { + LinkedList_705_Design_HashSet obj = new LinkedList_705_Design_HashSet(); + obj.add(1); + boolean param_3 = obj.contains(1); + System.out.println(param_3); + obj.remove(1); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_83_Remove_Duplicates_from_Sorted_List.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_83_Remove_Duplicates_from_Sorted_List.java new file mode 100644 index 0000000..ce5d7f0 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_83_Remove_Duplicates_from_Sorted_List.java @@ -0,0 +1,24 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_83_Remove_Duplicates_from_Sorted_List { + public ListNode deleteDuplicates(ListNode head) { + if (head == null) return null; + ListNode next = deleteDuplicates(head.next); + if (next != null && head.val == next.val) head.next = next.next; + return head; + } + + public static void main(String[] args) { +// int[] array = {1,1,1,2,2,3,3,3}; + int[] array = {5,1,1}; +// int[] array = {7,7,7,7,7}; + ListNode node = ListNode.insertNode(array); + LinkedList_83_Remove_Duplicates_from_Sorted_List object = new LinkedList_83_Remove_Duplicates_from_Sorted_List(); + ListNode.printLinedList(node, "original node"); + ListNode newNode = object.deleteDuplicates(node); + System.out.println("**------------------------------**"); + ListNode.printLinedList(newNode, "newNode"); + } +} diff --git a/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_876_Middle_of_the_Linked_List.java b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_876_Middle_of_the_Linked_List.java new file mode 100644 index 0000000..a0e8a15 --- /dev/null +++ b/src/leetcodeNZ/tags/linkedlist/easy/LinkedList_876_Middle_of_the_Linked_List.java @@ -0,0 +1,36 @@ +package leetcodeNZ.tags.linkedlist.easy; + +import leetcodeNZ.model.ListNode; + +public class LinkedList_876_Middle_of_the_Linked_List { + + public ListNode middleNode(ListNode head) { + if (head!= null && head.next == null) return head; + ListNode tempNode = null; + ListNode copiedHead = head; + double loopedIndex = 0, middleIndex, tempIndex = 0; + while (head != null) { + loopedIndex++; + middleIndex = loopedIndex % 2 == 1 ? Math.floor(loopedIndex / 2) : Math.ceil(loopedIndex / 2); + if (tempIndex != middleIndex && copiedHead != null) { + tempNode = copiedHead.next; + copiedHead = tempNode; + tempIndex = middleIndex; + } + head = head.next; + } + return tempNode; + } + + public static void main(String[] args) { + int[] array = {1,2,3,4,5}; + ListNode node = ListNode.insertNode(array); + LinkedList_876_Middle_of_the_Linked_List object = new LinkedList_876_Middle_of_the_Linked_List(); + ListNode middleNode = object.middleNode(node); + System.out.println("**------------------------------**"); + while (middleNode != null) { + System.out.println(middleNode.val); + middleNode = middleNode.next; + } + } +} diff --git a/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_101_Symmetric_Tree.java b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_101_Symmetric_Tree.java new file mode 100644 index 0000000..9b31458 --- /dev/null +++ b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_101_Symmetric_Tree.java @@ -0,0 +1,30 @@ +package leetcodeNZ.tags.topInterviewQuestions; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class TIQ_101_Symmetric_Tree { + + private String traversal(TreeNode node, boolean isLeftNode) { + if (node == null) return "null"; + String left = traversal(node.left, isLeftNode); + String right = traversal(node.right, isLeftNode); + return (isLeftNode ? right + "-" + left : left + "-" + right) + "-" + node.val; + } + + public boolean isSymmetric(TreeNode root) { + if (root.left == null && root.right == null) return true; + return traversal(root.left, true).equals(traversal(root.right, false)); + } + + public static void main(String[] args) { +// Integer[] array = {1,2,2,3,4,4,3}; +// Integer[] array = {1,2,2,null,3,null,3}; + Integer[] array = {1,2,2,null,3,null,3}; + TreeNode node = TreeNode.fromArray(array); + + TreeNodePrintUtil.displayTree(node); + TIQ_101_Symmetric_Tree object = new TIQ_101_Symmetric_Tree(); + System.out.println(object.isSymmetric(node)); + } +} diff --git a/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_118_Pascal_s_Triangle.java b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_118_Pascal_s_Triangle.java new file mode 100644 index 0000000..cbf807d --- /dev/null +++ b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_118_Pascal_s_Triangle.java @@ -0,0 +1,33 @@ +package leetcodeNZ.tags.topInterviewQuestions; + +import java.util.ArrayList; +import java.util.List; + +public class TIQ_118_Pascal_s_Triangle { + public List> generate(int numRows) { + List> mainList = new ArrayList<>(); + for (int i = 0; i < numRows; i++) { + List subList = new ArrayList<>(); + if (i == 0) {} + else if (i == 1) subList.add(1); + else { + List previousSubList = mainList.get(i - 1); + for (int j = 0; j < previousSubList.size(); j++) { + if (j == 0) subList.add(1); + else subList.add(previousSubList.get(j - 1) + previousSubList.get(j)); + } + } + subList.add(1); + mainList.add(subList); + } + return mainList; + } + + public static void main(String[] args) { + TIQ_118_Pascal_s_Triangle object = new TIQ_118_Pascal_s_Triangle(); + for (int i = 1; i <= 30 ; i++) { + System.out.println(object.generate(i)); + } + } +} + diff --git a/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_121_Best_Time_to_Buy_and_Sell_Stock.java b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_121_Best_Time_to_Buy_and_Sell_Stock.java new file mode 100644 index 0000000..e455043 --- /dev/null +++ b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_121_Best_Time_to_Buy_and_Sell_Stock.java @@ -0,0 +1,65 @@ +package leetcodeNZ.tags.topInterviewQuestions; + +public class TIQ_121_Best_Time_to_Buy_and_Sell_Stock { +// public int maxProfit(int[] prices) { +// int maxProfit = 0; +// for (int i = prices.length - 1; i >= 0 ; i--) { +// for (int j = i - 1; j >= 0; j--) { +// int profit = prices[i] - prices[j]; +// if (profit > maxProfit) maxProfit = profit; +// } +// } +// return maxProfit; +// } + +// public int maxProfit(int[] prices) { +// if (prices.length == 1) return 0; +// int minIndex = 0; +// int maxIndex = 1; +// int min = prices[minIndex]; +// int max = prices[maxIndex]; +// System.out.println("prices.length: " + prices.length); +// for (int i = 0; i < prices.length;) { +// System.out.println("minIndex " + minIndex + " maxIndex " + maxIndex); +// int minIndexValue = minIndex >= prices.length ? min : prices[minIndex]; +// int maxIndexValue = maxIndex >= prices.length ? max : prices[maxIndex]; +// if (minIndexValue < min) { +// min = minIndexValue; +// } +// if (maxIndexValue > max) { +// max = maxIndexValue; +// } +// System.out.println("minIndexValue " + minIndexValue + " maxIndexValue " + maxIndexValue + " min " + min + " max " + max); +// minIndex++; +// maxIndex++; +// if (minIndex >= maxIndex) { +// minIndex = maxIndex - 1; +// } +// i++; +// } +// if (min < max) return max - min; +// else return 0; +// } + + public int maxProfit(int[] prices) { + int min = Integer.MAX_VALUE; + int profit = 0; + int currentProfit; + for (int i = 0; i < prices.length; i++) { + if (prices[i] < min) min = prices[i]; + currentProfit = prices[i] - min; + if (currentProfit > profit) profit = currentProfit; + } + return profit; + } + + + public static void main(String[] args) { +// int array[] = {7,1,5,3,6,4}; +// int array[] = {7,6,4,3,1}; +// int array[] = {2,1,2,0,1}; + int array[] = {1,2,4}; + TIQ_121_Best_Time_to_Buy_and_Sell_Stock object = new TIQ_121_Best_Time_to_Buy_and_Sell_Stock(); + System.out.println(object.maxProfit(array)); + } +} diff --git a/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_125_Valid_Palindrome.java b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_125_Valid_Palindrome.java new file mode 100644 index 0000000..dff7b2e --- /dev/null +++ b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_125_Valid_Palindrome.java @@ -0,0 +1,46 @@ +package leetcodeNZ.tags.topInterviewQuestions; + +import java.util.Stack; + +public class TIQ_125_Valid_Palindrome { + + public boolean isPalindrome(String s) { + if (s == null || s.length() == 0 || s.length() == 1) return true; + Stack stack = new Stack<>(); + char charArray[] = s.toCharArray(); + for (int i = 0; i < charArray.length; i++) { + int char2int = charArray[i]; + int lowercaseInt = (char2int >= 65 && char2int <= 90) ? char2int + 32 : char2int; + System.out.println("lowercaseInt " + lowercaseInt); + if ((lowercaseInt >= 97 && lowercaseInt <= 122) || (lowercaseInt >= 48 && lowercaseInt <= 57)) { + stack.push((char)lowercaseInt); + } + } + System.out.println(s); + System.out.println(stack); + System.out.println("****************************"); + while (stack.size() > 1) { + char firstElement = stack.firstElement(); + char lastElement = stack.pop(); + if (firstElement != lastElement) return false; + stack.remove(0); + } + return true; + } + + public static void main(String[] args) { + char cArray[] = {'0','1','2','3','4','5','6','7','8','9'}; + for (int i = 0; i < cArray.length; i++) { + int item = cArray[i]; + System.out.println("i " + i + " toChar " + item); + } + + + TIQ_125_Valid_Palindrome object = new TIQ_125_Valid_Palindrome(); +// System.out.println(object.isPalindrome("A man, a plan, a canal: Panama")); +// System.out.println(object.isPalindrome("race a car")); + System.out.println(object.isPalindrome("0P")); +// System.out.println(object.isPalindrome("A")); +// System.out.println(object.isPalindrome("b")); + } +} diff --git a/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_70_Climbing_Stairs.java b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_70_Climbing_Stairs.java new file mode 100644 index 0000000..16b3bad --- /dev/null +++ b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_70_Climbing_Stairs.java @@ -0,0 +1,12 @@ +package leetcodeNZ.tags.topInterviewQuestions; + +public class TIQ_70_Climbing_Stairs { + public int climbStairs(int n) { + return 0; + } + + public static void main(String[] args) { + TIQ_70_Climbing_Stairs object = new TIQ_70_Climbing_Stairs(); + object.climbStairs(2); + } +} diff --git a/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_88_Merge_Sorted_Array.java b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_88_Merge_Sorted_Array.java new file mode 100644 index 0000000..437590a --- /dev/null +++ b/src/leetcodeNZ/tags/topInterviewQuestions/TIQ_88_Merge_Sorted_Array.java @@ -0,0 +1,13 @@ +package leetcodeNZ.tags.topInterviewQuestions; + +public class TIQ_88_Merge_Sorted_Array { + + public void merge(int[] nums1, int m, int[] nums2, int n) { + + } + + public static void main(String[] args) { + TIQ_88_Merge_Sorted_Array object = new TIQ_88_Merge_Sorted_Array(); +// object.merge(); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_100_Same_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_100_Same_Tree.java new file mode 100644 index 0000000..336815d --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_100_Same_Tree.java @@ -0,0 +1,61 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_100_Same_Tree { + + + private void traversal(TreeNode root, StringBuffer tree2str) { + if (root == null) return; + System.out.println("=====>" + root.val); + tree2str.append(root.val + "-"); + if (root.left == null) tree2str.append("*"); + if (root.right == null) tree2str.append("&"); + System.out.println(tree2str); + traversal(root.left, tree2str); + traversal(root.right, tree2str); + } + + public boolean isSameTree(TreeNode p, TreeNode q) { + StringBuffer tree2str1 = new StringBuffer(); + StringBuffer tree2str2 = new StringBuffer(); + traversal(p, tree2str1); + traversal(q, tree2str2); + return tree2str1.toString().equals(tree2str2.toString()); + } + +// private void traversal(TreeNode root, String tree2str) { +// if (root == null) return; +// System.out.println("=====>" + root.val); +// tree2str += root.val + "-"; +// System.out.println(tree2str); +// traversal(root.left, tree2str); +// traversal(root.right, tree2str); +// } +// +// public boolean isSameTree(TreeNode p, TreeNode q) { +// String tree2str1 = ""; +// String tree2str2 = ""; +// traversal(p, tree2str1); +// System.out.println("tree2str1 " + tree2str1); +// traversal(q, tree2str2); +// System.out.println("tree2str2 " + tree2str2); +// return tree2str1.equals(tree2str2); +// } + + public static void main(String[] args) { +// Integer[] array = {6,2,8,0,4,7,9,null,null,3,5}; // {6,2,8,0,4,7,9,3,5}; // {1,2}; +// Integer[] array = {1,2}; + Integer[] array = {10,5,null,null,15}; + TreeNode node = TreeNode.fromArray(array); + TreeNodePrintUtil.displayTree(node); + +// Integer[] array2 = {1,null,2}; + Integer[] array2 = {10,5,15};; + TreeNode node2 = TreeNode.fromArray(array2); + TreeNodePrintUtil.displayTree(node2); + Tree_100_Same_Tree object = new Tree_100_Same_Tree(); + System.out.println(object.isSameTree(node, node2)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_104_Maximum_Depth_of_Binary_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_104_Maximum_Depth_of_Binary_Tree.java new file mode 100644 index 0000000..d85bc07 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_104_Maximum_Depth_of_Binary_Tree.java @@ -0,0 +1,26 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_104_Maximum_Depth_of_Binary_Tree { + + public int maxDepth(TreeNode root) { + if (root == null) return 0; + int leftDepth = maxDepth(root.left); + int rightDepth = maxDepth(root.right); + return (leftDepth > rightDepth ? leftDepth : rightDepth) + 1; + } + + public static void main(String[] args) { + + TreeNode second1 = new TreeNode(1, null, null); + TreeNode second3 = new TreeNode(3, null, null); + TreeNode second2 = new TreeNode(2, second1, second3); + TreeNode second7 = new TreeNode(7, null, null); + TreeNode second4 = new TreeNode(4, second2, second7); + TreeNodePrintUtil.displayTree(second4); + Tree_104_Maximum_Depth_of_Binary_Tree object = new Tree_104_Maximum_Depth_of_Binary_Tree(); + System.out.println(object.maxDepth(second4)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_108_convert_sorted_array_to_binary_search_tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_108_convert_sorted_array_to_binary_search_tree.java new file mode 100644 index 0000000..43bbc23 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_108_convert_sorted_array_to_binary_search_tree.java @@ -0,0 +1,76 @@ +/** + * + */ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +/* + * Given an array where elements are sorted in ascending order, convert it to a height balanced BST. + For this problem, a height-balanced binary tree is defined as a binary tree in which the depth of the two subtrees of every node never differ by more than 1. + + Example: + + Given the sorted array: [-10,-3,0,5,9], + + One possible answer is: [0,-3,9,-10,null,5], which represents the following height balanced BST: + + 0 + / \ + -3 9 + / / + -10 5 + */ + +/** + * @author simonhan 16 Aug 2020 + */ +public class Tree_108_convert_sorted_array_to_binary_search_tree { + + public TreeNode sortedArrayToBST(int[] nums) { + TreeNode root = new TreeNode(nums[0]); + for(int i = 1; i < nums.length; i++) { + createBST(root, nums[i]); + } + return root; + } + + private void createBST(TreeNode node, int insetedNodeVal) { + if (insetedNodeVal < node.val) { + if (node.left == null) { + node.left = new TreeNode(insetedNodeVal); + } else { + createBST(node.left, insetedNodeVal); + } + } else { + if (node.right == null) { + node.right = new TreeNode(insetedNodeVal); + } else { + createBST(node.right, insetedNodeVal); + } + } + } + + public TreeNode arrayToBinaryTree(int[] nums) { + if (nums.length <= 0) return null; + return constructBinaryTree(nums, 0, nums.length - 1); + } + + private TreeNode constructBinaryTree(int[] nums, int left, int right) { + if (right < left) return null; + int middlePoint = left + (right - left) / 2; + TreeNode middleTreeNode = new TreeNode(nums[middlePoint]); + middleTreeNode.left = constructBinaryTree(nums, left, middlePoint - 1); + middleTreeNode.right = constructBinaryTree(nums, middlePoint + 1, right); + TreeNodePrintUtil.displayTree(middleTreeNode); + return middleTreeNode; + } + + public static void main(String[] args) { + int[] nums = {-10,-3,0,5,9}; + Tree_108_convert_sorted_array_to_binary_search_tree obj = new Tree_108_convert_sorted_array_to_binary_search_tree(); + TreeNode node = obj.arrayToBinaryTree(nums); + TreeNodePrintUtil.displayTree(node); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_144_Binary_Tree_Preorder_Traversal.java b/src/leetcodeNZ/tags/tree/easy/Tree_144_Binary_Tree_Preorder_Traversal.java new file mode 100644 index 0000000..f0b1d32 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_144_Binary_Tree_Preorder_Traversal.java @@ -0,0 +1,35 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_144_Binary_Tree_Preorder_Traversal { + + private void preOrder(TreeNode root, List list) { + if (root == null) return; + list.add(root.val); + preOrder(root.left, list); + preOrder(root.right, list); + } + + public List preorderTraversal(TreeNode root) { + List list = new ArrayList<>(); + preOrder(root, list); + return list; + } + + public static void main(String[] args) { + Integer[] array = {1, null, 2, 3}; + TreeNode node = TreeNode.fromArray(array); + TreeNodePrintUtil.displayTree(node); + Tree_144_Binary_Tree_Preorder_Traversal object = new Tree_144_Binary_Tree_Preorder_Traversal(); + List resultList = object.preorderTraversal(node); + for (int i : resultList) { + System.out.print(i + " "); + } + System.out.println(); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_145_Binary_Tree_Postorder_Traversal.java b/src/leetcodeNZ/tags/tree/easy/Tree_145_Binary_Tree_Postorder_Traversal.java new file mode 100644 index 0000000..11fa76e --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_145_Binary_Tree_Postorder_Traversal.java @@ -0,0 +1,35 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_145_Binary_Tree_Postorder_Traversal { + + private void postOrder(TreeNode root, List list) { + if (root == null) return; + postOrder(root.left, list); + postOrder(root.right, list); + list.add(root.val); + } + + public List postorderTraversal(TreeNode root) { + List list = new ArrayList<>(); + postOrder(root, list); + return list; + } + + public static void main(String[] args) { + Integer[] array = {1, null, 2, 3}; + TreeNode node = TreeNode.fromArray(array); + TreeNodePrintUtil.displayTree(node); + Tree_145_Binary_Tree_Postorder_Traversal object = new Tree_145_Binary_Tree_Postorder_Traversal(); + List resultList = object.postorderTraversal(node); + for (int i : resultList) { + System.out.print(i + " "); + } + System.out.println(); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_2236_Root_Equals_Sum_Of_Children.java b/src/leetcodeNZ/tags/tree/easy/Tree_2236_Root_Equals_Sum_Of_Children.java new file mode 100644 index 0000000..bbd367c --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_2236_Root_Equals_Sum_Of_Children.java @@ -0,0 +1,25 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; + +/** + * @author Simon-the-coder + * @date 1/05/22 5:25 PM + */ +public class Tree_2236_Root_Equals_Sum_Of_Children { + public boolean checkTree(TreeNode root) { + if (root == null) return false; + if (root.left == null && root.right == null); + return root.val == ((root.left == null ? 0 : root.left.val) + (root.right == null ? 0 : root.right.val)); + } + + public static void main(String[] args) { + + TreeNode left = new TreeNode(4, null, null); + TreeNode right = new TreeNode(6, null, null); + TreeNode root = new TreeNode(10, left, right); + + Tree_2236_Root_Equals_Sum_Of_Children object = new Tree_2236_Root_Equals_Sum_Of_Children(); + object.checkTree(root); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_226_Invert_Binary_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_226_Invert_Binary_Tree.java new file mode 100644 index 0000000..427d9a4 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_226_Invert_Binary_Tree.java @@ -0,0 +1,31 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_226_Invert_Binary_Tree { + + public TreeNode invertTree(TreeNode root) { + if (root == null) return null; + TreeNode temp = root.left; + root.left = root.right; + root.right = temp; + if (root.left != null) invertTree(root.left); + if (root.right != null) invertTree(root.right); + return root; + } + + public static void main(String[] args) { + + TreeNode second6 = new TreeNode(6, null, null); + TreeNode second9 = new TreeNode(9, null, null); + TreeNode second7 = new TreeNode(7, second6, second9); + TreeNode second1 = new TreeNode(1, null, null); + TreeNode second3 = new TreeNode(3, null, null); + TreeNode second2 = new TreeNode(2, second1, second3); + TreeNode second4 = new TreeNode(4, second2, second7); + TreeNodePrintUtil.displayTree(second4); + Tree_226_Invert_Binary_Tree object = new Tree_226_Invert_Binary_Tree(); + TreeNodePrintUtil.displayTree(object.invertTree(second4)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.java new file mode 100644 index 0000000..7ba8bb0 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.java @@ -0,0 +1,25 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree { + + public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) { + if (root == null) return null; + TreeNode left = lowestCommonAncestor(root.left, p, q); + TreeNode right = lowestCommonAncestor(root.right, p, q); + return null; + } + + public static void main(String[] args) { + Integer[] array = {6,2,8,0,4,7,9,null,null,3,5}; + TreeNode node = TreeNode.fromArray(array); + TreeNodePrintUtil.displayTree(node); + Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree object = new Tree_235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree(); + TreeNode node2 = node.left; + TreeNode node9 = node.right.right; + System.out.println("node2 " + node2.val + " node9.val " + node9.val); + object.lowestCommonAncestor(node, node2, node9); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_257_Binary_Tree_Paths.java b/src/leetcodeNZ/tags/tree/easy/Tree_257_Binary_Tree_Paths.java new file mode 100644 index 0000000..9b2d567 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_257_Binary_Tree_Paths.java @@ -0,0 +1,43 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_257_Binary_Tree_Paths { + + public List binaryTreePaths(TreeNode root) { + List answer = new ArrayList(); + if (root != null) searchBT(root, "", answer); + return answer; + } + private void searchBT(TreeNode root, String path, List answer) { + System.out.println(root.val); + TreeNodePrintUtil.displayTree(root); + if (root.left == null && root.right == null) { + answer.add(path + root.val); + System.out.println(answer); + } + if (root.left != null) searchBT(root.left, path + root.val + "->", answer); + if (root.right != null) searchBT(root.right, path + root.val + "->", answer); + } + + public static void main(String[] args) { + Integer[] array = {1,2,3,4,5,6,7,8,9,10,11,12,13,14,15}; + Integer[] array2 = {1,2,3,5,6}; +// Integer[] array = {1,2,3,null,5}; +// Integer[] array = {1}; +// Integer[] array = {1,null,3}; + TreeNode node = TreeNode.fromArray(array); +// TreeNode node2 = TreeNode.fromArray(array2); + TreeNodePrintUtil.displayTree(node); +// TreeNodePrintUtil.displayTree(node2); + System.out.println("-----------------------------"); + Tree_257_Binary_Tree_Paths object = new Tree_257_Binary_Tree_Paths(); + object.binaryTreePaths(node); +// System.out.println("-----------------------------"); +// System.out.println(object.binaryTreePaths(node2)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_559_Maximum_Depth_of_N_ary_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_559_Maximum_Depth_of_N_ary_Tree.java new file mode 100644 index 0000000..fa427a3 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_559_Maximum_Depth_of_N_ary_Tree.java @@ -0,0 +1,58 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +public class Tree_559_Maximum_Depth_of_N_ary_Tree { + + public int maxDepth(Node root) { + if (root == null) return 0; + int maxDepth = 0; + for (Node node : root.children) { + int depth = maxDepth(node); + if (depth > maxDepth) maxDepth = depth; + } + return maxDepth + 1; + } + + public static void main(String[] args) { + + Node treeNode14 = new Node(14, new ArrayList<>()); + Node treeNode13 = new Node(13, new ArrayList<>()); + Node treeNode12 = new Node(12, new ArrayList<>()); + List treeChildren11 = new ArrayList<>(); + treeChildren11.add(treeNode14); + Node treeNode11 = new Node(11, treeChildren11); + Node treeNode10 = new Node(10, new ArrayList<>()); + List treeChildren9 = new ArrayList<>(); + treeChildren9.add(treeNode13); + Node treeNode9 = new Node(9, treeChildren9); + List treeChildren8 = new ArrayList<>(); + treeChildren8.add(treeNode12); + Node treeNode8 = new Node(8, treeChildren8); + List treeChildren7 = new ArrayList<>(); + treeChildren7.add(treeNode11); + Node treeNode7 = new Node(7, treeChildren7); + Node treeNode6 = new Node(6, new ArrayList<>()); + List treeChildren5 = new ArrayList<>(); + treeChildren5.add(treeNode9); + treeChildren5.add(treeNode10); + Node treeNode5 = new Node(5, treeChildren5); + List treeChildren4 = new ArrayList<>(); + treeChildren4.add(treeNode8); + Node treeNode4 = new Node(4, treeChildren4); + List treeChildren3 = new ArrayList<>(); + treeChildren3.add(treeNode6); + treeChildren3.add(treeNode7); + Node treeNode3 = new Node(3, treeChildren3); + Node treeNode2 = new Node(2, new ArrayList<>()); + List treeChildren1 = new ArrayList<>(); + treeChildren1.add(treeNode2); + treeChildren1.add(treeNode3); + treeChildren1.add(treeNode4); + treeChildren1.add(treeNode5); + Node treeNode1 = new Node(1, treeChildren1); + Tree_559_Maximum_Depth_of_N_ary_Tree object = new Tree_559_Maximum_Depth_of_N_ary_Tree(); + System.out.println(object.maxDepth(treeNode1)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_563_Binary_Tree_Tilt.java b/src/leetcodeNZ/tags/tree/easy/Tree_563_Binary_Tree_Tilt.java new file mode 100644 index 0000000..2bfcf31 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_563_Binary_Tree_Tilt.java @@ -0,0 +1,5 @@ +package leetcodeNZ.tags.tree.easy; + +public class Tree_563_Binary_Tree_Tilt { + +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_589_N_ary_Tree_Preorder_Traversal.java b/src/leetcodeNZ/tags/tree/easy/Tree_589_N_ary_Tree_Preorder_Traversal.java new file mode 100644 index 0000000..e13ce05 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_589_N_ary_Tree_Preorder_Traversal.java @@ -0,0 +1,66 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +public class Tree_589_N_ary_Tree_Preorder_Traversal { + + private List list = new ArrayList<>(); + + private void treePreOrder(Node root) { + if (root == null) return; + if (root.children == null) return; + for (Node node : root.children) { + list.add(node.val); + treePreOrder(node); + } + } + + public List preorder(Node root) { + if (root != null) list.add(root.val); + treePreOrder(root); + return list; + } + + public static void main(String[] args) { + + Node treeNode14 = new Node(14, new ArrayList<>()); + Node treeNode13 = new Node(13, new ArrayList<>()); + Node treeNode12 = new Node(12, new ArrayList<>()); + List treeChildren11 = new ArrayList<>(); + treeChildren11.add(treeNode14); + Node treeNode11 = new Node(11, treeChildren11); + Node treeNode10 = new Node(10, new ArrayList<>()); + List treeChildren9 = new ArrayList<>(); + treeChildren9.add(treeNode13); + Node treeNode9 = new Node(9, treeChildren9); + List treeChildren8 = new ArrayList<>(); + treeChildren8.add(treeNode12); + Node treeNode8 = new Node(8, treeChildren8); + List treeChildren7 = new ArrayList<>(); + treeChildren7.add(treeNode11); + Node treeNode7 = new Node(7, treeChildren7); + Node treeNode6 = new Node(6, new ArrayList<>()); + List treeChildren5 = new ArrayList<>(); + treeChildren5.add(treeNode9); + treeChildren5.add(treeNode10); + Node treeNode5 = new Node(5, treeChildren5); + List treeChildren4 = new ArrayList<>(); + treeChildren4.add(treeNode8); + Node treeNode4 = new Node(4, treeChildren4); + List treeChildren3 = new ArrayList<>(); + treeChildren3.add(treeNode6); + treeChildren3.add(treeNode7); + Node treeNode3 = new Node(3, treeChildren3); + Node treeNode2 = new Node(2, new ArrayList<>()); + List treeChildren1 = new ArrayList<>(); + treeChildren1.add(treeNode2); + treeChildren1.add(treeNode3); + treeChildren1.add(treeNode4); + treeChildren1.add(treeNode5); + Node treeNode1 = new Node(1, treeChildren1); + + Tree_589_N_ary_Tree_Preorder_Traversal object = new Tree_589_N_ary_Tree_Preorder_Traversal(); + System.out.println(object.preorder(treeNode1)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_590_N_ary_Tree_Postorder_Traversal.java b/src/leetcodeNZ/tags/tree/easy/Tree_590_N_ary_Tree_Postorder_Traversal.java new file mode 100644 index 0000000..9cc3ce0 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_590_N_ary_Tree_Postorder_Traversal.java @@ -0,0 +1,82 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +class Node { + public int val; + public List children; + + public Node() {} + + public Node(int _val) { + val = _val; + } + + public Node(int _val, List _children) { + val = _val; + children = _children; + } +}; + +public class Tree_590_N_ary_Tree_Postorder_Traversal { + + private List list = new ArrayList<>(); + + private void treePostOrder(Node root) { + if (root == null) return; + if (root.children == null) return; + for (Node node : root.children) { + treePostOrder(node); + list.add(node.val); + } + } + + public List postorder(Node root) { + treePostOrder(root); + if (root != null) list.add(root.val); + return list; + } + + public static void main(String[] args) { + + Node treeNode14 = new Node(14, new ArrayList<>()); + Node treeNode13 = new Node(13, new ArrayList<>()); + Node treeNode12 = new Node(12, new ArrayList<>()); + List treeChildren11 = new ArrayList<>(); + treeChildren11.add(treeNode14); + Node treeNode11 = new Node(11, treeChildren11); + Node treeNode10 = new Node(10, new ArrayList<>()); + List treeChildren9 = new ArrayList<>(); + treeChildren9.add(treeNode13); + Node treeNode9 = new Node(9, treeChildren9); + List treeChildren8 = new ArrayList<>(); + treeChildren8.add(treeNode12); + Node treeNode8 = new Node(8, treeChildren8); + List treeChildren7 = new ArrayList<>(); + treeChildren7.add(treeNode11); + Node treeNode7 = new Node(7, treeChildren7); + Node treeNode6 = new Node(6, new ArrayList<>()); + List treeChildren5 = new ArrayList<>(); + treeChildren5.add(treeNode9); + treeChildren5.add(treeNode10); + Node treeNode5 = new Node(5, treeChildren5); + List treeChildren4 = new ArrayList<>(); + treeChildren4.add(treeNode8); + Node treeNode4 = new Node(4, treeChildren4); + List treeChildren3 = new ArrayList<>(); + treeChildren3.add(treeNode6); + treeChildren3.add(treeNode7); + Node treeNode3 = new Node(3, treeChildren3); + Node treeNode2 = new Node(2, new ArrayList<>()); + List treeChildren1 = new ArrayList<>(); + treeChildren1.add(treeNode2); + treeChildren1.add(treeNode3); + treeChildren1.add(treeNode4); + treeChildren1.add(treeNode5); + Node treeNode1 = new Node(1, treeChildren1); + + Tree_590_N_ary_Tree_Postorder_Traversal object = new Tree_590_N_ary_Tree_Postorder_Traversal(); + System.out.println(object.postorder(treeNode1)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_606_Construct_String_from_Binary_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_606_Construct_String_from_Binary_Tree.java new file mode 100644 index 0000000..f16c7e1 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_606_Construct_String_from_Binary_Tree.java @@ -0,0 +1,46 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.List; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_606_Construct_String_from_Binary_Tree { + + private void traversal(TreeNode root, List list) { + if (root == null) return; + + traversal(root.left, list); + traversal(root.right, list); + list.add(root.val); + System.out.println(root.val); + + } + +// public String tree2str(TreeNode root) { +// List list = new ArrayList<>(); +// traversal(root,list); +// System.out.println(list); +// return ""; +// } + + public String tree2str(TreeNode t) { + if(t == null) return ""; + String left = tree2str(t.left); + String right = tree2str(t.right); + System.out.println("left " + left + " | right " + right); + if(left == "" && right == "") return t.val + ""; + + return t.val + "(" + left + ")" + (right == "" ? "" : "(" + right + ")"); + } + + public static void main(String[] args) { + Integer[] array = {1,2,3,4}; +// Integer[] array = {1,2,3,null,4}; + TreeNode node = TreeNode.fromArray(array); + TreeNodePrintUtil.displayTree(node); + System.out.println("-----------------------------"); + Tree_606_Construct_String_from_Binary_Tree object = new Tree_606_Construct_String_from_Binary_Tree(); + System.out.println(object.tree2str(node)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_617_merge_two_binary_tress.java b/src/leetcodeNZ/tags/tree/easy/Tree_617_merge_two_binary_tress.java new file mode 100644 index 0000000..bebd1ab --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_617_merge_two_binary_tress.java @@ -0,0 +1,61 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +/** + * Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not. + * + * You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree. + * + * Example 1: + * + * Input: + * Tree 1 Tree 2 + * 1 2 + * / \ / \ + * 3 2 1 3 + * / \ \ + * 5 4 7 + * + * Output: + * Merged tree: + * 3 + * / \ + * 4 5 + * / \ \ + * 5 4 7 + */ + +/** + * @author Simon-the-coder + * @date 17/08/20 9:43 am + */ +public class Tree_617_merge_two_binary_tress { + + public TreeNode mergeTrees(TreeNode node1, TreeNode node2) { + if (node1 == null && node2 == null) return null; + int newValue = (node1 == null ? 0 : node1.val) + (node2 == null ? 0 : node2.val); + + TreeNode newNode = new TreeNode(newValue); + newNode.left = mergeTrees(node1 == null ? null : node1.left, node2 == null ? null : node2.left); + newNode.right = mergeTrees(node1 == null ? null : node1.right, node2 == null ? null : node2.right); + return newNode; + } + + public static void main(String[] args) { + TreeNode first5 = new TreeNode(5, null, null); + TreeNode first3 = new TreeNode(3, first5, null); + TreeNode first2 = new TreeNode(2, null, null); + TreeNode first1 = new TreeNode(1, first3, first2); + TreeNodePrintUtil.displayTree(first1); + TreeNode second4 = new TreeNode(4, null, null); + TreeNode second7 = new TreeNode(7, null, null); + TreeNode second1 = new TreeNode(1, null, second4); + TreeNode second3 = new TreeNode(3, null, second7); + TreeNode second2 = new TreeNode(2, second1, second3); + TreeNodePrintUtil.displayTree(second2); + Tree_617_merge_two_binary_tress object = new Tree_617_merge_two_binary_tress(); + TreeNodePrintUtil.displayTree(object.mergeTrees(first1, second2)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_637_Average_of_Levels_in_Binary_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_637_Average_of_Levels_in_Binary_Tree.java new file mode 100644 index 0000000..07d48bc --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_637_Average_of_Levels_in_Binary_Tree.java @@ -0,0 +1,72 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +// double average = ((root.left == null ? 0 : root.left.val) + (root.right == null ? 0 : root.right.val)) / 2; +// list.add(average); + +public class Tree_637_Average_of_Levels_in_Binary_Tree { +// private List list = new ArrayList<>(); +// public void averageOfLevel(TreeNode root) { +// if (root == null) return; +// if (root.left != null && root.right != null) list.add(new Double(root.left.val + root.right.val)/ 2); +// if (root.left == null && root.right != null) list.add(new Double(root.right.val)); +// if (root.left != null && root.right == null) list.add(new Double(root.left.val)); +// averageOfLevel(root.left); +// averageOfLevel(root.right); +// } +// +// public List averageOfLevels(TreeNode root) { +// if (root == null) return list; +// list.add(new Double(root.val)); +// averageOfLevel(root); +// return list; +// } + + private List list = new ArrayList<>(); + public List averageOfLevels(TreeNode root) { + if (root == null) return list; + averageOfLevel(root); + return list; + } + + public void averageOfLevel(TreeNode root) { + Stack globalStack = new Stack<>(); + globalStack.push(root); + int levelNodeCount = globalStack.size(); + boolean isLoop = true; + while (isLoop) { + double sum = 0; + List arrayList = new ArrayList<>(); + for (int i = 0; i < levelNodeCount; i++) { + TreeNode node = globalStack.pop(); + if (node != null) { + sum += node.val; + arrayList.add(node); + } + } + + for (TreeNode node : arrayList) { + if (node.left != null) globalStack.push(node.left); + if (node.right != null) globalStack.push(node.right); + } + list.add(sum / levelNodeCount); + levelNodeCount = globalStack.size(); + isLoop = levelNodeCount > 0; + } + } + + public static void main(String[] args) { + Integer[] array = {3, 1, 5, 0, 2, 4, 6}; + TreeNode node = TreeNode.fromArray(array); + + TreeNodePrintUtil.displayTree(node); + Tree_637_Average_of_Levels_in_Binary_Tree object = new Tree_637_Average_of_Levels_in_Binary_Tree(); + System.out.println(object.averageOfLevels(node)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_653_Two_Sum_IV_Input_is_a_BST.java b/src/leetcodeNZ/tags/tree/easy/Tree_653_Two_Sum_IV_Input_is_a_BST.java new file mode 100644 index 0000000..e34e3b7 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_653_Two_Sum_IV_Input_is_a_BST.java @@ -0,0 +1,56 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_653_Two_Sum_IV_Input_is_a_BST { + +// private List nodeValueList = new ArrayList<>(); +// private void traversal(TreeNode root) { +// if (root == null) return; +// traversal(root.left); +// traversal(root.right); +// nodeValueList.add(root.val); +// } +// +// public boolean findTarget(TreeNode root, int k) { +// traversal(root); +// for (int i = 0; i < nodeValueList.size(); i++) { +// int subValue = k - nodeValueList.get(i); +// for (int j = 0; j < nodeValueList.size(); j++) { +// if (i != j && subValue == nodeValueList.get(j)) { +// return true; +// } +// } +// } +// return false; +// } + private boolean b = false; + private void traversal(TreeNode root, List nodeValueList, int k) { + if (root == null) return; + traversal(root.left, nodeValueList, k); + traversal(root.right, nodeValueList, k); + if (nodeValueList.contains(root.val)) { + b = true; + return; + } + nodeValueList.add(k - root.val); + } + + public boolean findTarget(TreeNode root, int k) { + List nodeValueList = new ArrayList<>(); + traversal(root, nodeValueList, k); + return b; + } + + public static void main(String[] args) { + Integer[] array = {5,3,6,2,4,null,7}; + TreeNode node = TreeNode.fromArray(array); + TreeNodePrintUtil.displayTree(node); + Tree_653_Two_Sum_IV_Input_is_a_BST object = new Tree_653_Two_Sum_IV_Input_is_a_BST(); + object.findTarget(node, 9); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_700_Search_in_a_Binary_Search_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_700_Search_in_a_Binary_Search_Tree.java new file mode 100644 index 0000000..6bf4484 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_700_Search_in_a_Binary_Search_Tree.java @@ -0,0 +1,30 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_700_Search_in_a_Binary_Search_Tree { + public TreeNode searchBST(TreeNode root, int val) { + if (root == null) return null; + if (root.val > val) return searchBST(root.left, val); + else if(root.val < val) return searchBST(root.right, val); + else return root; + } + + public static void main(String[] args) { + TreeNode second1 = new TreeNode(1, null, null); + TreeNode second3 = new TreeNode(3, null, null); + TreeNode second2 = new TreeNode(2, second1, second3); + TreeNode second7 = new TreeNode(7, null, null); + TreeNode second4 = new TreeNode(4, second2, second7); + + TreeNodePrintUtil.displayTree(second4); + Tree_700_Search_in_a_Binary_Search_Tree object = new Tree_700_Search_in_a_Binary_Search_Tree(); + + TreeNodePrintUtil.displayTree(object.searchBST(second4, 1)); + TreeNodePrintUtil.displayTree(object.searchBST(second4, 3)); + TreeNodePrintUtil.displayTree(object.searchBST(second4, 2)); + TreeNodePrintUtil.displayTree(object.searchBST(second4, 7)); + TreeNodePrintUtil.displayTree(object.searchBST(second4, 4)); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_872_Leaf_Similar_Trees.java b/src/leetcodeNZ/tags/tree/easy/Tree_872_Leaf_Similar_Trees.java new file mode 100644 index 0000000..3f227ce --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_872_Leaf_Similar_Trees.java @@ -0,0 +1,64 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +public class Tree_872_Leaf_Similar_Trees { + private String treeValuesString1; + private String treeValuesString2; + private void inOrder(TreeNode root, boolean isFirstTree) { + if (root == null) return; + if (root.left == null && root.right == null) { + if (isFirstTree) { + treeValuesString1 += root.val + "-"; + } else { + treeValuesString2 += root.val + "-"; + } + } + inOrder(root.left, isFirstTree); + inOrder(root.right,isFirstTree); + } + public boolean leafSimilar(TreeNode root1, TreeNode root2) { + inOrder(root1, true); + inOrder(root2, false); + return treeValuesString1.equals(treeValuesString2); + } + public List list = new ArrayList<>(); + private void getLeaves(TreeNode root) { + if (root == null) return; + if (root.left == null && root.right == null) { + list.add(root.val); + } + getLeaves(root.left); + getLeaves(root.right); + } + + public static void main(String[] args) { +// [3,5,1,6,2,9,8,null,null,7,14] +// [3,5,1,6,71,4,2,null,null,null,null,null,null,9,8] + Tree_872_Leaf_Similar_Trees object = new Tree_872_Leaf_Similar_Trees(); +// Integer[] integerArray1 = {3,5,1,6,2,9,8,null,null,7,4}; + Integer[] integerArray1 = {3,5,1,6,2,9,8,null,null,7,14}; +// Integer[] integerArray1 = {105,117,null,82,38,115,10,null,40,44,6,61,19,null,null,8,24,104,107,4,90,8,113,27,116,77,null,25,67,14,null,46,19,100,10,121,63,null,109,113,59,97,91,109,39,60,57,null,90,98,70,49,null,null,15,88,68,30,110,120,83,50,45,null,null,56,115,null,18,116,64,90,null,null,40,111,104,110,9,83,15,84,64,36,101,null,94,100,39,46,117,116,91,null,42,80,47,46,50,36,3,88,64,46,8,57,89,43,null,90,109,47,12,39,17,null,null,null,60,32,67,72,null,null,null,34,57,null,null,27,121,99,null,112,null,32,null,29,null,40,19,67,16,null,9,89,null,null,82,33,52,24,42,95,31,null,2,99,75,37,null,107,111,null,63,21,null,58,34,null,null,null,69,null,64,null,38,null,100,null,null,45,10,null,null,null,90,116,122,null,92,52,43,35,79,null,66,68,57,9,41}; + TreeNodePrintUtil.displayTree(TreeNode.fromArray(integerArray1)); + object.getLeaves(TreeNode.fromArray(integerArray1)); + for (int i : object.list) { + System.out.print(" " + i); + } + System.out.println(); +// Integer[] integerArray2 = {3,5,1,6,7,4,2,null,null,null,null,null,null,9,8}; + Integer[] integerArray2 = {3,5,1,6,71,4,2,null,null,null,null,null,null,9,8}; +// Integer[] integerArray2 = {85,25,40,null,9,null,null,13,null,22,112,112,null,60,89,64,18,91,92,97,null,null,94,90,55,117,33,65,107,111,113,null,44,null,null,18,27,null,106,77,3,null,83,null,null,null,null,52,55,32,null,46,92,74,51,8,32,55,32,null,111,29,null,25,46,63,82,null,15,102,70,61,13,42,30,91,79,2,null,90,null,null,122,62,null,null,66,66,111,63,24,null,76,6,null,33,45,42,69,null,10,21,6,96,79,33,57,null,16,72,122,13,1,29,104,29,29,66,null,41,122,60,5,73,2,16,110,10,39,null,null,122,null,34,88,69,64,38,100,89,109,null,45,10,90,116,122,92,52,null,43,35,79,64,null,66,68,null,57,9,41,null,null,104,34,57,9,null,27,null,121,99,112,null,32,null,null,40,null,null,19,67,16,9,89,82,null,95,52,null,24,42,33,null,31,2,99,75,37,21,58}; + TreeNodePrintUtil.displayTree(TreeNode.fromArray(integerArray2)); + object.list.clear(); + object.getLeaves(TreeNode.fromArray(integerArray2)); + for (int i : object.list) { + System.out.print(" " + i); + } + System.out.println(); + System.out.println(object.leafSimilar(TreeNode.fromArray(integerArray1), TreeNode.fromArray(integerArray2))); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_897_Increasing_Order_Search_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_897_Increasing_Order_Search_Tree.java new file mode 100644 index 0000000..f904b4b --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_897_Increasing_Order_Search_Tree.java @@ -0,0 +1,49 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; +import leetcodeNZ.util.TreeNodePrintUtil; + +/** + * @author Simon-the-coder + * @date 2/05/22 7:06 PM + */ +public class Tree_897_Increasing_Order_Search_Tree { + public TreeNode preNode; + public TreeNode tempNode; + + public TreeNode increasingBST(TreeNode root) { + if (root != null) { + increasingBST(root.left); + if (tempNode != null) { + tempNode.right = root; + } + tempNode = root; + root.left = null; + if (preNode == null) { + preNode = tempNode; + } + TreeNodePrintUtil.displayTree(preNode); + increasingBST(root.right); + } + return preNode; + } + + public static void main(String[] args) { + + TreeNode n4 = new TreeNode(4, null, null); + TreeNode n1 = new TreeNode(1, null, null); + TreeNode n7 = new TreeNode(7, null, null); + TreeNode n9 = new TreeNode(9, null, null); + TreeNode n8 = new TreeNode(8, n7, n9); + TreeNode n2 = new TreeNode(2, n1, null); + TreeNode n3 = new TreeNode(3, n2, n4); + TreeNode n6 = new TreeNode(6, null, n8); + TreeNode n5 = new TreeNode(5, n3, n6); + + TreeNodePrintUtil.displayTree(n5); + + Tree_897_Increasing_Order_Search_Tree obj = new Tree_897_Increasing_Order_Search_Tree(); + obj.increasingBST(n5); + TreeNodePrintUtil.displayTree(obj.preNode); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_938_Range_Sum_of_BST.java b/src/leetcodeNZ/tags/tree/easy/Tree_938_Range_Sum_of_BST.java new file mode 100644 index 0000000..45b7946 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_938_Range_Sum_of_BST.java @@ -0,0 +1,32 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; + +/** + * @author Simon-the-coder + * @date 1/05/22 6:36 PM + */ +public class Tree_938_Range_Sum_of_BST { + + private int sum = 0; + public int rangeSumBST(TreeNode root, int low, int high) { + if (root == null) return 0; + if (root.val >= low && root.val <= high) sum += root.val; + rangeSumBST(root.left, low, high); + rangeSumBST(root.right, low, high); + return sum; + } + + public static void main(String[] args) { + + TreeNode n3 = new TreeNode(3, null, null); + TreeNode n7 = new TreeNode(7, null, null); + TreeNode n5 = new TreeNode(5, n3, n7); + TreeNode n18 = new TreeNode(18, null, null); + TreeNode n15 = new TreeNode(15, null, n18); + TreeNode n10 = new TreeNode(10, n5, n15); + + Tree_938_Range_Sum_of_BST object = new Tree_938_Range_Sum_of_BST(); + object.rangeSumBST(n10, 7, 15); + } +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_94_Binary_Tree_Inorder_Traversal.java b/src/leetcodeNZ/tags/tree/easy/Tree_94_Binary_Tree_Inorder_Traversal.java new file mode 100644 index 0000000..bb5f500 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_94_Binary_Tree_Inorder_Traversal.java @@ -0,0 +1,70 @@ +package leetcodeNZ.tags.tree.easy; + +import java.util.ArrayList; +import java.util.List; +import java.util.Stack; + +import leetcodeNZ.model.TreeNode; + +/* + * Given a binary tree, return the inorder traversal of its nodes' values. + + Example: + + Input: [1,null,2,3] + 1 + \ + 2 + / + 3 + + Output: [1,3,2] + Follow up: Recursive solution is trivial, could you do it iteratively? + */ + +public class Tree_94_Binary_Tree_Inorder_Traversal { + + private String stackToString(Stack s) { + String result = ""; + + for(int i = 0; i < s.size(); i++) { + TreeNode node = s.get(i); + result += node.val + " "; + } + return result; + } + + public List inorderTraversal(TreeNode root) { + List list = new ArrayList<>(); + Stack s = new Stack<>(); + TreeNode currentNode = root; + boolean done = false; + while (!done) { + if (currentNode != null) { + s.push(currentNode); + currentNode = currentNode.left; + } else { + if (s.isEmpty()) { + done = true; + } else { + currentNode = s.pop(); + list.add(currentNode.val); + currentNode = currentNode.right; + } + } + } + return list; + } + + public static void main(String[] args) { + + int[] nums = {-10,-3,0,5,9}; + Tree_108_convert_sorted_array_to_binary_search_tree obj_108 = new Tree_108_convert_sorted_array_to_binary_search_tree(); + TreeNode node = obj_108.arrayToBinaryTree(nums); + + Tree_94_Binary_Tree_Inorder_Traversal obj_94 = new Tree_94_Binary_Tree_Inorder_Traversal(); + List list = obj_94.inorderTraversal(node); + System.out.println(list); + } + +} diff --git a/src/leetcodeNZ/tags/tree/easy/Tree_965_Univalued_Binary_Tree.java b/src/leetcodeNZ/tags/tree/easy/Tree_965_Univalued_Binary_Tree.java new file mode 100644 index 0000000..a130bac --- /dev/null +++ b/src/leetcodeNZ/tags/tree/easy/Tree_965_Univalued_Binary_Tree.java @@ -0,0 +1,35 @@ +package leetcodeNZ.tags.tree.easy; + +import leetcodeNZ.model.TreeNode; + +public class Tree_965_Univalued_Binary_Tree { + + private boolean isUnivalTree = true; + private int val; + + private void inOrder(TreeNode root) { + if (root == null) return; + if (root.val != val) { + isUnivalTree = false; + } + inOrder(root.left); + inOrder(root.right); + } + + public boolean isUnivalTree(TreeNode root) { + if (root == null) return false; + val = root.val; + inOrder(root); + return isUnivalTree; + } + + public static void main(String[] args) { + TreeNode second1 = new TreeNode(2, null, null); + TreeNode second2 = new TreeNode(2, null, null); + TreeNode second3 = new TreeNode(5, second1, second2); + TreeNode second4 = new TreeNode(2, null, null); + TreeNode second5 = new TreeNode(2, second3, second4); + Tree_965_Univalued_Binary_Tree object = new Tree_965_Univalued_Binary_Tree(); + System.out.println(object.isUnivalTree(second5)); + } +} diff --git a/src/leetcodeNZ/tags/tree/hard/Tree_1028_Recover_a_Tree_From_Preorder_Traversal.java b/src/leetcodeNZ/tags/tree/hard/Tree_1028_Recover_a_Tree_From_Preorder_Traversal.java new file mode 100644 index 0000000..166b483 --- /dev/null +++ b/src/leetcodeNZ/tags/tree/hard/Tree_1028_Recover_a_Tree_From_Preorder_Traversal.java @@ -0,0 +1,21 @@ +package leetcodeNZ.tags.tree.hard; + +import leetcodeNZ.model.TreeNode; + +public class Tree_1028_Recover_a_Tree_From_Preorder_Traversal { + public TreeNode recoverFromPreorder(String traversal) { + return null; + } + + public static void main(String[] args) { +// TreeNode second7 = new TreeNode(7, null, null); +// TreeNode second6 = new TreeNode(6, null, null); +// TreeNode second5 = new TreeNode(5, second6, second7); +// TreeNode second4 = new TreeNode(4, null, null); +// TreeNode second3 = new TreeNode(3, null, null); +// TreeNode second2 = new TreeNode(2, second3, second4); +// TreeNode second1 = new TreeNode(1, second2, second5); +// TreeNodePrintUtil.displayTree(second1); + Tree_1028_Recover_a_Tree_From_Preorder_Traversal object = new Tree_1028_Recover_a_Tree_From_Preorder_Traversal(); + } +} diff --git a/src/leetcodeNZ/util/TreeNodePrintUtil.java b/src/leetcodeNZ/util/TreeNodePrintUtil.java new file mode 100644 index 0000000..da58028 --- /dev/null +++ b/src/leetcodeNZ/util/TreeNodePrintUtil.java @@ -0,0 +1,52 @@ +package leetcodeNZ.util; + +import java.util.Stack; + +import leetcodeNZ.model.TreeNode; + +public class TreeNodePrintUtil { + public static void displayTree(TreeNode root) + { + Stack globalStack = new Stack(); + globalStack.push(root); + int emptyLeaf = 32; + boolean isRowEmpty = false; + System.out.println("****......................................................****"); + while(!isRowEmpty) + { + + Stack localStack = new Stack(); + isRowEmpty = true; + for(int j=0; j mapDimensionToLimitValue; + private static Map mapCost; + + private static List listDimension; + + private static String[] prepareInputtedData() { + System.out.println(FIRST_OUTPUT_TO_USER); + Scanner sc = new Scanner(System.in); + String str = sc.nextLine(); + String[] strIn = str.trim().split(SPACE); + + int amountOfInputtedArguments = strIn.length; + if (amountOfInputtedArguments < AMOUNT_OF_NUMBER_SHOULD_BE_INPUTTED) { + System.out.println(INSUFFICIENT_INPUT); + return null; + } + + if (amountOfInputtedArguments > AMOUNT_OF_NUMBER_SHOULD_BE_INPUTTED) { + System.out.println(INPUTTED_MORE_THAN_4_NUMBER); + return null; + } + + return strIn; + } + + public static void main(String[] args) { + + String[] inputtedData = prepareInputtedData(); + + if (inputtedData == null) { + return; + } + + int indexOfLastInputtedNumber = inputtedData.length - 1; + + double[] dimensionsArray = new double[3]; + + double weight = new Double(inputtedData[indexOfLastInputtedNumber]); + + for (int i = 0; i < dimensionsArray.length; i++) { + if (!isDouble(inputtedData[i])) { + System.out.println(INVALID_INPUT); + return; + } + dimensionsArray[i] = new Double(inputtedData[i]); + } + + initSolutionData(); + PackageCostV4 pc = new PackageCostV4(); + System.out.println(pc.packageCost(dimensionsArray, weight)); + } + + private static void initSolutionData() { + mapCost = new HashMap<>(); + mapCost.put(SMALL_PACKAGE, "$5.00"); + mapCost.put(MEDIUM_PACKAGE, "$7.50"); + mapCost.put(LARGE_PACKAGE, "$8.50"); + mapCost.put(INVALID_PACKAGE, "No solution"); + + listDimension = new ArrayList<>(); + listDimension.add("LENGTH"); + listDimension.add("BREADTH"); + listDimension.add("HEIGHT"); + + double[][] dimensionValues = { + {200.00, 300.00, 150.00}, // Small Length Breadth Height + {300.00, 400.00, 200.00}, // Medium Length Breadth Height + {400.00, 600.00, 250.00} // Large Length Breadth Height + }; + + mapDimensionToLimitValue = new HashMap<>(); + + for (int i = 0; i < dimensionValues.length; i++) { + double[] curDimension = dimensionValues[i]; + for (int j = 0; j < listDimension.size(); j++) { + mapDimensionToLimitValue.put(i + listDimension.get(j), curDimension[j]); + } + } + } + + private static boolean isDouble(String input) { + Pattern pattern= Pattern.compile("^(([1-9]{1}\\d*)|([0]{1}))(\\.(\\d){0,2})?$"); // Determine the regular expression for a 2-digit decimal number + Matcher match = pattern.matcher(input); + return match.matches(); + } + + private int packageTypeByDimension(double dimensionValue, String suffix) { + double smallPackageDimensionLimit = mapDimensionToLimitValue.get(SMALL_PACKAGE + suffix); + double mediumPackageDimensionLimit = mapDimensionToLimitValue.get(MEDIUM_PACKAGE + suffix); + double largePackageDimensionLimit = mapDimensionToLimitValue.get(LARGE_PACKAGE + suffix); + if (dimensionValue > 0 && dimensionValue <= smallPackageDimensionLimit) { + return SMALL_PACKAGE; + } else if (dimensionValue > smallPackageDimensionLimit && dimensionValue <= mediumPackageDimensionLimit) { + return MEDIUM_PACKAGE; + } else if (dimensionValue >= mediumPackageDimensionLimit && dimensionValue <= largePackageDimensionLimit) { + return LARGE_PACKAGE; + } else { + return INVALID_PACKAGE; + } + } + + private int checkPackageType(double[] inputtedDimension) { + + int sum = 0; + for(int i = 0; i < listDimension.size(); i++) { + int typeByDimension = packageTypeByDimension(inputtedDimension[i], listDimension.get(i)); + if (typeByDimension < 0) { + return INVALID_PACKAGE; + } + sum += typeByDimension; + } + + if (sum == 0) { + return SMALL_PACKAGE; + } else if (sum > 0 && sum <= 3) { + return MEDIUM_PACKAGE; + } else { + return LARGE_PACKAGE; + } + } + + /* + dimension[]: index 0 -> length, index 1 -> breadth, index 2 -> height + */ + private String packageCost(double inputtedDimensions[], double weight) { + double MAX_WEIGHT = 25.00; + if (weight > MAX_WEIGHT) { + return mapCost.get(INVALID_PACKAGE); + } + int packageType = checkPackageType(inputtedDimensions); + return mapCost.get(packageType); + } +} diff --git a/src/youTap/SecondHighestNumberInArray.java b/src/youTap/SecondHighestNumberInArray.java new file mode 100644 index 0000000..b77eeb0 --- /dev/null +++ b/src/youTap/SecondHighestNumberInArray.java @@ -0,0 +1,32 @@ +package youTap; + +/** + * @author Simon-the-coder + * @date 28/11/21 9:40 AM + */ +public class SecondHighestNumberInArray { + + public static void main(String[] args) { + int arr[] = { 100, 14, 46, 47, 94, 94, 52, 86, 36, 94, 89 }; + int largest = 0; + int secondLargest = 0; + + System.out.println("The given array is:"); + + for (int i = 0; i < arr.length; i++) { + System.out.print(arr[i] + " "); + if (arr[i] > secondLargest) { + if (arr[i] > largest) { + // the largest becomes the second largest and get a new value + secondLargest = largest; + largest = arr[i]; + } else { + secondLargest = arr[i]; + } + } + } + + System.out.println("\nSecond largest number is: " + secondLargest); + System.out.println("Largest Number is: " + largest); + } +}