Skip to content

Commit bb18300

Browse files
YangFongYangFong
committed
feat: add solutions to lc problem: No.0092,0100,0462
- No.0092.Reverse Linked List II - No.0100.Same Tree - No.0462.Minimum Moves to Equal Array Elements II
1 parent f9c15f7 commit bb18300

File tree

11 files changed

+652
-0
lines changed

11 files changed

+652
-0
lines changed

‎solution/0000-0099/0092.Reverse Linked List II/README.md

+46
Original file line numberDiff line numberDiff line change
@@ -237,6 +237,52 @@ public class Solution {
237237
}
238238
```
239239

240+
### **TypeScript**
241+
242+
```ts
243+
/**
244+
* Definition for singly-linked list.
245+
* class ListNode {
246+
* val: number
247+
* next: ListNode | null
248+
* constructor(val?: number, next?: ListNode | null) {
249+
* this.val = (val===undefined ? 0 : val)
250+
* this.next = (next===undefined ? null : next)
251+
* }
252+
* }
253+
*/
254+
255+
function reverseBetween(
256+
head: ListNode | null,
257+
left: number,
258+
right: number,
259+
): ListNode | null {
260+
const n = right - left;
261+
if (n === 0) {
262+
return head;
263+
}
264+
265+
const dummy = new ListNode(0, head);
266+
let pre = null;
267+
let cur = dummy;
268+
for (let i = 0; i < left; i++) {
269+
pre = cur;
270+
cur = cur.next;
271+
}
272+
const h = pre;
273+
pre = null;
274+
for (let i = 0; i <= n; i++) {
275+
const next = cur.next;
276+
cur.next = pre;
277+
pre = cur;
278+
cur = next;
279+
}
280+
h.next.next = cur;
281+
h.next = pre;
282+
return dummy.next;
283+
}
284+
```
285+
240286
### **...**
241287

242288
```

‎solution/0000-0099/0092.Reverse Linked List II/README_EN.md

+46
Original file line numberDiff line numberDiff line change
@@ -226,6 +226,52 @@ public class Solution {
226226
}
227227
```
228228

229+
### **TypeScript**
230+
231+
```ts
232+
/**
233+
* Definition for singly-linked list.
234+
* class ListNode {
235+
* val: number
236+
* next: ListNode | null
237+
* constructor(val?: number, next?: ListNode | null) {
238+
* this.val = (val===undefined ? 0 : val)
239+
* this.next = (next===undefined ? null : next)
240+
* }
241+
* }
242+
*/
243+
244+
function reverseBetween(
245+
head: ListNode | null,
246+
left: number,
247+
right: number,
248+
): ListNode | null {
249+
const n = right - left;
250+
if (n === 0) {
251+
return head;
252+
}
253+
254+
const dummy = new ListNode(0, head);
255+
let pre = null;
256+
let cur = dummy;
257+
for (let i = 0; i < left; i++) {
258+
pre = cur;
259+
cur = cur.next;
260+
}
261+
const h = pre;
262+
pre = null;
263+
for (let i = 0; i <= n; i++) {
264+
const next = cur.next;
265+
cur.next = pre;
266+
pre = cur;
267+
cur = next;
268+
}
269+
h.next.next = cur;
270+
h.next = pre;
271+
return dummy.next;
272+
}
273+
```
274+
229275
### **...**
230276

231277
```

‎solution/0000-0099/0092.Reverse Linked List II/Solution.ts

+41
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,41 @@
1+
/**
2+
* Definition for singly-linked list.
3+
* class ListNode {
4+
* val: number
5+
* next: ListNode | null
6+
* constructor(val?: number, next?: ListNode | null) {
7+
* this.val = (val===undefined ? 0 : val)
8+
* this.next = (next===undefined ? null : next)
9+
* }
10+
* }
11+
*/
12+
13+
function reverseBetween(
14+
head: ListNode | null,
15+
left: number,
16+
right: number,
17+
): ListNode | null {
18+
const n = right - left;
19+
if (n === 0) {
20+
return head;
21+
}
22+
23+
const dummy = new ListNode(0, head);
24+
let pre = null;
25+
let cur = dummy;
26+
for (let i = 0; i < left; i++) {
27+
pre = cur;
28+
cur = cur.next;
29+
}
30+
const h = pre;
31+
pre = null;
32+
for (let i = 0; i <= n; i++) {
33+
const next = cur.next;
34+
cur.next = pre;
35+
pre = cur;
36+
cur = next;
37+
}
38+
h.next.next = cur;
39+
h.next = pre;
40+
return dummy.next;
41+
}

‎solution/0100-0199/0100.Same Tree/README.md

+194
Original file line numberDiff line numberDiff line change
@@ -360,6 +360,200 @@ var isSameTree = function (p, q) {
360360
};
361361
```
362362

363+
### **TypeScript**
364+
365+
```ts
366+
/**
367+
* Definition for a binary tree node.
368+
* class TreeNode {
369+
* val: number
370+
* left: TreeNode | null
371+
* right: TreeNode | null
372+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
373+
* this.val = (val===undefined ? 0 : val)
374+
* this.left = (left===undefined ? null : left)
375+
* this.right = (right===undefined ? null : right)
376+
* }
377+
* }
378+
*/
379+
380+
function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
381+
if (p == null && q == null) {
382+
return true;
383+
}
384+
if (p == null || q == null || p.val !== q.val) {
385+
return false;
386+
}
387+
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
388+
}
389+
```
390+
391+
```ts
392+
/**
393+
* Definition for a binary tree node.
394+
* class TreeNode {
395+
* val: number
396+
* left: TreeNode | null
397+
* right: TreeNode | null
398+
* constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
399+
* this.val = (val===undefined ? 0 : val)
400+
* this.left = (left===undefined ? null : left)
401+
* this.right = (right===undefined ? null : right)
402+
* }
403+
* }
404+
*/
405+
406+
function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
407+
const queue = [];
408+
p && queue.push(p);
409+
q && queue.push(q);
410+
if (queue.length === 1) {
411+
return false;
412+
}
413+
while (queue.length !== 0) {
414+
const node1 = queue.shift();
415+
const node2 = queue.shift();
416+
if (node1.val !== node2.val) {
417+
return false;
418+
}
419+
if (
420+
(node1.left == null && node2.left != null) ||
421+
(node1.left != null && node2.left == null)
422+
) {
423+
return false;
424+
}
425+
if (
426+
(node1.right == null && node2.right != null) ||
427+
(node1.right != null && node2.right == null)
428+
) {
429+
return false;
430+
}
431+
432+
if (node1.left != null) {
433+
queue.push(node1.left);
434+
queue.push(node2.left);
435+
}
436+
if (node1.right != null) {
437+
queue.push(node1.right);
438+
queue.push(node2.right);
439+
}
440+
}
441+
return true;
442+
}
443+
```
444+
445+
### **Rust**
446+
447+
```rust
448+
// Definition for a binary tree node.
449+
// #[derive(Debug, PartialEq, Eq)]
450+
// pub struct TreeNode {
451+
// pub val: i32,
452+
// pub left: Option<Rc<RefCell<TreeNode>>>,
453+
// pub right: Option<Rc<RefCell<TreeNode>>>,
454+
// }
455+
//
456+
// impl TreeNode {
457+
// #[inline]
458+
// pub fn new(val: i32) -> Self {
459+
// TreeNode {
460+
// val,
461+
// left: None,
462+
// right: None
463+
// }
464+
// }
465+
// }
466+
use std::rc::Rc;
467+
use std::cell::RefCell;
468+
impl Solution {
469+
fn dfs(p: &Option<Rc<RefCell<TreeNode>>>, q: &Option<Rc<RefCell<TreeNode>>>) -> bool {
470+
if p.is_none() && q.is_none() {
471+
return true;
472+
}
473+
if p.is_none() || q.is_none() {
474+
return false;
475+
}
476+
let r1 = p.as_ref().unwrap().borrow();
477+
let r2 = q.as_ref().unwrap().borrow();
478+
r1.val == r2.val && Self::dfs(&r1.left, &r2.left) && Self::dfs(&r1.right, &r2.right)
479+
}
480+
481+
pub fn is_same_tree(
482+
p: Option<Rc<RefCell<TreeNode>>>,
483+
q: Option<Rc<RefCell<TreeNode>>>,
484+
) -> bool {
485+
Self::dfs(&p, &q)
486+
}
487+
}
488+
```
489+
490+
```rust
491+
// Definition for a binary tree node.
492+
// #[derive(Debug, PartialEq, Eq)]
493+
// pub struct TreeNode {
494+
// pub val: i32,
495+
// pub left: Option<Rc<RefCell<TreeNode>>>,
496+
// pub right: Option<Rc<RefCell<TreeNode>>>,
497+
// }
498+
//
499+
// impl TreeNode {
500+
// #[inline]
501+
// pub fn new(val: i32) -> Self {
502+
// TreeNode {
503+
// val,
504+
// left: None,
505+
// right: None
506+
// }
507+
// }
508+
// }
509+
use std::rc::Rc;
510+
use std::cell::RefCell;
511+
use std::collections::VecDeque;
512+
impl Solution {
513+
pub fn is_same_tree(
514+
mut p: Option<Rc<RefCell<TreeNode>>>,
515+
mut q: Option<Rc<RefCell<TreeNode>>>,
516+
) -> bool {
517+
let mut queue = VecDeque::new();
518+
if p.is_some() {
519+
queue.push_back(p.take());
520+
}
521+
if q.is_some() {
522+
queue.push_back(q.take());
523+
}
524+
if queue.len() == 1 {
525+
return false;
526+
}
527+
while queue.len() != 0 {
528+
if let (Some(mut node1), Some(mut node2)) = (queue.pop_front(), queue.pop_front()) {
529+
let mut node1 = node1.as_mut().unwrap().borrow_mut();
530+
let mut node2 = node2.as_mut().unwrap().borrow_mut();
531+
if node1.val != node2.val {
532+
return false;
533+
}
534+
match (node1.left.is_some(), node2.left.is_some()) {
535+
(false, false) => {}
536+
(true, true) => {
537+
queue.push_back(node1.left.take());
538+
queue.push_back(node2.left.take());
539+
}
540+
(_, _) => return false,
541+
}
542+
match (node1.right.is_some(), node2.right.is_some()) {
543+
(false, false) => {}
544+
(true, true) => {
545+
queue.push_back(node1.right.take());
546+
queue.push_back(node2.right.take());
547+
}
548+
(_, _) => return false,
549+
}
550+
}
551+
}
552+
true
553+
}
554+
}
555+
```
556+
363557
### **...**
364558

365559
```

0 commit comments

Comments
 (0)