Skip to content

Navigation Menu

Sign in
Appearance settings

Search code, repositories, users, issues, pull requests...

Provide feedback

We read every piece of feedback, and take your input very seriously.

Saved searches

Use saved searches to filter your results more quickly
Sign up
Appearance settings

Commit fbf52ee

Browse files
算法模板新增 typescript 版本代码
1 parent 4596847 commit fbf52ee

File tree

1 file changed

+264
-1
lines changed

1 file changed

+264
-1
lines changed

‎problems/算法模板.md

Lines changed: 264 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -394,7 +394,7 @@ var postorder = function (root, list) {
394394
```javascript
395395
var preorderTraversal = function (root) {
396396
let res = [];
397-
if (root === null) return rs;
397+
if (root === null) return res;
398398
let stack = [root],
399399
cur = null;
400400
while (stack.length) {
@@ -536,6 +536,269 @@ function backtracking(参数) {
536536
}
537537
```
538538

539+
TypeScript:
540+
541+
## 二分查找法
542+
543+
使用左闭右闭区间
544+
545+
```typescript
546+
var search = function (nums: number[], target: number): number {
547+
let left: number = 0, right: number = nums.length - 1;
548+
// 使用左闭右闭区间
549+
while (left <= right) {
550+
let mid: number = left + Math.floor((right - left)/2);
551+
if (nums[mid] > target) {
552+
right = mid - 1; // 去左面闭区间寻找
553+
} else if (nums[mid] < target) {
554+
left = mid + 1; // 去右面闭区间寻找
555+
} else {
556+
return mid;
557+
}
558+
}
559+
return -1;
560+
};
561+
```
562+
563+
使用左闭右开区间
564+
565+
```typescript
566+
var search = function (nums: number[], target: number): number {
567+
let left: number = 0, right: number = nums.length;
568+
// 使用左闭右开区间 [left, right)
569+
while (left < right) {
570+
let mid: number = left + Math.floor((right - left)/2);
571+
if (nums[mid] > target) {
572+
right = mid; // 去左面闭区间寻找
573+
} else if (nums[mid] < target) {
574+
left = mid + 1; // 去右面闭区间寻找
575+
} else {
576+
return mid;
577+
}
578+
}
579+
return -1;
580+
};
581+
```
582+
583+
## KMP
584+
585+
```typescript
586+
var kmp = function (next: number[], s: number): void {
587+
next[0] = -1;
588+
let j: number = -1;
589+
for(let i: number = 1; i < s.length; i++){
590+
while (j >= 0 && s[i] !== s[j + 1]) {
591+
j = next[j];
592+
}
593+
if (s[i] === s[j + 1]) {
594+
j++;
595+
}
596+
next[i] = j;
597+
}
598+
}
599+
```
600+
601+
## 二叉树
602+
603+
### 深度优先遍历(递归)
604+
605+
二叉树节点定义:
606+
607+
```typescript
608+
class TreeNode {
609+
val: number
610+
left: TreeNode | null
611+
right: TreeNode | null
612+
constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
613+
this.val = (val===undefined ? 0 : val)
614+
this.left = (left===undefined ? null : left)
615+
this.right = (right===undefined ? null : right)
616+
}
617+
}
618+
```
619+
620+
前序遍历(中左右):
621+
622+
```typescript
623+
var preorder = function (root: TreeNode | null, list: number[]): void {
624+
if (root === null) return;
625+
list.push(root.val); // 中
626+
preorder(root.left, list); // 左
627+
preorder(root.right, list); // 右
628+
}
629+
```
630+
631+
中序遍历(左中右):
632+
633+
```typescript
634+
var inorder = function (root: TreeNode | null, list: number[]): void {
635+
if (root === null) return;
636+
inorder(root.left, list); // 左
637+
list.push(root.val); // 中
638+
inorder(root.right, list); // 右
639+
}
640+
```
641+
642+
后序遍历(左右中):
643+
644+
```typescript
645+
var postorder = function (root: TreeNode | null, list: number[]): void {
646+
if (root === null) return;
647+
postorder(root.left, list); // 左
648+
postorder(root.right, list); // 右
649+
list.push(root.val); // 中
650+
}
651+
```
652+
653+
### 深度优先遍历(迭代)
654+
655+
前序遍历(中左右):
656+
657+
```typescript
658+
var preorderTraversal = function (root: TreeNode | null): number[] {
659+
let res: number[] = [];
660+
if (root === null) return res;
661+
let stack: TreeNode[] = [root],
662+
cur: TreeNode | null = null;
663+
while (stack.length) {
664+
cur = stack.pop();
665+
res.push(cur.val);
666+
cur.right && stack.push(cur.right);
667+
cur.left && stack.push(cur.left);
668+
}
669+
return res;
670+
};
671+
```
672+
673+
中序遍历(左中右):
674+
675+
```typescript
676+
var inorderTraversal = function (root: TreeNode | null): number[] {
677+
let res: number[] = [];
678+
if (root === null) return res;
679+
let stack: TreeNode[] = [];
680+
let cur: TreeNode | null = root;
681+
while (stack.length !== 0 || cur !== null) {
682+
if (cur !== null) {
683+
stack.push(cur);
684+
cur = cur.left;
685+
} else {
686+
cur = stack.pop();
687+
res.push(cur.val);
688+
cur = cur.right;
689+
}
690+
}
691+
return res;
692+
};
693+
```
694+
695+
后序遍历(左右中):
696+
697+
```typescript
698+
var postorderTraversal = function (root: TreeNode | null): number[] {
699+
let res: number[] = [];
700+
if (root === null) return res;
701+
let stack: TreeNode[] = [root];
702+
let cur: TreeNode | null = null;
703+
while (stack.length) {
704+
cur = stack.pop();
705+
res.push(cur.val);
706+
cur.left && stack.push(cur.left);
707+
cur.right && stack.push(cur.right);
708+
}
709+
return res.reverse()
710+
};
711+
```
712+
713+
### 广度优先遍历(队列)
714+
715+
```typescript
716+
var levelOrder = function (root: TreeNode | null): number[] {
717+
let res: number[] = [];
718+
if (root === null) return res;
719+
let queue: TreeNode[] = [root];
720+
while (queue.length) {
721+
let n: number = queue.length;
722+
let temp: number[] = [];
723+
for (let i: number = 0; i < n; i++) {
724+
let node: TreeNode = queue.shift();
725+
temp.push(node.val);
726+
node.left && queue.push(node.left);
727+
node.right && queue.push(node.right);
728+
}
729+
res.push(temp);
730+
}
731+
return res;
732+
};
733+
```
734+
735+
### 二叉树深度
736+
737+
```typescript
738+
var getDepth = function (node: TreNode | null): number {
739+
if (node === null) return 0;
740+
return 1 + Math.max(getDepth(node.left), getDepth(node.right));
741+
}
742+
```
743+
744+
### 二叉树节点数量
745+
746+
```typescript
747+
var countNodes = function (root: TreeNode | null): number {
748+
if (root === null) return 0;
749+
return 1 + countNodes(root.left) + countNodes(root.right);
750+
}
751+
```
752+
753+
## 回溯算法
754+
755+
```typescript
756+
function backtracking(参数) {
757+
if (终止条件) {
758+
存放结果;
759+
return;
760+
}
761+
762+
for (选择:本层集合中元素(树中节点孩子的数量就是集合的大小)) {
763+
处理节点;
764+
backtracking(路径,选择列表); // 递归
765+
回溯,撤销处理结果
766+
}
767+
}
768+
769+
```
770+
771+
## 并查集
772+
773+
```typescript
774+
let n: number = 1005; // 根据题意而定
775+
let father: number[] = new Array(n).fill(0);
776+
777+
// 并查集初始化
778+
function init () {
779+
for (int i: number = 0; i < n; ++i) {
780+
father[i] = i;
781+
}
782+
}
783+
// 并查集里寻根的过程
784+
function find (u: number): number {
785+
return u === father[u] ? u : father[u] = find(father[u]);
786+
}
787+
// 将v->u 这条边加入并查集
788+
function join(u: number, v: number) {
789+
u = find(u);
790+
v = find(v);
791+
if (u === v) return ;
792+
father[v] = u;
793+
}
794+
// 判断 u 和 v是否找到同一个根
795+
function same(u: number, v: number): boolean {
796+
u = find(u);
797+
v = find(v);
798+
return u === v;
799+
}
800+
```
801+
539802
Java:
540803

541804

0 commit comments

Comments
(0)

AltStyle によって変換されたページ (->オリジナル) /