python的数据结构（线性表）

最新推荐文章于 2024-06-11 17:01:33 发布

淮猪

最新推荐文章于 2024-06-11 17:01:33 发布

阅读量365

点赞数 3

分类专栏： python数据结构与算法文章标签：数据结构 python 算法链表

本文链接：https://blog.csdn.net/2301_79070867/article/details/138581662

版权

python数据结构与算法专栏收录该内容

3 篇文章 0 订阅

订阅专栏

它是由n(n>=0)个元素（节点）组成的满足如下条件的有限序列（a0,a1...,an-1）:

当i=1，...，n-1时，ai有且仅有一个直接前趋ai-1；

当i=0,1，...，n-2时，有且仅有一个直接后继ai+1；

表中第一个元素a0没有前去；

最后一个元素an-1无后继。

数据元素的个数n称为线性表长度，长度为0时称为空表。数据元素可以是单一类型的数据，如整数、字符串等，也可以由若干个数据项组成的结构体，如学生信息等。

存储分为：顺序存储和链式存储。

顺序存储

list和tuple两种数据类型实现顺序表。

优点：

1.无需为表示结点间的逻辑关系而增加额外的存储空间；

2.可方便地随机存取表中的任一元素。

缺点：

1.插入或删除平均需要移动一半的结点；

2.存储分配只能预先进行静态分配

链式存储

数据域和指针域：data和next。

采用链式存储结构的线性表称为链表。

链表中结点的逻辑次序和物理次序不一定相同。即：逻辑上相邻未必在物理上相邻。

节点数据类型可表示为：

Class SingleNode(object)： "单链表的结点"

Def __init__(self,item):

self.item=item #item存放数据元素

self.next=None #next是下一个结点的标识

尾插法：next指向下一个结点。

头插法：将要插入的元素next指向第一个结点，找到头然后指向要插入的元素

遍历

def travel(self):
    cur=self._head #头部
    while cur !=None:
        print(cur.elem,end='') #输出当前的值
        cur=cur.next
    print("\n")

查找节点是否存在

def search(self,item):
    cur=self.__head  #头部
    while not cur:
      if cur.elem==item:  #当前节点的值是否等于你要查询的值
        return True
      else:
          cur = cur.next   #指向下一个
    return False

头部添加元素

def add(self,item):
    node=Node(item)
    node.next=self.__head
    self.__head=node

尾部添加元素

def append(self,item):
    node=Node(item)   #实例化对象
    #由于特殊情况当链表为空时没有next，所以在前面要做个判断
    if self.is_empty():   #判断链表是否为空
      self.__head=node
    else:
      cur=self.__head
      while cur.next!=None:  #从头开始一直遍历到最后一个
        cur=cur.next
      cur.next=node   #找到最后一个元素，然后将添加值赋给最后一个元素的next指针

指定位置添加元素

def insert(self,pos,item):    #pos为插入位置，item为插入数值
    if pos<=0:    #如果pos位置在0，当做头插法
      self.add(item)
    elif pos>self.length()-1
      #如果pos位置比原链表长，那么都当做尾插法来做
      self.appdent(item)
    else:
      per=self.__head
      count=0
      while count<pos-1  #通过遍历到达要插入的位置
        count+=1
        per=per.next
      #当循环退出后，per指向pos-1位置
      node=Node(item)
      node.next=per.next    #要插入位置的前一个赋给插入值的下一个
      per.next=node   #要插入位置的前一个的next赋给要插入的值

删除结点

def remove(self,item):
    cur=self.__head
    pre=None  #删除元素的前一个
    while cur !=None:   #看该表为不为空
      if cur.elem==item:  #如果头的值等于要删除的值
        if cur==self.__head:     #先判断该节点是否是头结点
          self.__head=cur.next   #头结点做替换
        else:
          pre.next=cur.next  #把当前的next个前一个的next
        break
      else:
        pre=cur
        cur=cur.next

循环链表

最后一个结点的指正指向头结点，整个链表构成了一个封闭的环。

后续是否为头结点

双向链表

每个节点的指针域里包含两个指针，其中一个指向前去结点，另一个指向后继结点。

最后实例：

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 is_empty(self):
        '''链表是否为空'''
        return self.__head == None
    def length(self):
        cur = self.__head                  #cur游标，用来移动遍历节点
        count = 0                    #count记录数量
        while cur != None:
            count += 1
            cur = cur.next
        return count
    def travel(self):
        cur = self.__head
        while cur != None:
            print(cur.elem, end=' ')
            cur = cur.next
        print("\n")
    def add(self, item):
        node = Node(item)
        node.next = self.__head
        self.__head = node
    def append(self, item):
        node = Node(item)
        #由于特殊情况当链表为空时没有next，所以在前面要做个判断
        if self.is_empty():
            self.__head = node
        else:
            cur = self.__head
            while cur.next != None:
                cur = cur.next
            cur.next = node
    def insert(self, pos, item):
        if pos <= 0:    #如果pos位置在0，当做头插法
            self.add(item)
        elif pos > self.length() - 1:
            #如果pos位置比原链表长，那么都当做尾插法来做
            self.append(item)
        else:
            per = self.__head
            count = 0
            while count < pos - 1:
                count += 1
                per = per.next
            #当循环退出后，pre指向pos-1位置
            node = Node(item)
            node.next = per.next
            per.next = node
    def remove(self, item):
        cur = self.__head
        pre = None
        while cur != None:
            if cur.elem == item:       #先判断该节点是否是头结点
                if cur == self.__head:
                    self.__head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                pre = cur
                cur = cur.next
    def search(self, item):
        cur = self.__head
        while not cur:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False
if name == "__main__":
    ll = SingleLinkList()
    print(ll.is_empty())
    print(ll.length())
    ll.append(3)
    ll.add(999)
    ll.insert(-3, 110)
    ll.insert(99, 111)
    print(ll.is_empty())
    print(ll.length())
    ll.travel()
    ll.remove(111)
    ll.travel()