数据结构与算法-4

1 - 双向链表

一种更复杂的链表是“双向链表”或“双面链表”。每个节点有两个链接：一个指向前一个节点，当此节点为第一个节点时，指向空值；而另一个指向下一个节点，当此节点为最后一个节点时，指向空值。

设计的双向链表需要完成以下操作

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

代码如下：

class Node():
    '''节点'''
    def __init__(self,elem):
        self.elem = elem
        self.next = None
        self.prev = None
class DoubleLinkList():
    '''双链表'''
    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.elem, end='\t')
            cur = cur.next
        print('')
        return

    def add(self, item):
        '''链表头部添加元素'''
        node = Node(item)
        node.next = self.__head
        self.__head = node
        Node.prev = 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 isert(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
            # 移动到指定位置的前一个位置
            while count < (pos-1):
                count += 1
                cur = cur.next
            # 将node的prev指向cur
            node.prev = cur
            # 将node的next指向cur的下一个节点
            node.next = cur.next
            # 将cur的下一个节点的prev指向node
            cur.next.prev = node
            # 将cur的next指向node
            cur.next = node


    def remove(self, item):
        '''删除节点'''
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                # 先判断此节点是否是头结点，如果是头节点
                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不是None才有cur,next
                        cur.next.prev = cur.prev
                break
            else:
                pre = cur
                cur = cur.next

    def search(self, item):
        '''判断是否在链表中'''
        cur = self.__head
        while cur != None:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        return False

if __name__ == '__main__':
    ll = DoubleLinkList()
    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.isert(-1, 9)
    ll.travel()
    ll.isert(2, 100)
    ll.travel()
    ll.isert(10, 200)
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()

结果如下：

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

2 - 单向循环链表

        单链表的一个变形是单向循环链表，链表中最后一个节点的next域不再为None，而是指向链表的头节点。

同样也需要完成如下操作：

• is_empty() 判断链表是否为空
• length() 返回链表的长度
• travel() 遍历
• add(item) 在头部添加一个节点
• append(item) 在尾部添加一个节点
• insert(pos, item) 在指定位置pos添加节点
• remove(item) 删除一个节点
• search(item) 查找节点是否存在

代码如下：

class Node():
    ''' 节点 '''
    def __init__(self,elem,next = None):
        self.elem = elem
        self.next = next
sn = Node(100)
class SingleCycleLinkList():
    '''单循环链表'''
    def __init__(self,node=None):#不传头节点，默认指向空，传入头节点会把空给替换掉
        self.__head = node
        if node:
            node.next = node
    def is_empty(self):
        '''链表是否为空'''
        return self.__head == None
    def length(self):
        '''链表长度'''
        # cur用来移动遍历节点
        if self.is_empty():
            return 0
        cur = self.__head
        # count记录节点数量
        count = 1 # 因为指针是cur.next，所以这里是1，不然会少数
        while cur.next != self.__head:
            count += 1
            cur = cur.next
        return count
    def travel(self):
        '''遍历链表'''
        if self.is_empty():
            return
        cur = self.__head
        while cur.next != self.__head:
            print(cur.elem,end='\t')
            cur = cur.next
        # 退出循环，cur指向尾节点，但尾节点未打印
        print(cur.elem)
        print('')
        return

    def add(self,item):
        '''链表头部添加元素'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
            # 能处理原有列表是空列表的情况
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            node.next = self.__head
            self.__head = node
            cur.next = node

    def append(self,item):
        '''尾部添加'''
        node = Node(item)
        if self.is_empty():
            self.__head = node
            node.next = node
        else:
            cur = self.__head
            while cur.next != self.__head:
                cur = cur.next
            node.next = self.__head# cur.next
            cur.next = node

    def isert(self,pos,item):
        '''指定位置添加元素
        :param pos from 0
        '''
        if pos <= 0:
            self.add(item)
        # for i in range(pos-1):
        #     pre = pre.next
        elif pos > (self.length()-1):
            self.append(item)
        else:
            node = Node(item)
            pre = self.__head
            count = 0
            while count < (pos-1):
                pre = pre.next
                count += 1
            # 当循环退出后，pre指向pos-1的位置
            node.next = pre.next
            pre.next = node

    def remove(self,item):
        '''删除节点'''
        if self.is_empty():
            return
        cur = self.__head
        pre = None
        # 能进循环体，代表不止1个元素，因此只有1个元素的情况属于循环外地尾节点的情况
        while cur.next != self.__head:
            if cur.elem == item:
                # 先判断此节点是否是头结点，如果是头节点
                if cur == self.__head:
                    # 头节点的情况，找到尾节点，将其指向新的头节点
                    rear = self.__head
                    while rear != self.__head:
                        rear = rear.next
                    self.__head = cur.next
                    rear.next = self.__head
                else:
                    # 中间节点，跟单链表操作一样
                    pre.next = cur.next
                # 这里不能是break，而是return，不然会报错
                return
            else:
                pre = cur
                cur = cur.next
        # 退出循环，cur指向尾节点
        if cur.elem == item:
            # 链表只有一个节点
            if cur == self.__head:
                self.__head = None
        # 对有很多节点的情况，对尾节点进行删除
        else:
            pre.next = cur.next

    def search(self,item):
        '''判断是否在链表中'''
        if self.is_empty():
            return False
        cur = self.__head
        while cur.next != self.__head:
            if cur.elem == item:
                return True
            else:
                cur = cur.next
        # 要对最后一个元素进行判断
        if cur.elem == item:
            return True
        return False

if __name__ == '__main__':
    ll = SingleCycleLinkList()
    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.isert(-1,9)
    ll.travel()
    ll.isert(2,100)
    ll.travel()
    ll.isert(10,200)
    ll.travel()
    ll.remove(100)
    ll.travel()
    ll.remove(9)
    ll.travel()
    ll.remove(200)
    ll.travel()

结果如下：

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

        单向循环链表难点总结

        单向循环的难点在于改变首部和尾部，都需要改变尾部元素的指针，这里可以在remove函数体现。remove函数有几个逻辑，首先判断链表是否为空，然后判断要删除的元素是处于前中部还是末尾，一个元素默认是处于末尾。如果元素处于尾部则根据链表是否为只有单个元素的链表，是则直接将self.__head指向None，否则将pre.next = cur.next。如果元素处于前中部则看该元素是否为头部，如果为头部，需要将self.__head指向cur.next，通过循环遍历到链表的末尾，将cur.next指向新的self.__head。如果不为头部，操作同普通的链表，因为它不影响头尾的连接关系。

3 - 栈

引言：我的理解是，顺序表和链表就是一个底层的内存存储的工具，反映了数据与数据间在内存中怎样存储。而栈、队列是对数据进行任务层面的操作，它不管你存储方式是怎样的，它只需要按照其自己的规则进行存数据和取数据，至于你数据是按顺序表在内存中开辟连续空间存储，还是按链表根据指针指向存储，都无关紧要。以栈为例，我后进的元素必定要先出，不管你是怎么存储的，怎么遍历的。

因此，栈需要完成的操作有：

• Stack() 创建一个新的空栈
• push(item) 添加一个新的元素item到栈顶
• pop() 弹出栈顶元素
• peek() 返回栈顶元素
• is_empty() 判断栈是否为空
• size() 返回栈的元素个数

实现的代码如下：

class Stack():
    '''栈'''
    def __init__(self):
        self.__list = []
    def push(self,item):
        '''压栈'''
        # 使用顺序表进行存储，从尾部加，时间复杂度为O（1），如果用链表在尾部加，时间复杂度为O（n）
        self.__list.append(item)
    def pop(self):
        '''弹栈'''
        return self.__list.pop()
    def peek(self):
        '''返回栈顶元素'''
        # 不为空才返回元素
        if self.__list:
            return self.__list[-1]
        else:
            return None
    def is_empty(self):
        '''判断栈是否为空'''
        return self.__list == []
    def size(self):
        '''返回栈道个数'''
        pass
if __name__ == "__main__":
    s = Stack()
    s.push(1)
    s.push(2)
    s.push(3)
    s.push(4)
    print(s.pop())
    print(s.pop())
    print(s.pop())
    print(s.pop())

运行结果如下：

4
3
2
1

4 - 队列

队列相对与栈而言，操作逻辑是先进先出。

需要实现的操作为：

• Queue() 创建一个空的队列
• enqueue(item) 往队列中添加一个item元素
• dequeue() 从队列头部删除一个元素
• is_empty() 判断一个队列是否为空
• size() 返回队列的大小

代码如下:

class Queue():
    '''队列'''
    def __init__(self):
        self.__list = []
    def enqueue(self,item):
        '''往队列添加元素'''
        self.__list.append(item)
        # self.__list.insert(0,item)
    def dequeue(self):
        '''出队'''
        return self.__list.pop(0)
        # return self.__list.pop()
        '''用那个方法看是出队用的多还是入队用的多，因为如果出对和入队操作频率一样多的话，二者时间复杂度是一样的，
        如果入队比较频繁，对于顺序表而言，应该从末尾添加元素，首部弹出元素
        如果出队比较频繁，对于顺序表而言，应该从首部添加元素，尾部弹出元素'''

    def is_empty(self):
        '''判空'''
        return  self.__list ==[]
    def size(self):
        '''返回队列大小'''
        return len(self.__list)
if __name__ == "__main__":
    q = Queue()
    q.enqueue(1)
    q.enqueue(2)
    print(q.dequeue())
    print(q.dequeue())

结果如下:

1
2

5 - 双端队列

双端队列是一种具有队列和栈的性质的数据结构。双端队列中的元素可以从两端弹出，其限定插入和删除操作在表的两端进行。双端队列可以在队列任意一端入队和出队。可以从两头进，可以认为是队列，每一端都只能后进先出，可以看作是栈。

 

需要实现的操作为：

• Deque() 创建一个空的双端队列
• add_front(item) 从队头加入一个item元素
• add_rear(item) 从队尾加入一个item元素
• remove_front() 从队头删除一个item元素
• remove_rear() 从队尾删除一个item元素
• is_empty() 判断双端队列是否为空
• size() 返回队列的大小

代码如下:

class QueueDouble():
    '''双端队列'''
    def __init__(self):
        self.__list = []

    def add_front(self, item):
        '''往队列头部添加元素'''
        self.__list.insert(0,item)

    def add_rear(self, item):
        '''往队列尾部添加元素'''
        self.__list.append(item)

    def pop_front(self):
        '''出队'''
        return self.__list.pop(0)

    def pop_rear(self):
        '''出队'''
        return self.__list.pop()

    def is_empty(self):
        '''判空'''
        return self.__list == []

    def size(self):
        '''返回队列大小'''
        return len(self.__list)


if __name__ == "__main__":
    qb = QueueDouble()
    qb.add_front(5)
    qb.add_rear(6)
    qb.add_front(4)
    qb.add_rear(7)
    qb.add_front(3)
    qb.add_rear(8)
    qb.add_front(2)
    qb.add_rear(9)
    qb.add_front(1)
    qb.add_rear(10)
    for i in range(10):
        print(qb.pop_front(),end = '\t')

运行结果如下：

1	2	3	4	5	6	7	8	9	10