计算机的数据算法-内存|顺序表|链表|单链表|双端链表

内存

计算机的作用
- 用来存储和运算二进制的数据
问题：计算机如何计算1+2?
- 将1和2的二进制类型的数据加载到计算机的内存中，然后使用寄存器进行数值的运算
变量的概念
- 变量就是某一块内存
- 内存空间是有两个默认的属性:
  - 内存空间的大小
    - bit(位)：一个bit大小的内存空间只能存放一位二进制的数
    - byte（字节）:8bit
    - kb:1024byte
  - 内存空间的地址
    - 使用一个十六进制的数值表示
    - 作用:让cup寻址
形象化理解内存(内存的大小和地址)
理解a=10的内存图(引用、指向)
- 引用：变量==>内存空间的地址
- a=10: a变量/引用/内存空间的地址
- 指向：如果变量或者引用表示的是某一块内存空间地址的话，则该变量或者引用指向了该块内存
不同数据占用内存空间的大小

# 栈
class Stack():
    def __init__(self):
        self.items=[]

    def push(self,item):
        self.items.append(item)

    def pop(self):
        return self.items.pop()
    def peek(self):
        return len(self.items)-1
    def isEmpty(self):
        return self.items==[]
    def size(self):
        return len(self.items)

stack=Stack()
# print(stack)
stack.push(1)
stack.push(2)
stack.push(3)

print('栈顶元素下标:',stack.peek())
print(stack.isEmpty())
print('元素个数:',stack.size())
print(stack.pop())
print(stack.pop())
print(stack.pop())

# 双端队列

# 队列

class Queue():
    def __init__(self):
        self.items=[]
    def enqueue(self,item):
        self.items.insert(0,item)
    def dequeue(self):
        return self.items.pop()
    def isEmpty(self):
        return self.items==[]
    def size(self):
        return len(self.items)
q=Queue()
q.enqueue(1)
q.enqueue(2)
q.enqueue(3)
# print(q.dequeue())
# print(q.dequeue())
# print(q.dequeue())


kids=['A','B','C','D','E','F']
queue=Queue()
for kid in kids:
    queue.enqueue(kid) #A对头 F对尾
while queue.size()>1:
    for i in range(6): #每循环一次，山芋传递一次，手里有山芋的孩子永远咋对头位置
        kid=queue.dequeue()
        queue.enqueue(kid)
    queue.dequeue()
print('最终获胜的孩子:',queue.dequeue())

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

# Node(3)
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
        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
                return find
            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.item==item:
                pre.next=cur.next
                return

        # while cur:
        #     pre=cur
        #     if cur.item==item:
        #         pre.next=cur.next
        #         return
        #     cur=cur.next


link=Link()
# link.add(3)
# link.add(4)
# link.add(5)
link.append(1)
link.append(2)
link.append(3)
link.append(4)
# link.insert(2,1.3)
link.remove(3)
link.travel()
# print('>>>',link.search(6))
print(link.isEmpty())
print(link.size())

顺序表

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

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

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

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

链表

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

# Node(3)
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
        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
                return find
            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.item==item:
                pre.next=cur.next
                return

        # while cur:
        #     pre=cur
        #     if cur.item==item:
        #         pre.next=cur.next
        #         return
        #     cur=cur.next


link=Link()
# link.add(3)
# link.add(4)
# link.add(5)
link.append(1)
link.append(2)
link.append(3)
link.append(4)
# link.insert(2,1.3)
link.remove(3)
link.travel()
# print('>>>',link.search(6))
print(link.isEmpty())
print(link.size())

双端队列

class Deque():
    def __init__(self):
        self.items=[]
    def addFront(self,item):
        self.items.insert(0,item)
    def addRear(self,item):
        self.items.append(item)
    def removeFront(self):
        return self.items.pop()
    def removeRear(self):
        return self.items.pop(0)
    def isEmpty(self):
        return self.items==[]
    def size(self):
        return len(self.items)

q=Deque()
q.addFront(1)
q.addFront(2)
q.addFront(3)
# print(q.removeRear())
# print(q.removeRear())
# print(q.removeRear())

def isHuiWen(s):
    ex=True
    q=Deque()
    for ch in s:
        q.addFront(ch)
    while q.size()>1:
        if q.removeFront() != q.removeRear():
            ex=False
            break
    return ex
print(isHuiWen('heereh'))

链表：

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

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

链表（Linked list）:是一种常见的基础数据结构，是一种线性表，但是不像顺序表存储数据，而是每一个结点(数据存储单元)里存放

下一个结点的信息(即地址)

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

"""

Python中定义变量不需要指明变量类型，这是因为变量为一个对象，存储该对象的内存中封装了变量的类型、地址、值。
Python中的=不仅仅是赋值号，也可以是指针的赋值运算（比如：指针指向一个地址，就用=进行实现，最明显的例子就是开头提的问题）。
所以上述两点就解决了在Python中怎么指向下一个结点地址的问题。


链表
链表是线性表，满足（除头尾结点外）有唯一的一个前驱和唯一的一个后继

单链表
单链表是链表最简单的形式，每个结点有两个域，一个是值域，另一个是指针域，指针域指向下一个结点的地址，最后一个结点的指针域为空。单链表的实现有两种方法，一种是带头结点，一种是不带头结点，图中所示为不带头结点的单链表。
————————————————
版权声明：本文为CSDN博主「九久呀」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_38851184/article/details/105750984

"""

class Node(object):
    """结点"""
    def __init__(self,elem):
        self.elem=elem
        self.next=None

class SingleLinkList(object):
    """单链表"""
    def __init__(self,Node=None):
        self.__head=Node



    def add(self,item):
        """插入头结点"""
        node=Node(item)
        node.next=self.__head
        self.__head=node

    def travel(self):
        cur=self.__head
        while cur!=None:
            print(cur.elem,end=' ')
            cur=cur.next
    def is_empty(self):
        return self.__head==None

    def length(self):
        cur=self.__head
        cnt=0
        while cur!=None:
            cnt+=1
            cur=cur.next
        return cnt

    def append(self,item):
        """插入尾节点"""
        node=Node(item)
        if self.is_empty():
            self.__head=node
        else:
            cur=self.__head
            while cur.next!=None:
                cur=cur.next
            cur.next=node
    def search(self,item):
        cur=self.__head
        while cur.elem!=item:
            cur=cur.next
        print("查找成功")
        pass

    def insert(self,pose,item):
        """在指定位置插入结点"""
        if pose<=0:
            self.add(item)
        elif pose>=self.length()-1:
            self.append(item)
        else:
            node=Node(item)
            cnt=1
            cur=self.__head
            pre=None
            while cnt !=pose:
                pre=cur
                cur=cur.next
                cnt+=1
            cur=node
            cur.next=pre.next
            pre.next=cur
    def remove(self,item):
        if self.is_empty():
            print("连表为空，删除操作错误!")
        else:
            cur=self.__head
            pre=None
            while cur.elem!=item:
                pre=cur
                cur=cur.next
            pre.next=cur.next
            print('删除成功')
            del cur

if __name__=="__main__":
    l=SingleLinkList()
    print(l.is_empty())
    print(l.length())
    l.append(1)
    print(l.is_empty())
    print(l.length())
    l.add(0)
    l.append(2)
    l.append(3)
    l.append(4)
    l.append(5)

    l.append(6)
    l.insert(255,100)
    l.travel()

posted @ 2023-02-18 19:10 布衣梦蝶1978 阅读(31) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

计算机的数据算法-内存|顺序表|链表|单链表|双端链表

内存

顺序表

链表

双端队列

链表：

公告