2021-08-18 python数据结构与算法-链表

递归两个特点：调用自身、结束条件。

递归实例：汉诺塔问题

def hanoi(n,a,b,c):
    if n>0:
        hanoi(n-1,a,c,b)
        print('从 %s 移动到 %s'%(a,c))
        hanoi(n-1,b,a,c)

hanoi(3,'A','B','C')

输出结果：

从 A 移动到 C
从 A 移动到 B
从 C 移动到 B
从 A 移动到 C
从 B 移动到 A
从 B 移动到 C
从 A 移动到 C

顺序查找

从头到尾依次遍历一遍，查找目标值。

def linear_search(data_set,val):
    for i in range(len(data_set)):
        if data_set[i]==val:
            print('find it!location %d' %i)
    print(-1)

linear_search([1,2,44,33],9)

单链表实现：

# -*- coding:utf-8 -*-
"""
单链表的操作：
is_empty():判断链表是否为空
length():返回链表的长度
travel():遍历整个链表
head_add(item):在链表头部添加元素item
rear_append(item):在链表尾部添加元素item
insert(pos,item):指定位置添加元素
remove(item):删除节点
search(item):查找节点是否存在
"""
class SingleNode(object):
    '''单链表的节点'''
    def __init__(self,item):
        #_item存放数据元素
        self.item = item
        # _next是下一个节点的标识
        self.next = None
class SingleLinkList(object):
    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 ""

    def head_add(self, item):
        node = SingleNode(item)
        node.next = self._head
        self._head = node

    def rear_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,position,item):
        if position<=0:
            self.head_add(item)
        elif position>self.length():
            self.rear_append(item)
        else:
            node = SingleNode(item)
            pre = self._head
            for i in range(1,position-1):
                pre = pre.next
            node.next = pre.next
            pre.next = node

    def remove(self,item):
        cur = self._head
        pre = None
        if cur != None:
            while cur.item != item:
                pre = cur
                cur = cur.next
            pre.next = cur.next

    def search(self,item):
        cur = self._head
        while cur != None:
            if cur.item == item:
                return True
            cur = cur.next
        return False

## 实例测试：
ll = SingleLinkList()
ll.head_add(1)
ll.head_add(2)
ll.rear_append(3)
ll.insert(2, 4)
print ("length:",ll.length())
ll.travel()
print(ll.search(3))
print(ll.search(5))
ll.remove(1)
print("length:",ll.length())
ll.travel()

测试运行：

length: 4
2
4
1
3
True
False
length: 3
2
4
3

单向循环链表：

# -*- coding:utf-8 -*-
"""
@author: housong
@file: 单向循环链表.py
@time: 2021/08/18
单链表的操作：
is_empty():判断链表是否为空
length():返回链表的长度
travel():遍历整个链表
head_add(item):在链表头部添加元素item
rear_append(item):在链表尾部添加元素item
insert(pos,item):指定位置添加元素
remove(item):删除节点
search(item):查找节点是否存在
"""
class SingleNode(object):
    def __init__(self,item):
        self.item = item
        self.next = None

class SingleLinkReco(object):
    def __init__(self):
        self._head = None

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

    def length(self):
        if self.is_empty():
            return 0
        count = 1
        cur = self._head
        while cur.next != self._head: #这里的判定条件相比单链表有变化了，不再是cur != None
            count += 1
            cur = cur.next
        return count

    def travel(self):
        if self.is_empty():
            return
        else:
            cur=self._head
            print(cur.item)
            while cur.next != self._head:
                cur = cur.next
                print(cur.item)
        print("")

    def head_add(self,item):
        node = SingleNode(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            node.next = self._head
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            cur.next = node
            self._head = node

    def rear_append(self,item):
        node = SingleNode(item)
        if self.is_empty():
            self._head = node
            node.next = self._head
        else:
            cur = self._head
            while cur.next != self._head:
                cur = cur.next
            cur.next = node
            node.next = self._head

    def insert(self,pos,item):
        if pos<=1:
            self.head_add(item)
        elif pos>self.length():
            self.rear_append(item)
        else:
            node = SingleNode(item)
            pre = self._head
            for i in range(1,pos-1):
                pre = pre.next
            node.next = pre.next
            pre.next = node

    def search(self,item):
        if self.is_empty():
            return False
        cur = self._head
        if cur.item == item:
            return True
        while cur.next != self._head:
            cur = cur.next
            if cur.item == item:
                return True
        return False

    def remove(self,item):
        if self.is_empty():
            return False
        cur = self._head
        if cur.item == item:
            #不止一个节点时候
            if cur.next != self._head:
                self._head = cur.next
                end = self._head
                while end.next != self._head:
                    end = end.next
                end.next = cur.next
            else:#链表只有一个节点，还是要找到节点，直接就None
                self._head = None
        else:
            pre = self._head
            while cur.next != self._head:
                if cur.item == item:
                    pre.next = cur.next
                    return
                else:
                    pre = cur
                    cur = cur.next
            if cur.item == item:
                pre.next = cur.next

ll = SingleLinkReco()
ll.head_add(1)
ll.head_add(2)
ll.rear_append(3)
ll.insert(2, 4)
ll.insert(4, 5)
ll.insert(1, 6)
print("length:",ll.length())
ll.travel()
print(ll.search(3))
print(ll.search(7))
ll.remove(1)
print("length:",ll.length())
ll.travel()

输出：

C:\Users\housong\Anaconda3\python.exe C:/Users/housong/PycharmProjects/pythonProject/单向循环链表.py
length: 6
6
2
4
1
5
3

True
False
length: 5
6
2
4
5
3


Process finished with exit code 0

双向循环链表：

"""双向循环链表-housong"""
# -*- coding:utf-8 -*-
"""
单链表的操作：
is_empty():判断链表是否为空
length():返回链表的长度
travel():遍历整个链表
head_add(item):在链表头部添加元素item
rear_append(item):在链表尾部添加元素item
insert(pos,item):指定位置添加元素
remove(item):删除节点
search(item):查找节点是否存在
"""
class SingleNodeRe(object):
    def __init__(self,item):
        self.item = item
        self.next = None
        self.pre = None

class DoubleCircularLinkedList(object):
    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):
        if self.is_empty():
            return False
        else:
            cur = self._head
            while cur != None:
                print(cur.item)
                cur = cur.next

    def head_add(self,item):
        node = SingleNodeRe(item)
        if self.is_empty():
            self._head = node
        else:
            node.next = self._head
            self._head.pre = node
            self._head = node

    def rear_append(self,item):
        node = SingleNodeRe(item)
        if self.is_empty():
            self._head = node
        else:
            cur = self._head
            while cur.next != None:
                cur = cur.next
            cur.next = node
            node.pre = cur
    def insert(self,pos,item):
        if pos<=1:
            self.head_add(item)
        elif pos>self.length():
            self.rear_append(item)
        else:
            node = SingleNodeRe(item)
            cur = self._head
            for i in range(1,pos):
                cur = cur.next
            cur.pre.next = node
            node.pre = cur.pre
            node.next = cur
            cur.pre = node

    def remove(self,item):
        if self.is_empty():
            return False
        else:
            cur = self._head
            if cur.item==item:
                self._head=None
            while cur.next != None:
                if cur.item == item:
                    cur.next.pre = cur.pre
                    cur.pre.next = cur.next
                cur = cur.next
            if cur.item == item:
                cur.pre.next = None
                cur.pre =None

    def search(self,item):
        if self.is_empty():
            return False
        else:
            cur = self._head
            if cur.item == item:
                return True
            else:
                while cur.next != None:
                    if cur.item == item:
                        return True
                    cur = cur.next
                if cur.item == item:
                    return True
                else:
                    return False

ll = DoubleCircularLinkedList()
ll.head_add(1)
ll.head_add(2)
ll.rear_append(3)
ll.insert(2, 4)
ll.insert(4, 5)
ll.insert(0, 6)
ll.travel()
print("length:",ll.length())
print(ll.search(3))
print(ll.search(4))
ll.remove(1)
print("length:",ll.length())
ll.travel()

运行结果：

6
2
4
1
5
3
length: 6
True
True
length: 5
6
2
4
5
3

Process finished with exit code 0