顺序表与链表

内存

• 计算机的作用
  • 存储和运算二进制的数据。
• 问题：计算机如何计算1+2？
  • 现将1和2（0010）进行存储
  • 计算机会使用加法寄存器进行加法运算
• 变量的概念
  • 引用==变量。变量就是我们为存储数据单独开辟的内存空间。
• 形象化理解内存（内存的大小和地址）
  • 开辟好的内存空间会有两个默认的属性：大小，地址
  • 大小：衡量该块内存能够存储数据的大小
    • bit(位)：只可以存放一位二进制的数
    • byte（字节）：8bit
    • kb:1024byte
    • 10Mb:10*1024*1024*8
    • 作用：可以衡量该内存存储数据大小的范围
  • 地址：16进制的数表示
    • 作用：定位内存空间的位置
    • 变量/引用：内存空间的地址

如果一个变量表示的是某一块内存空间的地址，则该变量指向该块内存空间。如果一个变量指向了某一块内存空间，则该变量就可以代替/表示这块内存中存储的数值。

• 不同数据占用内存空间的大小
  • 整数：4字节
  • 浮点型：
    • float：4字节
    • double：8字节
  • 字符型（char）：(单个)1字节

顺序表

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

• 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):
        self._head = None
    
    def add(self,item):
        
        node = Node(item)	# 创建一个新节点
        node.next = self._head	# 新节点指向None
        self._head = node	# head 指向新节点
    
    def travel(self):
        # 在非空的链表中head永远要指向第一个节点的地址，永远不要修改它的指向,否则会造成数据的丢失
        cur = self._head
        while cur:
            print(cur.item) # 遍历节点
            cur = cur.next	# 下一个节点
    
    def is_empty(self):
        return self._head == None
    
    def length(self):
        # 链表的长度
        cur = self._head
        count = 0
        while cur:
            count += 1
            cur = cur.next
        return count
    
    def append(self,item):
        # 尾部添加
        node = Node(item)
        cur = self._head
        pre = None
        # 如果链表为空
        if self._head == None:
            self._head = node
            return
        while cur:
            pre = cur
            cur = cur.next	# cur 指向None，pre指向最后一个节点
        pre.next = node	# 最后一个节点next指向新节点
        
    def search(self,item):
        # 查找节点(值)是否存在
        cur = self._head
        find = False
        while cur:
            if cur.item == item:
                find = True
                break
            else:
                cur = cur.next	# 遍历下一个节点
        return find
    
    def insert(self,pos,item):
        # 在某个位置插入节点
        node = Node(item)
        cur = self._head
        pre = None
        
        # 如果插入的位置大于了链表的长度，则默认插入到尾部
        if pos > self.length() - 1:
            self.append(item)
            return
        
        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 item == cur.item:
            self._head = cur.next
            return
        
        while cur:
            if cur.item != item:
                pre = cur
                cur = cur.next
        pre.next = cur.next
        # 该节点的前一个节点next指向其后一个节点，就达到删除
    
link = Link()

顺序表与链表

原文：https://www.cnblogs.com/yzm1017/p/12594200.html