数据结构 --- 02. 内存, 顺序表, 单链表

一.内存

　　1.基本概念

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


变量的概念：
　　就是计算机中的某一块内存空间

 

衡量计算机内存大小的范围：
　　bit
　　byte
　　kb
　　mb

计算机中内存空间都会有两个基本的属性
　　大小
　　地址

 

不同数据占用内存空间的大小
　　整数：4byte
　　float：4byte
　　double：8byte
　　字符：1byte

 

理解a=10的内存图（引用，指向）

　　指向：如果一个变量存储了某一块内存空间的地址，则表示该变量指向该块内存
　　引用：如果一个变量存储了某一块内存空间的地址，则该变量可以成为该内存的一个引用

 

二.顺序表

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

python中的列表和元组就属于多数据类型的顺序表

 

单数据类型顺序表的内存图（内存连续开启）

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

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

 

　　1.单数据类型

 

#单类型顺序表 数组
import numpy as np
arr = np.array([1,2,3])
print(arr[1])

# 2

 

 

 

　　2.多类型数据结构

 

 三.单链表

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

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是不像顺序表一样连续存储数据，
而是每一个结点（数据存储单元）里存放下一个结点的信息（即地址）

 

 

 　　1.基本操作

. is_empty()：链表是否为空

. length()：链表长度

. travel()：遍历整个链表

. add(item)：链表头部添加元素

. append(item)：链表尾部添加元素

. insert(pos, item)：指定位置添加元素

. remove(item)：删除节点

. search(item)：查找节点是否存在

 

 　　2.代码结构

class Node():
    def __init__(self,item):
        self.item = item
        self.next = None #存储的链表中下一个节点的地址
class Link():
    def __init__(self):
        #_head永远指向None或者第一个节点的地址
        self._head = None      
    def add(self,item):
        node = Node(item)
        node.next = self._head
        self._head = node
    def travel(self):
        #cur存储的就是第一个节点的地址
        cur = self._head
        while cur:
            print(cur.item)
            cur = cur.next
    def is_Empty(self):
        return self._head == None
    def size(self):
        length = 0
        if self._head == None:
            return length
        #cur就是指向了第一个节点
        cur = self._head
        while cur:
            length += 1
            cur = cur.next
        return length
    def append(self,item):
        node = Node(item)
        #如果链表为空则执行如下操作
        if self._head == None:
            self._head = node
            return
        
        cur = self._head
        pre = None
        while cur:
            pre = cur
            cur = cur.next
        pre.next = node
        
    def search(self,item):
        ex = False
        
        cur = self._head
        while cur:
            if cur.item == item:
                ex = True
                break
            cur = cur.next
        return ex
    def insert(self,pos,item):
        node = Node(item)
        
        if pos <= 0:
            self.add(item)
            return
        if pos >= self.size():
            self.append(item)
            return
        
        cur = self._head
        pre = None
        
        for i in range(0,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.item == item:
                pre.next = cur.next
                break
        

 

link = Link()
link.add(1)
link.add(2)
link.add(3)
link.append(4)
# link.insert(-2,'hello')
link.remove(3)
link.travel()

结果:

2
1
4