xmengnet/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2024-12-27 01:46:31 +08:00
Code Issues Projects Releases Packages Wiki Activity Actions

build

Browse source
This commit is contained in:
krahets 2023-03-03 21:53:50 +08:00
parent e67aadb973
commit ac7ab1e01a
2 changed files with 218 additions and 10 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
chapter_computational_complexity/time_complexity.md
View file

@ -142,7 +142,7 @@ $$
```swift title=""
// 在某运行平台下
func algorithm(_ n: Int) {
func algorithm(n: Int) {
var a = 2 // 1 ns
a = a + 1 // 1 ns
a = a * 2 // 10 ns
@ -344,19 +344,19 @@ $$
```swift title=""
// 算法 A 时间复杂度：常数阶
func algorithmA(_ n: Int) {
func algorithmA(n: Int) {
print(0)
}
// 算法 B 时间复杂度：线性阶
func algorithmB(_ n: Int) {
func algorithmB(n: Int) {
for _ in 0 ..< n {
print(0)
}
}
// 算法 C 时间复杂度：常数阶
func algorithmC(_ n: Int) {
func algorithmC(n: Int) {
for _ in 0 ..< 1000000 {
print(0)
}
@ -1961,7 +1961,7 @@ $$
```swift title="time_complexity.swift"
/* 对数阶（循环实现） */
func logarithmic(n: Int) -> Int {
func logarithmic(n: Double) -> Int {
var count = 0
var n = n
while n > 1 {
@ -2076,7 +2076,7 @@ $$
```swift title="time_complexity.swift"
/* 对数阶（递归实现） */
func logRecur(n: Int) -> Int {
func logRecur(n: Double) -> Int {
if n <= 1 {
return 0
}
@ -2220,7 +2220,7 @@ $$
return 1
}
var count = linearLogRecur(n: n / 2) + linearLogRecur(n: n / 2)
for _ in 0 ..< Int(n) {
for _ in sequence(first: 0, next: { $0 < n - 1 ? $0 + 1 : nil }) {
count += 1
}
return count

214
chapter_stack_and_queue/deque.md
View file

@ -1687,14 +1687,222 @@ comments: true
=== "JavaScript"
```js title="array_deque.js"
[class]{ArrayDeque}-[func]{}
```javascript title="array_deque.js"
/* 基于环形数组实现的双向队列 */
class ArrayDeque {
#nums; // 用于存储双向队列元素的数组
#front; // 队首指针，指向队首元素
#queSize; // 双向队列长度
/* 构造方法 */
constructor(capacity) {
this.#nums = new Array(capacity);
this.#front = 0;
this.#queSize = 0;
}
/* 获取双向队列的容量 */
capacity() {
return this.#nums.length;
}
/* 获取双向队列的长度 */
size() {
return this.#queSize;
}
/* 判断双向队列是否为空 */
isEmpty() {
return this.#queSize === 0;
}
/* 计算环形数组索引 */
index(i) {
// 通过取余操作实现数组首尾相连
// 当 i 越过数组尾部后，回到头部
// 当 i 越过数组头部后，回到尾部
return (i + this.capacity()) % this.capacity();
}
/* 队首入队 */
pushFirst(num) {
if (this.#queSize === this.capacity()) {
console.log("双向队列已满");
return;
}
// 队首指针向左移动一位
// 通过取余操作，实现 front 越过数组头部后回到尾部
this.#front = this.index(this.#front - 1);
// 将 num 添加至队首
this.#nums[this.#front] = num;
this.#queSize++;
}
/* 队尾入队 */
pushLast(num) {
if (this.#queSize === this.capacity()) {
console.log("双向队列已满");
return;
}
// 计算尾指针，指向队尾索引 + 1
const rear = this.index(this.#front + this.#queSize);
// 将 num 添加至队尾
this.#nums[rear] = num;
this.#queSize++;
}
/* 队首出队 */
pollFirst() {
const num = this.peekFirst();
// 队首指针向后移动一位
this.#front = this.index(this.#front + 1);
this.#queSize--;
return num;
}
/* 队尾出队 */
pollLast() {
const num = this.peekLast();
this.#queSize--;
return num;
}
/* 访问队首元素 */
peekFirst() {
if (this.isEmpty())
throw new Error("The Deque Is Empty.");
return this.#nums[this.#front];
}
/* 访问队尾元素 */
peekLast() {
if (this.isEmpty())
throw new Error("The Deque Is Empty.");
// 计算尾元素索引
const last = this.index(this.#front + this.#queSize - 1);
return this.#nums[last];
}
/* 返回数组用于打印 */
toArray() {
// 仅转换有效长度范围内的列表元素
const res = [];
for (let i = 0, j = this.#front; i < this.#queSize; i++, j++) {
res[i] = this.#nums[this.index(j)];
}
return res;
}
}
```
=== "TypeScript"
```typescript title="array_deque.ts"
[class]{ArrayDeque}-[func]{}
/* 基于环形数组实现的双向队列 */
class ArrayDeque {
private nums: number[]; // 用于存储双向队列元素的数组
private front: number; // 队首指针，指向队首元素
private queSize: number; // 双向队列长度
/* 构造方法 */
constructor(capacity: number) {
this.nums = new Array(capacity);
this.front = 0;
this.queSize = 0;
}
/* 获取双向队列的容量 */
capacity(): number {
return this.nums.length;
}
/* 获取双向队列的长度 */
size(): number {
return this.queSize;
}
/* 判断双向队列是否为空 */
isEmpty(): boolean {
return this.queSize === 0;
}
/* 计算环形数组索引 */
index(i: number): number {
// 通过取余操作实现数组首尾相连
// 当 i 越过数组尾部后，回到头部
// 当 i 越过数组头部后，回到尾部
return (i + this.capacity()) % this.capacity();
}
/* 队首入队 */
pushFirst(num: number): void {
if (this.queSize === this.capacity()) {
console.log("双向队列已满");
return;
}
// 队首指针向左移动一位
// 通过取余操作，实现 front 越过数组头部后回到尾部
this.front = this.index(this.front - 1);
// 将 num 添加至队首
this.nums[this.front] = num;
this.queSize++;
}
/* 队尾入队 */
pushLast(num: number): void {
if (this.queSize === this.capacity()) {
console.log("双向队列已满");
return;
}
// 计算尾指针，指向队尾索引 + 1
const rear: number = this.index(this.front + this.queSize);
// 将 num 添加至队尾
this.nums[rear] = num;
this.queSize++;
}
/* 队首出队 */
pollFirst(): number {
const num: number = this.peekFirst();
// 队首指针向后移动一位
this.front = this.index(this.front + 1);
this.queSize--;
return num;
}
/* 队尾出队 */
pollLast(): number {
const num: number = this.peekLast();
this.queSize--;
return num;
}
/* 访问队首元素 */
peekFirst(): number {
if (this.isEmpty())
throw new Error("The Deque Is Empty.");
return this.nums[this.front];
}
/* 访问队尾元素 */
peekLast(): number {
if (this.isEmpty())
throw new Error("The Deque Is Empty.");
// 计算尾元素索引
const last = this.index(this.front + this.queSize - 1);
return this.nums[last];
}
/* 返回数组用于打印 */
toArray(): number[] {
// 仅转换有效长度范围内的列表元素
const res: number[] = [];
for (let i = 0, j = this.front; i < this.queSize; i++, j++) {
res[i] = this.nums[this.index(j)];
}
return res;
}
}
```
=== "C"