内存、顺序表、链表

内存

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

• 问题：计算机如何计算1+2？
  • 将1和2的二进制类型的数据加载到计算机的内存中，然后使用寄存器进行数值的预算。

• 变量的概念
  • 变量就是某一块内存
  • 内存空间是有两个默认的属性：
    • 内存空间的大小
      • bit（位）：一个bit大小的内存空间只能存放一位二进制的数
      • byte（字节）：8bit
      • kb：1024byte
    • 内存空间的地址
      • 使用一个十六进制的数值表示
      • 作用：让cup寻址

• 形象化理解内存（内存的大小和地址）

• 理解a=10的内存图（引用，指向）
  • 引用：变量==》内存空间的地址
  • a = 10：a变量/引用/内存空间的地址
  • 指向：如果变量或者引用表示的是某一块内存空间地址的话，则该变量或者该引用指向了该块内存

• 不同数据占用内存空间的大小

顺序表

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

• 多数据类型顺序表的内存图（内存非连续开辟）

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

链表：相对于顺序表，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理且进行扩充时不需要进行数据搬迁。

• 链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）
•  is_empty()：链表是否为空
•  length()：链表长度
•  travel()：遍历整个链表
•  add(item)：链表头部添加元素
•  append(item)：链表尾部添加元素
•  insert(pos, item)：指定位置添加元素
•  remove(item)：删除节点
•  search(item)：查找节点是否存在

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None
class Link():
    def __init__(self):
        #构造出一个空链表
        #_head存储的只能是空或者第一个节点的地址
        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)
    def travel(self):
        #_head在链表创建好之后一定是不可变
        cur = self._head
        while cur:
            print(cur.item)
            cur = cur.next
            
    def isEmpty(self):
        return self._head == None
    
    def size(self):
        cur = self._head
        count = 0
        while cur:
            count += 1
            cur = cur.next
        return count
    
    def append(self,item):
        node = Node(item)
        #特殊情况
        if self._head == None:
            self._head = node
            return
        
        cur = self._head
        pre = None#pre指向的是cur前一个节点
        while cur:
            pre = cur
            cur = cur.next
        pre.next = node
    
    def search(self,item):
        find = False
        
        cur = self._head
        while cur:
            if cur.item == item:
                find = True
                break
            cur = cur.next
        
        return find
    
    def insert(self,pos,item):
        node = Node(item)
        pre = None
        cur = self._head
        for i in range(pos):
            pre = cur
            cur = cur.next
        pre.next = node
        node.next = cur
        
    def remove(self,item):
        cur = self._head
        pre = None
        #删除的是第一个节点
        if cur.item == item:
            self._head = cur.next
            return
        while cur:  
            pre = cur
            cur = cur.next
            if cur.next == None:
                return
            if cur.item == item:
                pre.next = cur.next
                return

按大小自动插入时排序的链表

class SortLink():
    def __init__(self):
        self._head = None
    def travel(self):
        #_head在链表创建好之后一定是不可变
        cur = self._head
        while cur:
            print(cur.item)
            cur = cur.next
            
    def sortInsert(self,item):
        node = Node(item)
        #插入的是第一个节点
        if self._head == None:
            self._head = node
            return
        cur = self._head
        pre = None
        
        if item < cur.item:
            self._head = node
            node.next = cur
            return
        while cur:
            pre = cur
            cur = cur.next
            if cur == None:
                pre.next = node
                return
            if cur.item > item:
                pre.next = node
                node.next = cur
                return