Skip to content

Commit a786a0b

Browse files
Zanger67Zanger67
committed
Additional work on tree topics list
1 parent a7dcb6c commit a786a0b

16 files changed

+1035
-59
lines changed

‎README.md

+64-59
Large diffs are not rendered by default.

‎markdowns/_339. Nested List Weight Sum.md

+137
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,137 @@
1+
# 339. [Nested List Weight Sum](<https://leetcode.com/problems/nested-list-weight-sum>)
2+
3+
*First completed: July 02, 2024*
4+
5+
*Last updated: July 02, 2024*
6+
7+
8+
> *To see the question prompt, click the title.*
9+
10+
**Topics:** Depth-First Search, Breadth-First Search
11+
12+
**AC %:** 83.833
13+
14+
15+
## Solutions
16+
17+
- [m339.c](<../my-submissions/m339.c>)
18+
- [m339.py](<../my-submissions/m339.py>)
19+
### C
20+
#### [m339.c](<../my-submissions/m339.c>)
21+
```C
22+
/**
23+
* *********************************************************************
24+
* // This is the interface that allows for creating nested lists.
25+
* // You should not implement it, or speculate about its implementation
26+
* *********************************************************************
27+
*
28+
* // Initializes an empty nested list and return a reference to the nested integer.
29+
* struct NestedInteger *NestedIntegerInit();
30+
*
31+
* // Return true if this NestedInteger holds a single integer, rather than a nested list.
32+
* bool NestedIntegerIsInteger(struct NestedInteger *);
33+
*
34+
* // Return the single integer that this NestedInteger holds, if it holds a single integer
35+
* // The result is undefined if this NestedInteger holds a nested list
36+
* int NestedIntegerGetInteger(struct NestedInteger *);
37+
*
38+
* // Set this NestedInteger to hold a single integer.
39+
* void NestedIntegerSetInteger(struct NestedInteger *ni, int value);
40+
*
41+
* // Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
42+
* void NestedIntegerAdd(struct NestedInteger *ni, struct NestedInteger *elem);
43+
*
44+
* // Return the nested list that this NestedInteger holds, if it holds a nested list
45+
* // The result is undefined if this NestedInteger holds a single integer
46+
* struct NestedInteger **NestedIntegerGetList(struct NestedInteger *);
47+
*
48+
* // Return the nested list's size that this NestedInteger holds, if it holds a nested list
49+
* // The result is undefined if this NestedInteger holds a single integer
50+
* int NestedIntegerGetListSize(struct NestedInteger *);
51+
* };
52+
*/
53+
int helper(struct NestedInteger* curr, int multiplier) {
54+
if (NestedIntegerIsInteger(curr)) {
55+
return multiplier * NestedIntegerGetInteger(curr);
56+
}
57+
58+
int lstSize = NestedIntegerGetListSize(curr);
59+
struct NestedInteger** lst = NestedIntegerGetList(curr);
60+
61+
int output = 0;
62+
for (int i = 0; i < lstSize; i++) {
63+
output += helper(lst[i], multiplier + 1);
64+
}
65+
66+
return output;
67+
}
68+
69+
int depthSum(struct NestedInteger** nestedList, int nestedListSize) {
70+
int output = 0;
71+
for (int i = 0; i < nestedListSize; i++) {
72+
output += helper(nestedList[i], 1);
73+
}
74+
return output;
75+
}
76+
```
77+
78+
### Python
79+
#### [m339.py](<../my-submissions/m339.py>)
80+
```Python
81+
# """
82+
# This is the interface that allows for creating nested lists.
83+
# You should not implement it, or speculate about its implementation
84+
# """
85+
#class NestedInteger:
86+
# def __init__(self, value=None):
87+
# """
88+
# If value is not specified, initializes an empty list.
89+
# Otherwise initializes a single integer equal to value.
90+
# """
91+
#
92+
# def isInteger(self):
93+
# """
94+
# @return True if this NestedInteger holds a single integer, rather than a nested list.
95+
# :rtype bool
96+
# """
97+
#
98+
# def add(self, elem):
99+
# """
100+
# Set this NestedInteger to hold a nested list and adds a nested integer elem to it.
101+
# :rtype void
102+
# """
103+
#
104+
# def setInteger(self, value):
105+
# """
106+
# Set this NestedInteger to hold a single integer equal to value.
107+
# :rtype void
108+
# """
109+
#
110+
# def getInteger(self):
111+
# """
112+
# @return the single integer that this NestedInteger holds, if it holds a single integer
113+
# Return None if this NestedInteger holds a nested list
114+
# :rtype int
115+
# """
116+
#
117+
# def getList(self):
118+
# """
119+
# @return the nested list that this NestedInteger holds, if it holds a nested list
120+
# Return None if this NestedInteger holds a single integer
121+
# :rtype List[NestedInteger]
122+
# """
123+
124+
class Solution:
125+
def depthSum(self, nestedList: List[NestedInteger]) -> int:
126+
def helper(multiplier: int, curr: NestedInteger) -> int :
127+
if curr.isInteger() :
128+
return multiplier * curr.getInteger()
129+
130+
output = 0
131+
for i in curr.getList() :
132+
output += helper(multiplier + 1, i)
133+
return output
134+
135+
return sum([helper(1, x) for x in nestedList])
136+
```
137+

‎markdowns/_341. Flatten Nested List Iterator.md

+129
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,129 @@
1+
# 341. [Flatten Nested List Iterator](<https://leetcode.com/problems/flatten-nested-list-iterator>)
2+
3+
*First completed: July 02, 2024*
4+
5+
*Last updated: July 02, 2024*
6+
7+
8+
> *To see the question prompt, click the title.*
9+
10+
**Topics:** Stack, Tree, Depth-First Search, Design, Queue, Iterator
11+
12+
**AC %:** 64.553
13+
14+
15+
I choose to use a private inner class in this instance since my approach does an initial parsing of the data to remove empty `NestedIntegers` (e.g. the test case of `[[[]]]`). By using an PIC, I can call that to host the data when I make recursive creations of this iterator, saving that overhead time of $n$ which could in a worst case situation could result in a $O(n^2)$ overhead for initialization costs alone.
16+
17+
Since what we're iterating through is a `NestedInteger`, I thought it would be most suiting to create an Iterator that is, like the data, nested. So, in the program, I keep a tab of any current *nested iterators*, using them to their fullest to DFS through the data.
18+
19+
## Solutions
20+
21+
- [m341.java](<../my-submissions/m341.java>)
22+
### Java
23+
#### [m341.java](<../my-submissions/m341.java>)
24+
```Java
25+
/**
26+
* // This is the interface that allows for creating nested lists.
27+
* // You should not implement it, or speculate about its implementation
28+
* public interface NestedInteger {
29+
*
30+
* // @return true if this NestedInteger holds a single integer, rather than a nested list.
31+
* public boolean isInteger();
32+
*
33+
* // @return the single integer that this NestedInteger holds, if it holds a single integer
34+
* // Return null if this NestedInteger holds a nested list
35+
* public Integer getInteger();
36+
*
37+
* // @return the nested list that this NestedInteger holds, if it holds a nested list
38+
* // Return empty list if this NestedInteger holds a single integer
39+
* public List<NestedInteger> getList();
40+
* }
41+
*/
42+
public class NestedIterator implements Iterator<Integer> {
43+
private List<NestedInteger> data;
44+
private dataManagement manager;
45+
public NestedIterator(List<NestedInteger> nestedList) {
46+
this.data = nestedList;
47+
48+
49+
// Parses data upon receiving it, recursively removing any
50+
// cases that are empty i.e. containing no integer values
51+
for (int i = data.size() - 1; i >= 0; i--) {
52+
if (isEmpty(data.get(i))) {
53+
data.remove(i);
54+
}
55+
}
56+
57+
// Assigns a managing private inner class so that the
58+
// recusive creations of "NestedIterators" don't revalidate
59+
// the data (checking and removing empty sub-NestedIntegers)
60+
this.manager = new dataManagement(nestedList);
61+
}
62+
63+
private boolean isEmpty(NestedInteger curr) {
64+
if (curr == null) {
65+
return true;
66+
}
67+
if (curr.isInteger()) {
68+
return false;
69+
}
70+
for (int i = curr.getList().size() - 1; i >= 0; i--) {
71+
if (isEmpty(curr.getList().get(i))) {
72+
curr.getList().remove(i);
73+
}
74+
}
75+
return curr.getList().size() == 0;
76+
}
77+
78+
@Override
79+
public Integer next() {
80+
return manager.next();
81+
}
82+
83+
@Override
84+
public boolean hasNext() {
85+
return manager.hasNext();
86+
}
87+
88+
private class dataManagement{
89+
private List<NestedInteger> data;
90+
private dataManagement curr;
91+
public dataManagement(List<NestedInteger> nestedList) {
92+
this.data = nestedList;
93+
}
94+
95+
public Integer next() {
96+
if (curr != null) {
97+
Integer output = curr.next();
98+
if (!curr.hasNext()) {
99+
curr = null;
100+
}
101+
return output;
102+
}
103+
104+
if (data.get(0).isInteger()) {
105+
Integer output = data.get(0).getInteger();
106+
data.remove(0);
107+
return output;
108+
}
109+
110+
curr = new dataManagement(data.get(0).getList());
111+
data.remove(0);
112+
return this.next();
113+
}
114+
115+
public boolean hasNext() {
116+
if ((data.size() == 0) && (curr == null))
117+
return false;
118+
return true;
119+
}
120+
}
121+
}
122+
123+
/**
124+
* Your NestedIterator object will be instantiated and called as such:
125+
* NestedIterator i = new NestedIterator(nestedList);
126+
* while (i.hasNext()) v[f()] = i.next();
127+
*/
128+
```
129+

0 commit comments

Comments
 (0)