1-数据结构与算法-顺序表和链表

内存

• 计算机的作用
  • 用来存储和运算二进制的数据

import numpy as np
np.iinfo('int8')

iinfo(min=-128, max=127, dtype=int8)

• 变量的概念
  • 就是表示计算机中的某一块内存。
  • a = 10
  • 计算机的某一块内存空间会有两个原始的属性
    • 大小：决定该块内存最大存储多大的数值
    • 地址：16进制的数表示。作用就是可以根据16进制的地址在整个计算机内存定位到制定唯一的内存空间。

• 理解a=10的内存图（引用，指向）
  • 引用：在面向对象的编程语言中变量就是引用。
  • 指向：如果一个变量表示了某块内存，则成为该引用/变量指向了该块内存
    • 如果一个变量指向某块内存，则该变量就可以表示该块内存空间中存储的数据值

顺序表

• 集合中存储的元素是有顺序的，顺序表的结构可以分为两种形式：单数据类型 (np数组)和多数据类型。
• python中的列表和元组就属于多数据类型的顺序表

• 顺序表的弊端：顺序表的结构需要预先知道数据大小来申请连续的存储空间，而在进行扩充时又需要进行数据的搬迁。

链表

• 相对于顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理且进行扩充时不需要进行数据搬迁
• 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）

节点数据结构的封装

# 节点数据结构的封装
class Node():
    def __init__(self,item):
        self.item = item
        self.next = None

• . is_empty()：链表是否为空
• . length()：链表长度
• . travel()：遍历整个链表
• . add(item)：链表头部添加元素
• . append(item)：链表尾部添加元素
• . insert(pos, item)：指定位置添加元素
• . remove(item)：删除节点
• . search(item)：查找节点是否存在

class Link():
    def __init__(self): # 构建一个空的链表
        self._head = None # 只可以指向第一个节点
    
    # 链表头部添加元素
    def add(self,item):
        node = Node(item) # 创建一个新的节点
        node.next = self._head # 让新的第一个节点连接以前的第一个节点
        self._head = node # 让空链表连接新的第一个节点
        
    # 遍历整个链表
    def travel(self):
#         print(self._head.item)
#         print(self._head.next.item)
#         print(self._head.next.next.item) # ...
        cur = self._head
        while cur:
            print(cur.item)
            cur = cur.next
            
    # 查看链表长度        
    def length(self):
        count = 0
        cur = self._head
        while cur:
            count += 1
            cur = cur.next
        return count
    
    # 判断列表是否为空
    def isEmpty(self):
        return self._head == None
    
    # 查询节点是否存在
    def searchItem(self, item):
        find = False
        cur = self._head
        while cur:
            cur_item = cur.item # 遍历节点，将数据值赋给cur_item
            if item == cur_item:
                find = True
                break
            cur = cur.next
        return find
    
    # 向链表尾部添加元素
    def append(self,item):
        node = Node(item)
        
        if self._head == None:# 如果链表为空
            self._head = node
            return
        # 链表非空
        cur = self._head
        pre = None # per永远指向cur前一个节点
        while cur:
            pre = cur
            cur = cur.next
        # 循环结束后pre指向链表的最后一个节点，cur指向空 
        pre.next = node 
    
    # 向指定位置插入节点
    def insert(self,pos,item):
        node = Node(item)
        cur = self._head
        per = None
        if pos == 0: # 如果是往开头插入
            node.next = self._head # 让新元素连接以前的节点
            self._head = node # _head 连接新节点
            return
        if pos < 0 or pos > self.length(): # 如果在不存在的点插入
            print('位置有误，重新输入！！！')
            return
        for i in range(pos): # for循环到插入的位置
            per = cur
            cur = cur.next
        per.next = node
        node.next = cur
        
    # 删除指定节点   
    def remove(self, item):
        cur = self._head
        per = None
        # 如果删的是第一个节点
        if self._head.item == item: # 如果删的是第一个节点
            self._head = cur.next # 让_head直接连接下一个节点
            return
        
        # 如果删不存在的节点
        if not self.searchItem(item):
            print('删除元素不存在！！！')
            return
        
        while cur:
            per = cur
            cur = cur.next
            if cur.item == item:
                break
        per.next = cur.next

    # 倒置链表（一）   
    # 旧的从头开始依次往后查看数据，得到的数据挨个插到新链表头部，最后得到倒置的链表
    def reversal(self):
        cur = self._head
        link_rev = Link()
        while cur:
            item = cur.item
            cur = cur.next
            node_rev = Node(item)
            node_rev.next = link_rev._head
            link_rev._head = node_rev
        return link_rev

    # 倒置链表（二）    
    def reversLink(self):
        pre = None
        cur = self._head
        cur_next = cur.next
        
        while True:
            cur.next = pre
            
            pre = cur
            cur = cur_next
            
            if cur == None:  # 最后一次cur会等于None,None没有next
                break
            cur_next = cur_next.next
        self._head = pre