基本数据结构-顺序表和链表！！！

---

一、内存

1. 计算机的作用

• 存储和运算：计算机存储和处理的数据都是基于二进制的。例如，电影文件以二进制形式存储，播放时通过软件和硬件进行解码和运算，最终呈现为画面和声音。

2. 如何计算 1 + 2 的结果？

• 过程：将 1 和 2 输入计算机，转换为二进制数据存储，通过加法器计算并返回结果。

3. 数据存储

• 内存：计算机将数据存储在内存中。内存空间有两个基本属性：
  • 大小：表示可以存储的数据范围。
  • 地址：用十六进制表示，用于定位内存中的数据。

4. 变量

• 定义：变量是内存中存储数据的引用。
• 示例：a = 10，a 是 10 所在内存空间的引用。

5. 数据类型占用内存大小

• 整型：4 字节
• 浮点型：8 字节
• 字符型：1 字节

---

二、顺序表

1. 定义

• 顺序表：集合中存储的元素是有顺序的，分为单数据类型和多数据类型。

2. 单数据类型

• 存储：例如 int a = 10, 20, 30，数据存储在连续的内存空间中。
• 获取数据：通过索引访问。

3. 多数据类型

• 存储：例如 li = [10, 'a', 96.5]，数据存储在连续的内存空间中，但每个元素的类型可以不同。
• 获取数据：通过索引访问。

4. 顺序表的弊端

• 固定大小：需要预先知道数据大小来申请连续的存储空间。
• 扩容困难：扩容时需要进行数据搬迁。

5. Python 中的顺序表

• 列表（list） 和 元组（tuple）：采用顺序表的实现技术。

---

三、链表

1. 定义

• 链表：一种线性表，数据存储在不连续的内存空间中，每个节点包含数据和指向下一个节点的指针。

2. 单向链表

（1）结构

• 每个节点包含：
  • 数据域：存储具体数据。
  • 链接域：存储下一个节点的地址。

（2）抽象数据类型

• 操作：
  • is_empty()：判断链表是否为空。
  • length()：返回链表长度。
  • travel()：遍历链表。
  • add(item)：头部添加元素。
  • append(item)：尾部添加元素。
  • insert(pos, item)：指定位置插入元素。
  • remove(item)：删除元素。
  • search(item)：查找元素是否存在。

（3）代码实现

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None

    def __str__(self):
        return str(self.item)


class Link:
    def __init__(self):
        self._head = None

    def is_empty(self):
        return self._head is None

    def add(self, item):
        node = Node(item)
        node.next = self._head
        self._head = node

    def length(self):
        count = 0
        cur = self._head
        while cur is not None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        cur = self._head
        while cur is not None:
            print(cur)
            cur = cur.next

    def append(self, item):
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            cur = self._head
            while cur.next is not None:
                cur = cur.next
            cur.next = node

    def search(self, item):
        cur = self._head
        while cur is not None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

    def insert(self, pos, item):
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            for _ in range(pos - 1):
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        pre = None
        cur = self._head
        while cur is not None:
            if cur.item == item:
                if pre is None:  # 删除头节点
                    self._head = cur.next
                else:  # 删除中间或尾节点
                    pre.next = cur.next
                return
            pre = cur
            cur = cur.next

（4）测试代码

link = Link()
link.add('bobo')
link.add('jay')
link.add('tom')
link.add('jerry')
print(link.search('tom'))  # True
link.insert(1, 'haha')
link.travel()  # 输出链表内容
link.remove('bobo')
link.travel()

---

3. 单向循环链表

（1）结构

• 最后一个节点的 next 指向头节点，形成循环。

（2）代码实现

class Node:
    def __init__(self, item):
        self.item = item
        self.next = None


class SinCycLinkedList:
    def __init__(self):
        self._head = None

    def is_empty(self):
        return self._head is None

    def length(self):
        if self.is_empty():
            return 0
        count = 1
        cur = self._head
        while cur.next != self._head:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        if self.is_empty():
            return
        cur = self._head
        while cur.next != self._head:
            print(cur.item)
            cur = cur.next
        print(cur.item)

    def add(self, item):
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            node.next = self._head
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            cur.next = node
            self._head = node

    def append(self, item):
        node = Node(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            cur.next = node
            node.next = self._head

    def insert(self, pos, item):
        if pos <= 0:
            self.add(item)
        elif pos >= self.length():
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            for _ in range(pos - 1):
                cur = cur.next
            node.next = cur.next
            cur.next = node

    def remove(self, item):
        if self.is_empty():
            return
        pre = None
        cur = self._head
        while cur.next != self._head:
            if cur.item == item:
                if pre is None:  # 删除头节点
                    rear = self._head
                    while rear.next != self._head:
                        rear = rear.next
                    rear.next = cur.next
                    self._head = cur.next
                else:  # 删除中间节点
                    pre.next = cur.next
                return
            pre = cur
            cur = cur.next
        if cur.item == item:  # 删除尾节点
            if pre is None:  # 只有一个节点
                self._head = None
            else:
                pre.next = self._head

    def search(self, item):
        if self.is_empty():
            return False
        cur = self._head
        while cur.next != self._head:
            if cur.item == item:
                return True
            cur = cur.next
        return cur.item == item

（3）测试代码

ll = SinCycLinkedList()
ll.add(1)
ll.add(2)
ll.append(3)
ll.insert(2, 4)
print("length:", ll.length())  # 4
ll.travel()  # 2 1 4 3
ll.remove(1)
print("length:", ll.length())  # 3
ll.travel()  # 2 4 3

---