algorithm/hello-algo
1
0
Fork 0
mirror of https://github.com/krahets/hello-algo.git synced 2025-07-06 22:34:18 +08:00
Code Issues Packages Projects Releases Wiki Activity

Update code style for Python

Browse Source
This commit is contained in:
krahets
2023-03-03 03:07:22 +08:00
parent 7e9e6b000c
commit 7c501140f0
45 changed files with 274 additions and 266 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
codes/python/chapter_stack_and_queue/array_deque.py
View File

@ -8,37 +8,37 @@ import os.path as osp
import sys
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" 基于环形数组实现的双向队列 """
class ArrayDeque:
""" 构造方法 """
""" 基于环形数组实现的双向队列 """
def __init__(self, capacity):
""" 构造方法 """
self.nums = [0] * capacity
self.front = 0
self.que_size = 0
""" 获取双向队列的容量 """
def capacity(self):
""" 获取双向队列的容量 """
return len(self.nums)
""" 获取双向队列的长度 """
def size(self):
""" 获取双向队列的长度 """
return self.que_size
""" 判断双向队列是否为空 """
def is_empty(self):
""" 判断双向队列是否为空 """
return self.que_size == 0
""" 计算环形数组索引 """
def index(self, i):
""" 计算环形数组索引 """
# 通过取余操作实现数组首尾相连
# 当 i 越过数组尾部后，回到头部
# 当 i 越过数组头部后，回到尾部
return (i + self.capacity()) % self.capacity()
""" 队首入队 """
def push_first(self, num):
""" 队首入队 """
if self.que_size == self.capacity():
print("双向队列已满")
return
@ -49,8 +49,8 @@ class ArrayDeque:
self.nums[self.front] = num
self.que_size += 1
""" 队尾入队 """
def push_last(self, num):
""" 队尾入队 """
if self.que_size == self.capacity():
print("双向队列已满")
return
@ -60,34 +60,34 @@ class ArrayDeque:
self.nums[rear] = num
self.que_size += 1
""" 队首出队 """
def poll_first(self):
""" 队首出队 """
num = self.peek_first()
# 队首指针向后移动一位
self.front = self.index(self.front+1)
self.que_size -= 1
return num
""" 队尾出队 """
def poll_last(self):
""" 队尾出队 """
num = self.peek_last()
self.que_size -= 1
return num
""" 访问队首元素 """
def peek_first(self):
""" 访问队首元素 """
assert not self.is_empty(), "双向队列为空"
return self.nums[self.front]
""" 访问队尾元素 """
def peek_last(self):
""" 访问队尾元素 """
assert not self.is_empty(), "双向队列为空"
# 计算尾元素索引
last = self.index(self.front + self.que_size - 1)
return self.nums[last]
""" 返回数组用于打印 """
def to_array(self):
""" 返回数组用于打印 """
# 仅转换有效长度范围内的列表元素
res = []
for i in range(self.que_size):

19
codes/python/chapter_stack_and_queue/array_queue.py
View File

@ -8,29 +8,30 @@ import os.path as osp
import sys
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" 基于环形数组实现的队列 """
class ArrayQueue:
""" 基于环形数组实现的队列 """
def __init__(self, size):
""" 构造方法 """
self.__nums = [0] * size # 用于存储队列元素的数组
self.__front = 0 # 队首指针，指向队首元素
self.__size = 0 # 队列长度
""" 获取队列的容量 """
def capacity(self):
""" 获取队列的容量 """
return len(self.__nums)
""" 获取队列的长度 """
def size(self):
""" 获取队列的长度 """
return self.__size
""" 判断队列是否为空 """
def is_empty(self):
""" 判断队列是否为空 """
return self.__size == 0
""" 入队 """
def push(self, num):
""" 入队 """
assert self.__size < self.capacity(), "队列已满"
# 计算尾指针，指向队尾索引 + 1
# 通过取余操作，实现 rear 越过数组尾部后回到头部
@ -39,21 +40,21 @@ class ArrayQueue:
self.__nums[rear] = num
self.__size += 1
""" 出队 """
def poll(self):
""" 出队 """
num = self.peek()
# 队首指针向后移动一位，若越过尾部则返回到数组头部
self.__front = (self.__front + 1) % self.capacity()
self.__size -= 1
return num
""" 访问队首元素 """
def peek(self):
""" 访问队首元素 """
assert not self.is_empty(), "队列为空"
return self.__nums[self.__front]
""" 返回列表用于打印 """
def to_list(self):
""" 返回列表用于打印 """
res = [0] * self.size()
j = self.__front
for i in range(self.size()):

17
codes/python/chapter_stack_and_queue/array_stack.py
View File

@ -6,37 +6,38 @@ Author: Peng Chen (pengchzn@gmail.com)
import sys, os.path as osp
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" 基于数组实现的栈 """
class ArrayStack:
""" 基于数组实现的栈 """
def __init__(self):
""" 构造方法 """
self.__stack = []
""" 获取栈的长度 """
def size(self):
""" 获取栈的长度 """
return len(self.__stack)
""" 判断栈是否为空 """
def is_empty(self):
""" 判断栈是否为空 """
return self.__stack == []
""" 入栈 """
def push(self, item):
""" 入栈 """
self.__stack.append(item)
""" 出栈 """
def pop(self):
""" 出栈 """
assert not self.is_empty(), "栈为空"
return self.__stack.pop()
""" 访问栈顶元素 """
def peek(self):
""" 访问栈顶元素 """
assert not self.is_empty(), "栈为空"
return self.__stack[-1]
""" 返回列表用于打印 """
def to_list(self):
""" 返回列表用于打印 """
return self.__stack

2
codes/python/chapter_stack_and_queue/deque.py
View File

@ -8,7 +8,7 @@ import os.path as osp
import sys
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
from collections import deque

31
codes/python/chapter_stack_and_queue/linkedlist_deque.py
View File

@ -8,32 +8,33 @@ import os.path as osp
import sys
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" 双向链表结点 """
class ListNode:
""" 双向链表结点 """
def __init__(self, val):
""" 构造方法 """
self.val = val
self.next = None # 后继结点引用（指针）
self.prev = None # 前驱结点引用（指针）
""" 基于双向链表实现的双向队列 """
class LinkedListDeque:
""" 构造方法 """
""" 基于双向链表实现的双向队列 """
def __init__(self):
""" 构造方法 """
self.front, self.rear = None, None # 头结点 front ，尾结点 rear
self.__size = 0 # 双向队列的长度
""" 获取双向队列的长度 """
def size(self):
""" 获取双向队列的长度 """
return self.__size
""" 判断双向队列是否为空 """
def is_empty(self):
""" 判断双向队列是否为空 """
return self.size() == 0
""" 入队操作 """
def push(self, num, is_front):
""" 入队操作 """
node = ListNode(num)
# 若链表为空，则令 front, rear 都指向 node
if self.is_empty():
@ -52,16 +53,16 @@ class LinkedListDeque:
self.rear = node # 更新尾结点
self.__size += 1 # 更新队列长度
""" 队首入队 """
def push_first(self, num):
""" 队首入队 """
self.push(num, True)
""" 队尾入队 """
def push_last(self, num):
""" 队尾入队 """
self.push(num, False)
""" 出队操作 """
def poll(self, is_front):
""" 出队操作 """
# 若队列为空，直接返回 None
if self.is_empty():
return None
@ -86,24 +87,24 @@ class LinkedListDeque:
self.__size -= 1 # 更新队列长度
return val
""" 队首出队 """
def poll_first(self):
""" 队首出队 """
return self.poll(True)
""" 队尾出队 """
def poll_last(self):
""" 队尾出队 """
return self.poll(False)
""" 访问队首元素 """
def peek_first(self):
""" 访问队首元素 """
return None if self.is_empty() else self.front.val
""" 访问队尾元素 """
def peek_last(self):
""" 访问队尾元素 """
return None if self.is_empty() else self.rear.val
""" 返回数组用于打印 """
def to_array(self):
""" 返回数组用于打印 """
node = self.front
res = [0] * self.size()
for i in range(self.size()):

17
codes/python/chapter_stack_and_queue/linkedlist_queue.py
View File

@ -8,25 +8,26 @@ import os.path as osp
import sys
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" 基于链表实现的队列 """
class LinkedListQueue:
""" 基于链表实现的队列 """
def __init__(self):
""" 构造方法 """
self.__front = None # 头结点 front
self.__rear = None # 尾结点 rear
self.__size = 0
""" 获取队列的长度 """
def size(self):
""" 获取队列的长度 """
return self.__size
""" 判断队列是否为空 """
def is_empty(self):
""" 判断队列是否为空 """
return not self.__front
""" 入队 """
def push(self, num):
""" 入队 """
# 尾结点后添加 num
node = ListNode(num)
# 如果队列为空，则令头、尾结点都指向该结点
@ -39,23 +40,23 @@ class LinkedListQueue:
self.__rear = node
self.__size += 1
""" 出队 """
def poll(self):
""" 出队 """
num = self.peek()
# 删除头结点
self.__front = self.__front.next
self.__size -= 1
return num
""" 访问队首元素 """
def peek(self):
""" 访问队首元素 """
if self.size() == 0:
print("队列为空")
return False
return self.__front.val
""" 转化为列表用于打印 """
def to_list(self):
""" 转化为列表用于打印 """
queue = []
temp = self.__front
while temp:

17
codes/python/chapter_stack_and_queue/linkedlist_stack.py
View File

@ -6,44 +6,45 @@ Author: Peng Chen (pengchzn@gmail.com)
import sys, os.path as osp
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" 基于链表实现的栈 """
class LinkedListStack:
""" 基于链表实现的栈 """
def __init__(self):
""" 构造方法 """
self.__peek = None
self.__size = 0
""" 获取栈的长度 """
def size(self):
""" 获取栈的长度 """
return self.__size
""" 判断栈是否为空 """
def is_empty(self):
""" 判断栈是否为空 """
return not self.__peek
""" 入栈 """
def push(self, val):
""" 入栈 """
node = ListNode(val)
node.next = self.__peek
self.__peek = node
self.__size += 1
""" 出栈 """
def pop(self):
""" 出栈 """
num = self.peek()
self.__peek = self.__peek.next
self.__size -= 1
return num
""" 访问栈顶元素 """
def peek(self):
""" 访问栈顶元素 """
# 判空处理
if not self.__peek: return None
return self.__peek.val
""" 转化为列表用于打印 """
def to_list(self):
""" 转化为列表用于打印 """
arr = []
node = self.__peek
while node:

2
codes/python/chapter_stack_and_queue/queue.py
View File

@ -8,7 +8,7 @@ import os.path as osp
import sys
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" Driver Code """

2
codes/python/chapter_stack_and_queue/stack.py
View File

@ -6,7 +6,7 @@ Author: Peng Chen (pengchzn@gmail.com)
import sys, os.path as osp
sys.path.append(osp.dirname(osp.dirname(osp.abspath(__file__))))
from include import *
from modules import *
""" Driver Code """