基本的数据结构python代码

单向链表：

元素仅和下一个位置元素有关联。

除了存储其本身的信息之外，还要存储一个指示其直接后继的信息，存储数据元素信息的域称为数据域，把存储直接后继位置的域称为指针域，指针域中存储的信息称为指针，这两部分信息组成数据元素的存储映像，称为节点。

class SingleNode():
    """单链表节点"""

    def __init__(self,item):
        # item 存放数据元素
        self.item = item
        # next存放下一个节点的标识
        self.next = None


class SingleLinkList():
    """单链表"""

    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断列表是否为空"""
        return self._head == None

    def length(self):
        """链表长度"""
        count = 0
        # head初始化时指向头节点
        head = self._head

        # 尾节点指向None，当没有达到尾部时执行
        while head != None:
            count += 1
            # 将head后移一个节点
            head = head.next
        return count

    def travel(self):
        """遍历链表"""
        head = self._head

        while head != None:
            print(head.item)
            head = head.next
        print("complete!")

    def add(self,item):
        """头部添加元素"""
        # 先创建一个保存item的节点
        node = SingleNode(item)
        # 将新增的节点的next指向原有的头节点，就是self._head原有的位置
        node.next = self._head
        # 将链表的头_head指向新节点
        self._head = node

    def append(self,item):
        """向尾部添加元素"""

        node = SingleNode(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):
        """指定位置添加元素"""
        # 指定位置pos在第一个元素之前，向头部插入
        if pos <= 0:
            self.add(item)
        # 指定位置pos在最后一个元素之后，向尾部插入
        elif pos>(self.length()-1):
            self.append(item)
        # 向中间插入，找到指定的位置
        else:
            node = SingleNode(item)
            count = 0
            # pre用来指向指定位置pos的前一个位置pos-1,初始时_head移动到指定位置
            pre = self._head
            while count < (pos-1):
                count += 1
                pre = pre.next
            # 先将新节点node的next指向插入位置的节点
            node.next = pre.next
            # 将插入位置的前一个节点的next指向新节点
            pre.next = node

    def remove(self,item):
        """删除元素"""
        cur = self._head
        pre = None

        while cur != None:
            # 找到指定元素
            if cur.item == item:
                # 如果第一个就是删除的节点
                if not pre:
                    self._head = cur.next
                else:
                    pre.next = cur.next
                break
            else:
                # 继续向链表后移动节点
                pre = cur
                cur = cur.next

    def search(self,item):
        """链表查找节点是否存在，返回True或者False"""
        cur = self._head
        while cur!= None:
            if cur.item == item:
                return True
            cur = cur.next
        return False


if __name__ == '__main__':
    ll = SingleLinkList()
    ll.add(1)
    ll.add(2)
    ll.append(4)
    ll.insert(2,5)
    print(ll.search(3))
    print(ll.search(5))
    print(ll.search(1))
    ll.travel()

双向链表：

双向链表是在单链表的每个节点中，再设置一个前驱节点的指针域。所以双向链表有两个指针域，一个指向直接后继，一个指向直接前驱。因为每个节点都需两个指针，所以可能占用的内存空间略微大一点。

class Node():
    """双向链表节点"""
    def __init__(self,item):
        self.item = item
        self.next = None
        self.prev = None


class DLinkList():
    """双向链表"""
    def __init__(self):
        self._head = None

    def is_empty(self):
        """判断链表是否为空"""
        return self._head == None

    def length(self):
        """返回链表的长度"""
        cur = self._head
        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("complete!")

    def add(self,item):
        """头部插入元素"""
        node = Node(item)
        if self.is_empty():
            self._head = node
        else:
            # 将node的next指向_head的头节点
            node.next = self._head
            # 将_head的头节点的prev指向node
            self._head.prev = node
            # 将_head指向node
            self._head = node

    def append(self,item):
        """向尾部添加元素"""
        node = Node(item)
        if self.is_empty():
            # 如果是空链表，将_head指向node
            self._head = node
        else:
            # 初始化指针
            cur = self._head
            while cur.next != None:
                cur = cur.next
            # 将尾节点cur的next指向node
            cur.next = node
            # 将node的prev指向cur
            node.prev = cur

    def search(self,item):
        """查找元素是否存在"""
        cur = self._head
        while cur != Node:
            if cur.item == item:
                return True
            cur = cur.next
        return False

    def insert(self,pos,item):
        """在指定位置添加节点"""
        if pos <= 0:
            self.add(item)
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            cur = self._head
            count = 0
            # 移动指针cur到指定的位置的前一个位置
            while count < (pos -1):
                count += 1
                cur = cur.next
            # 将node节点的prev指向cur
            node.prev = cur
            # 将node节点的next指向下一个节点
            node.next = cur.next
            # 将cur的下一个节点的prev指向node
            cur.next.prev = node
            # 将cur的next指向node
            cur.next = node

    def remove(self,item):
        """删除元素"""
        if self.is_empty():
            return
        else:
            cur = self._head
            if cur.item == item:
                if cur.next == None:
                    self._head = None
                else:
                    cur.next.prev = None
                    self._head = cur.next
                return
            while cur != None:
                if cur.item == item:
                    # 将cur的前一个节点的next指向cur的后一个节点
                    cur.prev.next = cur.next
                    # 将cur的后一个节点的prev指向cur的前一个节点
                    cur.next.prev = cur.prev
                    break
                cur = cur.next

if __name__ == '__main__':
    ll = DLinkList()
    ll.add(1)
    ll.add(2)
    ll.insert(0,5)
    ll.insert(4,7)
    ll.insert(2,9)
    print(ll.search(5))
    # print(ll.search(10))
    print(ll.length())
    ll.travel()

栈：

     先进后出，后进先出

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

    def is_empty(self):
        return self.items == []

    def push(self,item):
        """加入元素"""
        self.items.append(item)

    def pop(self):
        """弹出元素"""
        return self.items.pop()

    def peek(self):
        """返回栈顶元素"""
        return self.items[-1]

    def size(self):
        """返回栈的大小"""
        return len(self.items)

if __name__ == '__main__':
    s = Stack()
    s.push('hello')
    s.push('world')
    s.push('stack')
    print(s.size())
    print(s.peek())
    print(s.pop())

队列：

     先进先出，后进后出，只能在尾部删除，在头部插入，中间部分不能做处理。

class Queue(object):
    """队列"""
    def __init__(self):
        self.items = []

    def is_empty(self):
        return self.items == []

    def enqueue(self,item):
        """进队列"""
        self.items.insert(0,item)

    def dequeue(self):
        """出队列"""
        return self.items.pop()

    def size(self):
        """返回大小"""
        return len(self.items)

if __name__ == '__main__':
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    print(q.size())
    print(q.dequeue())