Skip to content

Commit 1aa286d

Browse files
yanglbmeyanglbme
committed
feat: add solutions to lc problems: No.0382,0398
* No.0382.Linked List Random Node * No.0398.Random Pick Index
1 parent 1139bb9 commit 1aa286d

File tree

14 files changed

+744
-2
lines changed

14 files changed

+744
-2
lines changed

‎solution/0300-0399/0382.Linked List Random Node/README.md

Lines changed: 147 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -28,22 +28,168 @@ solution.getRandom();
2828

2929
<!-- 这里可写通用的实现逻辑 -->
3030

31+
蓄水池抽样问题。即从一个包含 n 个对象的列表 S 中随机选取 k 个对象，n 为一个非常大或者不知道的值。通常情况下，n 是一个非常大的值，大到无法一次性把所有列表 S 中的对象都放到内存中。我们这个问题是蓄水池抽样问题的一个特例，即 k=1。
32+
33+
**解法**：我们总是选择第一个对象，以 1/2 的概率选择第二个，以 1/3 的概率选择第三个，以此类推，以 1/m 的概率选择第 m 个对象。当该过程结束时，每一个对象具有相同的选中概率，即 1/n。
34+
35+
**证明**：第 m 个对象最终被选中的概率 P = `选择 m 的概率 × 其后面所有对象不被选择的概率`，即：
36+
37+
<img alt="" src="https://cdn.jsdelivr.net/gh/doocs/leetcode@main/solution/0300-0399/0382.Linked%20List%20Random%20Node/images/demo.gif"/>
38+
39+
思路同：[398. 随机数索引](/solution/0300-0399/0398.Random%20Pick%20Index/README.md)
40+
3141
<!-- tabs:start -->
3242

3343
### **Python3**
3444

3545
<!-- 这里可写当前语言的特殊实现逻辑 -->
3646

3747
```python
38-
48+
# Definition for singly-linked list.
49+
# class ListNode:
50+
# def __init__(self, val=0, next=None):
51+
# self.val = val
52+
# self.next = next
53+
class Solution:
54+
55+
def __init__(self, head: Optional[ListNode]):
56+
self.head = head
57+
58+
def getRandom(self) -> int:
59+
n = ans = 0
60+
head = self.head
61+
while head:
62+
n += 1
63+
x = random.randint(1, n)
64+
if n == x:
65+
ans = head.val
66+
head = head.next
67+
return ans
68+
69+
70+
# Your Solution object will be instantiated and called as such:
71+
# obj = Solution(head)
72+
# param_1 = obj.getRandom()
3973
```
4074

4175
### **Java**
4276

4377
<!-- 这里可写当前语言的特殊实现逻辑 -->
4478

4579
```java
80+
/**
81+
* Definition for singly-linked list.
82+
* public class ListNode {
83+
* int val;
84+
* ListNode next;
85+
* ListNode() {}
86+
* ListNode(int val) { this.val = val; }
87+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
88+
* }
89+
*/
90+
class Solution {
91+
private ListNode head;
92+
private Random random = new Random();
93+
94+
public Solution(ListNode head) {
95+
this.head = head;
96+
}
97+
98+
public int getRandom() {
99+
int ans = 0, n = 0;
100+
for (ListNode node = head; node != null; node = node.next) {
101+
++n;
102+
int x = 1 + random.nextInt(n);
103+
if (n == x) {
104+
ans = node.val;
105+
}
106+
}
107+
return ans;
108+
}
109+
}
110+
111+
/**
112+
* Your Solution object will be instantiated and called as such:
113+
* Solution obj = new Solution(head);
114+
* int param_1 = obj.getRandom();
115+
*/
116+
```
117+
118+
### **C++**
119+
120+
```cpp
121+
/**
122+
* Definition for singly-linked list.
123+
* struct ListNode {
124+
* int val;
125+
* ListNode *next;
126+
* ListNode() : val(0), next(nullptr) {}
127+
* ListNode(int x) : val(x), next(nullptr) {}
128+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
129+
* };
130+
*/
131+
class Solution {
132+
public:
133+
ListNode* head;
134+
135+
Solution(ListNode* head) {
136+
this->head = head;
137+
}
138+
139+
int getRandom() {
140+
int n = 0, ans = 0;
141+
for (ListNode* node = head; node != nullptr; node = node->next)
142+
{
143+
n += 1;
144+
int x = 1 + rand() % n;
145+
if (n == x) ans = node->val;
146+
}
147+
return ans;
148+
}
149+
};
150+
151+
/**
152+
* Your Solution object will be instantiated and called as such:
153+
* Solution* obj = new Solution(head);
154+
* int param_1 = obj->getRandom();
155+
*/
156+
```
46157

158+
### **Go**
159+
160+
```go
161+
/**
162+
* Definition for singly-linked list.
163+
* type ListNode struct {
164+
* Val int
165+
* Next *ListNode
166+
* }
167+
*/
168+
type Solution struct {
169+
head *ListNode
170+
}
171+
172+
func Constructor(head *ListNode) Solution {
173+
return Solution{head}
174+
}
175+
176+
func (this *Solution) GetRandom() int {
177+
n, ans := 0, 0
178+
for node := this.head; node != nil; node = node.Next {
179+
n++
180+
x := 1 + rand.Intn(n)
181+
if n == x {
182+
ans = node.Val
183+
}
184+
}
185+
return ans
186+
}
187+
188+
/**
189+
* Your Solution object will be instantiated and called as such:
190+
* obj := Constructor(head);
191+
* param_1 := obj.GetRandom();
192+
*/
47193
```
48194

49195
### **...**

‎solution/0300-0399/0382.Linked List Random Node/README_EN.md

Lines changed: 137 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -51,13 +51,149 @@ solution.getRandom(); // return 3
5151
### **Python3**
5252

5353
```python
54-
54+
# Definition for singly-linked list.
55+
# class ListNode:
56+
# def __init__(self, val=0, next=None):
57+
# self.val = val
58+
# self.next = next
59+
class Solution:
60+
61+
def __init__(self, head: Optional[ListNode]):
62+
self.head = head
63+
64+
def getRandom(self) -> int:
65+
n = ans = 0
66+
head = self.head
67+
while head:
68+
n += 1
69+
x = random.randint(1, n)
70+
if n == x:
71+
ans = head.val
72+
head = head.next
73+
return ans
74+
75+
76+
# Your Solution object will be instantiated and called as such:
77+
# obj = Solution(head)
78+
# param_1 = obj.getRandom()
5579
```
5680

5781
### **Java**
5882

5983
```java
84+
/**
85+
* Definition for singly-linked list.
86+
* public class ListNode {
87+
* int val;
88+
* ListNode next;
89+
* ListNode() {}
90+
* ListNode(int val) { this.val = val; }
91+
* ListNode(int val, ListNode next) { this.val = val; this.next = next; }
92+
* }
93+
*/
94+
class Solution {
95+
private ListNode head;
96+
private Random random = new Random();
97+
98+
public Solution(ListNode head) {
99+
this.head = head;
100+
}
101+
102+
public int getRandom() {
103+
int ans = 0, n = 0;
104+
for (ListNode node = head; node != null; node = node.next) {
105+
++n;
106+
int x = 1 + random.nextInt(n);
107+
if (n == x) {
108+
ans = node.val;
109+
}
110+
}
111+
return ans;
112+
}
113+
}
114+
115+
/**
116+
* Your Solution object will be instantiated and called as such:
117+
* Solution obj = new Solution(head);
118+
* int param_1 = obj.getRandom();
119+
*/
120+
```
121+
122+
### **C++**
123+
124+
```cpp
125+
/**
126+
* Definition for singly-linked list.
127+
* struct ListNode {
128+
* int val;
129+
* ListNode *next;
130+
* ListNode() : val(0), next(nullptr) {}
131+
* ListNode(int x) : val(x), next(nullptr) {}
132+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
133+
* };
134+
*/
135+
class Solution {
136+
public:
137+
ListNode* head;
138+
139+
Solution(ListNode* head) {
140+
this->head = head;
141+
}
142+
143+
int getRandom() {
144+
int n = 0, ans = 0;
145+
for (ListNode* node = head; node != nullptr; node = node->next)
146+
{
147+
n += 1;
148+
int x = 1 + rand() % n;
149+
if (n == x) ans = node->val;
150+
}
151+
return ans;
152+
}
153+
};
154+
155+
/**
156+
* Your Solution object will be instantiated and called as such:
157+
* Solution* obj = new Solution(head);
158+
* int param_1 = obj->getRandom();
159+
*/
160+
```
60161

162+
### **Go**
163+
164+
```go
165+
/**
166+
* Definition for singly-linked list.
167+
* type ListNode struct {
168+
* Val int
169+
* Next *ListNode
170+
* }
171+
*/
172+
type Solution struct {
173+
head *ListNode
174+
}
175+
176+
func Constructor(head *ListNode) Solution {
177+
return Solution{head}
178+
}
179+
180+
func (this *Solution) GetRandom() int {
181+
n, ans := 0, 0
182+
for node := this.head; node != nil; node = node.Next {
183+
n++
184+
x := 1 + rand.Intn(n)
185+
if n == x {
186+
ans = node.Val
187+
}
188+
}
189+
return ans
190+
}
191+
192+
/**
193+
* Your Solution object will be instantiated and called as such:
194+
* obj := Constructor(head);
195+
* param_1 := obj.GetRandom();
196+
*/
61197
```
62198

63199
### **...**

‎solution/0300-0399/0382.Linked List Random Node/Solution.cpp

Lines changed: 35 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,35 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* struct ListNode {
4+
* int val;
5+
* ListNode *next;
6+
* ListNode() : val(0), next(nullptr) {}
7+
* ListNode(int x) : val(x), next(nullptr) {}
8+
* ListNode(int x, ListNode *next) : val(x), next(next) {}
9+
* };
10+
*/
11+
class Solution {
12+
public:
13+
ListNode* head;
14+
15+
Solution(ListNode* head) {
16+
this->head = head;
17+
}
18+
19+
int getRandom() {
20+
int n = 0, ans = 0;
21+
for (ListNode* node = head; node != nullptr; node = node->next)
22+
{
23+
n += 1;
24+
int x = 1 + rand() % n;
25+
if (n == x) ans = node->val;
26+
}
27+
return ans;
28+
}
29+
};
30+
31+
/**
32+
* Your Solution object will be instantiated and called as such:
33+
* Solution* obj = new Solution(head);
34+
* int param_1 = obj->getRandom();
35+
*/

‎solution/0300-0399/0382.Linked List Random Node/Solution.go

Lines changed: 32 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,32 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* type ListNode struct {
4+
* Val int
5+
* Next *ListNode
6+
* }
7+
*/
8+
type Solution struct {
9+
head *ListNode
10+
}
11+
12+
func Constructor(head *ListNode) Solution {
13+
return Solution{head}
14+
}
15+
16+
func (this *Solution) GetRandom() int {
17+
n, ans := 0, 0
18+
for node := this.head; node != nil; node = node.Next {
19+
n++
20+
x := 1 + rand.Intn(n)
21+
if n == x {
22+
ans = node.Val
23+
}
24+
}
25+
return ans
26+
}
27+
28+
/**
29+
* Your Solution object will be instantiated and called as such:
30+
* obj := Constructor(head);
31+
* param_1 := obj.GetRandom();
32+
*/

0 commit comments

Comments
 (0)