重生回到Python编程能力下降一百倍的时代，这次我要成为Py之神（面向对象）

面向对象编程（OOP）是Python的核心特性之一，它通过类和对象的概念将数据与操作封装在一起，提升代码的可维护性和复用性。

---

Python面向对象基础

1. 类与对象

• 类：类的定义使用class关键字，是对象的蓝图。例如定义一个“学生”类：

  class Student:
      def __init__(self, name, age):  # 构造方法
          self.name = name
          self.age = age
      
      def study(self):  # 方法
          print(f"{self.name}正在学习")
  

• 对象：通过实例化类创建对象。例如：stu = Student("Alice", 20)。

2. 继承与多态

• 继承：子类继承父类的属性和方法。例如：

  class CollegeStudent(Student):
      def __init__(self, name, age, major):
          super().__init__(name, age)
          self.major = major
  

• 多态：同一方法在不同子类中表现不同行为，例如不同子类重写study()方法。

3. 封装

通过私有属性（如__private_var）限制直接访问，提供公共方法操作数据，增强安全性。

---

LeetCode题解

题目1：设计链表（LeetCode 707）

问题描述
实现链表类，支持插入、删除、访问等操作。

解题思路

• 定义链表节点类ListNode，包含val和next属性。
• 链表类MyLinkedList管理头节点和长度。

代码实现

class ListNode:
    def __init__(self, val=0, next=None):
        self.val = val
        self.next = next

class MyLinkedList:
    def __init__(self):
        self.dummy = ListNode()  # 虚拟头节点简化操作
        self.size = 0

    def get(self, index: int) -> int:
        if index < 0 or index >= self.size:
            return -1
        curr = self.dummy.next
        for _ in range(index):
            curr = curr.next
        return curr.val

    def addAtHead(self, val: int) -> None:
        self.addAtIndex(0, val)

    # 其他方法如addAtTail、addAtIndex、deleteAtIndex类似

复杂度分析

• 时间复杂度：get为O(n)，插入删除平均O(1)。
• 空间复杂度：O(n)。

---

题目2：最小栈（LeetCode 155）

问题描述
设计一个支持push、pop、top和getMin操作的栈。

解题思路

• 使用辅助栈记录当前最小值。
• 封装栈操作，确保时间复杂度为O(1)。

代码实现

class MinStack:
    def __init__(self):
        self.stack = []
        self.min_stack = []  # 辅助栈记录最小值

    def push(self, val: int) -> None:
        self.stack.append(val)
        if not self.min_stack or val <= self.min_stack[-1]:
            self.min_stack.append(val)

    def pop(self) -> None:
        if self.stack.pop() == self.min_stack[-1]:
            self.min_stack.pop()

    def top(self) -> int:
        return self.stack[-1]

    def getMin(self) -> int:
        return self.min_stack[-1]

复杂度分析
所有操作均为O(1)时间复杂度。

---

题目3：LRU缓存（LeetCode 146）

问题描述
设计LRU缓存机制，支持get和put操作，时间复杂度O(1)。

解题思路

• 使用哈希表快速查找节点。
• 双向链表维护访问顺序，最近访问的节点移到头部。

代码实现

class DLinkedNode:
    def __init__(self, key=0, value=0):
        self.key = key
        self.value = value
        self.prev = None
        self.next = None

class LRUCache:
    def __init__(self, capacity: int):
        self.cache = {}
        self.capacity = capacity
        self.head = DLinkedNode()
        self.tail = DLinkedNode()
        self.head.next = self.tail
        self.tail.prev = self.head

    def _add_node(self, node):
        # 将节点添加到头部
        node.prev = self.head
        node.next = self.head.next
        self.head.next.prev = node
        self.head.next = node

    def _remove_node(self, node):
        # 移除节点
        prev = node.prev
        new_next = node.next
        prev.next = new_next
        new_next.prev = prev

    def get(self, key: int) -> int:
        if key not in self.cache:
            return -1
        node = self.cache[key]
        self._remove_node(node)
        self._add_node(node)
        return node.value

    def put(self, key: int, value: int) -> None:
        if key in self.cache:
            self._remove_node(self.cache[key])
        new_node = DLinkedNode(key, value)
        self.cache[key] = new_node
        self._add_node(new_node)
        if len(self.cache) > self.capacity:
            # 删除尾部节点
            lru = self.tail.prev
            self._remove_node(lru)
            del self.cache[lru.key]

复杂度分析

• get和put均O(1)。

---