Python数据结构与算法

1.链表
数据结构需要定义为类
单链表的操作：
is_empth() 链表是否为空
length() 遍历整个链表
add(item)链表头部添加元素
append(item)链表尾部添加元素
insert(pos.item)指定位置添加元素
remove(item)删除节点
search(item)查找节点是否存在
2.单链表及节点的定义代码

class Node(object):    #节点
    def __init__(self,elem):
        self.element=elem
        self.next=None
##用元组也可以实现（elm,None）
###定义链表的数据结构,实现单链表的操作
class SingleLinkList(object):
###单链表
    def __init__(self,node=None):
        self.__head=node
    def is_empty(self):
        return self.__head==None
    def length(self):
        #用cur游标，用来移动遍历节点
        cur=self.__head
        #count用来记录数量
        count=0
        while cur!=None:
            count+=1
            cur=cur.next
        return count
    def travel(self):
        cur=self.__head
        while cur!=None:
            print(cur.element,end=' ')
            cur=cur.next
        print('')
    def add(self,item):
        #头插法
        node=Node(item)
        node.next=self.__head
        self.__head=node
    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 insert(self,pos,item):
        #:param pos参数 从0开始索引
        if pos<=0:
            self.add(item)
        elif pos>(self.length()-1):
            self.append(item)
        else:
            pre=self.__head
            count=0
            while count<(pos-1):
                count+=1
                pre=pre.next
                #当循环退出后，pre指向pos-1位置
            node=Node(item)
            node.next=pre.next
            pre.next=node
    def remove(self,item):
        cur=self.__head
        pre=None
        while cur!=None:
            if cur.element==item:
                ###先判断此节点是否为头结点
                #头结点：pre=None  or  cur=sel.__head
                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 cur!=None:
            if cur.element==item:
                return True
            else:
                cur=cur.next
            return False

if __name__=="__main__":
    ll=SingleLinkList()
    print(ll.is_empty())
    print(ll.length())

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())
    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.insert(-5, 60)
    ll.travel()
    ll.insert(2,9)
    ll.travel()
    ll.insert(10, 200)
    ll.travel()
    print("***************")
    ll.remove(8)
    ll.travel()
    ll.remove(60)
    ll.travel()
    ll.search(5)

True
0
False
1
60 8 1 2 3 4 5 6
60 8 9 1 2 3 4 5 6
60 8 9 1 2 3 4 5 6 200

---

60 9 1 2 3 4 5 6 200
9 1 2 3 4 5 6 200
链表与顺序表的对比
链表失去了顺序表随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大，但对存储空间的使用要相对灵活。
3.双向链表
一种更复杂的链表是双向链表或双面链表。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。
双链表的操作：
is_empth() 链表是否为空
length() 遍历整个链表
add(item)链表头部添加元素
append(item)链表尾部添加元素
insert(pos.item)指定位置添加元素
remove(item)删除节点
search(item)查找节点是否存在

class Node(object):    #定义节点
    def __init__(self,item):
        self.item=item
        self.next=None
        self.prev=None

class DoubleLinkList(object):
    ###s双链表
    def __init__(self,node=None):
        self.__head = node

    def is_empty(self):
        return self.__head == None

    def length(self):
        # 用cur游标，用来移动遍历节点
        cur = self.__head
        # count用来记录数量
        count = 0
        while cur != None:
            count += 1
            cur = cur.next
        return count

    def travel(self):
        cur = self.__head
        while cur != None:
            print(cur.item)
            cur = cur.next
        print("")

    def add(self, item):
        # 头插法
        node = Node(item)
        #node.next = self.__head    方法一
        #self.__head = node
        #node.next.pre=node
        self.__head.prev=node
        self.__head=node

    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
            node.prev=cur

    def insert(self, pos, item):
        #:param pos参数 从0开始索引
        if pos <= 0:
            self.add(item)
        elif pos > (self.length() - 1):
            self.append(item)
        else:
            node=node(item)
            cur = self.__head
            count = 0
            while count < (pos - 1):
                count += 1
                cur=cur.next
            node.prev=cur
            node.next=cur.next
            cur.next.pre=node
            cur.next=node
            #方法二
            #node.next=cur
            #node.prev=cur.prev
            #cur.prev=node
            #cur.prev.next=node

    def remove(self, item):
        cur = self.__head
        while cur != None:
            if cur.item == item:
                ###先判断此节点是否为头结点
                # 头结点：pre=None  or  cur=sel.__head
                if cur == self.__head:
                    self.__head = cur.next
                    if cur.next:    ##判断链表是否只有一个结点
                        cur.next.prev=None
                else:
                    cur.prev.next = cur.next
                    if cur.next:
                        cur.next.prev = cur.prev
                break
            else:
                cur=cur.next
    def search(self, item):
        cur = self.__head
        while cur != None:
            if cur.item == item:
                return True
            else:
                cur = cur.next
            return False
if __name__=="__main__":
    ll=DoubleLinkList()

    ll.append(1)
    print(ll.is_empty())
    print(ll.length())
    ll.append(2)
    ll.add(8)
    ll.append(3)
    ll.append(4)
    ll.append(5)
    ll.append(6)
    ll.travel()
    ll.insert(-5, 60)
    ll.travel()
    ll.insert(2, 9)
    ll.travel()
    ll.insert(10, 200)
    ll.travel()
    print("***************")
    ll.remove(8)
    ll.travel()
    ll.remove(60)
    ll.travel()
    ll.search(5)