python数据结构之线性表

python数据结构之线性表

1.1线性表的抽象数据类型描述

• 线性表特征：每个元素最多只有一个前驱元素，最多只有一个后继元素

• 基本运算：
  CreateList(a):建立
Add(e):将e加到线性表尾部
getsize():长度
GetElem(int i):求表中序号为i的元素
SetElem(int i,E e):令表中序号为i的元素值为e
GetNo(E e):求表中第一个值为e的序号
Insert(int i,E e):在表中插入e，作为序号为i的元素
Delete(int i):删除序号为i的元素
display():输出线性表的所有元素

1.2线性表的顺序存储结构

1.2.1 顺序表

1.2.2 链表

• 特点：有头结点，尾结点
• 头结点不存放任何数据元素
  

1. 初始化

#初始化结点
class ListNode(object):
    def __init__(self,data=None):
        self.data=data
        self.next=None

#初始化单链表
class LinkList(object):
    def __init__(self):
        self.head=ListNode()
        self.head.next=None

2. 插入与删除

#将结点s插入单链表p结点的后面
        s.next=p.next
        p.next=s

#删除单链表中p的后继结点
        p.next=p.next.next

3. 整体建立单链表

#头插法建表:由数组a整体建立单链表
    def CreateListF(self,a):
        for i in range(len(a)):
            s=ListNode(a[i])
            s.next=self.head.next
            self.head.next=s

#尾插法建表:由数组a整体建立单链表
    def CreateListC(self,a):
        t=self.head
        for i in range(len(a)):
            s=ListNode(a[i])
            t.next=s
            t=s
        t.next=None

4. 线性表的基本运算在单链表中的实现

#查找序号为i的结点
    def geti(self,i):
        p=self.head
        j=-1
        while(j<i and p is not None):
            j+=1
            p=p.next
        return p

#将e添加到单链表末尾：先新建一个元素e的结点s，找到尾结点p，在p之后插入s
    def Add(self,e):
        s=ListNode(e)
        p=self.head
        while p.next!=None:
            p=p.next
        p.next=s

#求单链表长度
    def getsize(self):
        p=self.head
        cnt=0
        while p.next!=None:
            p=p.next
            cnt+=1
        return cnt

#求单链表中序号i的元素值
    def __getitem__(self,i):
        assert i>=0
        p=self.geti(i)
        assert p is not None
        return p.data

#设置单链表中序号i的元素值
    def __setitem__(self,i,e):
        assert i>=0
        p=self.geti(i)
        assert p is not None
        p.data=e

#求单链表中第一个值为e的元素的序号
    def GetNo(self,e)
        p=self.head.next
        j=0
        while p is not None and p.data!=e:
            j+=1
            p=p.next
        if p is None:
            return -1
        else:
            return j

#在单链表中插入e，作为第i个元素
    def Insert(self,i,e):
        assert i >=0
        s=ListNode(e)
        p=self.geti(i-1)
        assert p is not None
        s.next=p.next
        p.next=s

#在单链表中删除第i个数据元素
    def Delete(self,i):
        assert i>=0
        p=self.geti(i-1)
        while p!=None and p.next is not None:
        p.next=p.next.next

#输出单链表中的所有元素
    def display(self):
        p=self.head.next
        while p is not None:
            print(p.data,end='')
            p=p.next
        print()

5. 单链表的反转：头插法
   

def Reverse(L):
        p=L.head.next
        L.head.Next=None
        while p!=None:
            q=p.next
            p.next=L.head.next
            L.head.next=p
        		p=q

1.2.3双链表

• 特点：有两个指针属性，一个指向后继结点，一个指向前驱结点，头结点dhead唯一

1. 初始化

#初始化结点
class DLinkNode:
    def __init__(self,data=None):
        self.data=data
        self.next=None
        self.prior=None

#初始化双链表
class DLinkList:
    def __init__(self):
        self.dhead=DLinkNode()
        self.next=None
        self.prior=None

2. 插入和删除结点

   
#插入结点
        s.next=p.next
        p.next.prior=s
        s.prior=p
        p.next=s

#删除结点
        p.next.prior=p.prior
        p.prior.next=p.next

3. 整体建立

#头插法
    def CreateListF(self,a):
        for i in range(len(a)):
            s=DLinkNode(a[i])
            s.next=self.dhead.next
            if self.head.next!=None:
                self.dhead.next.prior=s
            self.dhead.next=s
            s.prior=self.dhead

#尾插法
    def CreateListR(self,a):
        t=self.head
        for i in range(len(a)):
            s=DLinkNode(a[i])
            t.next=s
            s.prior=t
            t=s
        t.next=None

4. 基本运算在双链表中的实现

#在双链表中序号i的位置插入元素e
    def Insert(self,i,e):
        assert i >=0
        s=DLinkNode(e)
        p=DlinkList[i-1]
        assert p is not None
        s.next=p.next
        while p.next!=None:
            p.next.prior=s
        s.prior=p
        p.next=s

#在双链表dhead中删除序号i的结点
    def geti(self,i):
        j=-1
        p=self.head
        while j<i and p is not None:
            j+=1
            p=p.next
        return p
    def Delete(self,i):
        assert i>=0
        p=self.geti(i)
        assert p is not None
        p.prior.next=p.next
        if p.next!=None:
            p.next.prior=p.prior

1.2.4循环链表

• 特点：尾结点指向头结点
• 循环单链表

 
#初始化
class CLinkList:
    def __init__(self):
        self.head=LinkNode()
        self.head.next=self.next

• 循环双链表

#初始化
class CDLinkList:
    def __init__(self):
        self.dhead=DLinkNode()
        self.dhead.next=self.dhead
        self.dhead.prior=self.dhead