算法导论 python代码 第十章

# author Ttssxuan
# Chapter 10.1

class Queue:
    '''
    the queue class

    Properties:
        head - the head of the queue
        tail - the tail of the queue
        length - the length of the queue
        arr - the queue entity
    '''
    def __init__(self, length):
        self.head = 0
        self.tail = 0
        self.length = length
        self.arr = [0] * self.length
    def __setitem__(self, i, x):
        self.arr[i] = x
    def __getitem__(self, i):
        return self.arr[i]
        

def enqueue(q, x):
    '''
    enqueue a element x to the queue q

    Parameters:
        q - the queue needs add a element
        x - the element needs add into the queue
    Returns:
        none
    '''
    
    if q.tail == q.length - 1:
        q.tail = 0
    else:
        q.tail += 1
    # determine whether overflow
    if q.tail == q.head:
        raise Exception("overflow")
    q[q.tail - 1] = x

def dequeue(q):
    '''
    get an element in the queue

    Parameters:
        q - the queue
    Returns:
        the last element of the queue
    '''
    if q.head == q.tail:
        raise Exception("underflow")
    x = q[q.head]
    if q.head == q.length - 1:
        q.head = 1
    else:
        q.head = q.head + 1
    return x

# test
q = Queue(10)
# enqueue
for i in range(0, 5):
    enqueue(q, i)
print(q.head, q.tail)
print(q.arr)
# dequeue
for i in range(0, 4):
    print(dequeue(q))
print(q.head, q.tail)
print(q.arr)

# author Ttssxuan
# chapter 10.1
# the stack

class Stack:
    '''
    the stack class

    Properties:
        top - the end of the stack
    '''
    def __init__(self):
        self.top = 0
        self.arr = []
    def __getitem__(self, i):
        return self.arr[i - 1]
    def __setitem__(self, i, x):
        self.arr.append(x)
    def __str__(self):
        return str(self.arr)

def stack_empty(s):
    '''
    determine whether the stack is empty

    Parameters:
        s - the stack
    Returns:
        if the stack is empty, gets True, otherwise gets False
    '''
    if s.top == 0:
        return True
    else:
        return False

def push(s, x):
    '''
    push x at the end of the stack s

    Parameters:
        s - the stack
        x - the value needs to push into the stack
    Returns:
        none
    '''
    s.top += 1
    s[s.top] = x

def pop(s):
    '''
    pop an element from stack s

    Parameters:
        s - the stack
    Returns:
        if the element exsit, return it, or raise excepthion
    '''
    if stack_empty(s):
        raise Exception("underflow")
    else:
        s.top -= 1
        return s[s.top + 1]

# test
s = Stack()
print(stack_empty(s))
push(s, 1)
print(s)
push(s, 2)
print(s)
print(pop(s))
print(pop(s))
# this will be underflow
print(pop(s))

# author Ttssxuan
# 10.1-5
# the implement of the deque


class Deque:
    '''
    the deque class

    Properties:
        head - the head of the deque
        tail - the tail of the deque
        length - the length of the deque
        arr - the queue entity
    '''
    def __init__(self, length):
        self.head = 0
        self.tail = 0
        self.length = length
        self.arr = [0] * self.length
    def __setitem__(self, i, x):
        self.arr[i] = x
    def __getitem__(self, i):
        return self.arr[i]
    def __str__(self):
        return str(self.arr)

def enqueue(q, x):
    '''
    append an element at the tail of the deque

    Parameters:
        q - the deque needs add a element
        x - the element needs add into the deque
    Returns:
        none
    '''
    q.tail = (q.tail + 1) % q.length
    # determine whether overflow
    if q.tail == q.head:
        raise Exception("overflow")
    q[q.tail - 1] = x

def enqueue_head(q, x):
    '''
    append an element at the head of the deque

    Parameters:
        q - the deque
        x - the value insert into the head
    Returns:
        none
    '''
    q.head = (q.head - 1) % q.length
    if q.head == q.tail:
        raise Exception("overflow")
    else:
        q[q.head] = x

def dequeue(q):
    '''
    get an element at the head of the deque

    Parameters:
        q - the deque
    Returns:
        the last element of the deque
    '''
    if q.head == q.tail:
        raise Exception("underflow")
    x = q[q.head]
    q.head = (q.head + 1) % q.length
    return x

def dequeue_tail(q):
    '''
    get an element at the tail of the deque

    Parameters:
        q - the deque
    Returns:
        the last element of the deque
    '''
    if q.tail == q.head:
        raise Exception("underflow")
    
    q.tail = (q.tail - 1) % q.length
    return q[q.tail]

# test
q = Deque(10)
# test enqueue
enqueue(q, 1)
enqueue(q, 2)
enqueue_head(q, 3)
enqueue_head(q, 4)
print(q)
print(q.head, q.tail)
# test dequeue
print(dequeue(q), q.head, q.tail)
print(dequeue_tail(q), q.head, q.tail)
print(dequeue(q), q.head, q.tail)
print(q)
print(dequeue_tail(q), q.head, q.tail)

# author Ttssxuan
# chapter 10.2
# the linked list


class Node:
    '''
    the linked list node

    Properties:
        key - the value of the node
        next - the pointer of the node
        prev - the pointer of the prev
    '''
    def __init__(self):
        self.value = None
        self.prev = None
        self.next = None
    def __str__(self):
        return str(self.value)

class Linked_list:
    '''
    the linked_list

    Properties:
        head - the head of the linked list
    '''
    def __init__(self):
        self.head = None
    def __str__(self):
        x = self.head
        re = ""
        while x != None:
            re += " " + str(x.value)
            x = x.next
        return re


def list_search(l, k):
    '''
    search the node whose value equels k

    Parameters:
        l - the linked list
        k - the value needs to be search
    Returns:
        if exist return the node, else return None
    '''
    x = l.head
    while x != None and x.value != k:
        x = x.next
    return x

def list_insert(l, x):
    '''
    insert the x into the given linked list

    Parameters:
        l - the linked list
        x - the node needs to be inserted into the linked list
    Returns:
        none
    '''
    x.next = l.head
    if l.head != None:
        l.head.prev = x
    l.head = x
    x.prev = None

def list_delete(l, x):
    '''
    delete the the node x in the given linked list

    Parameters:
        l - the linked list
        x - the node needs to be deleted from the linked list
    Returns:
        none
    '''
    if x.prev != None:
        x.prev.next = x.next
    else:
        l.head = x.next
    if x.next != None:
        x.next.prev = x.prev

# test
l = Linked_list()
# make the linked list
print("make the linked list")
for i in range(0, 10):
    x = Node()
    x.value = i
    list_insert(l, x)
print(l)
# search the value
print("search in the linked list")
print(list_search(l, 2))
print(list_search(l, 5))
# delete element
print("delete the element in the linked list")
print("delete 3")
list_delete(l, list_search(l, 3))
print(l)
print("delete 7")
list_delete(l, list_search(l, 7))
print(l)

# author Ttssxuan
# chapter 10.2
# the linked list with sentinels


class Node:
    '''
    the linked list node

    Properties:
        key - the value of the node
        next - the pointer of the node
        prev - the pointer of the prev
    '''
    def __init__(self):
        self.value = None
        self.prev = None
        self.next = None
    def __str__(self):
        return str(self.value)

class Linked_list:
    '''
    the linked_list

    Properties:
        head - the head of the linked list
    '''
    def __init__(self):
        x = Node()
        self.nil = x
        x.prev = x
        x.next = x
        
    def __str__(self):
        x = self.nil.next
        re = ""
        while x != self.nil:
            re += " " + str(x.value)
            x = x.next
        return re

def list_delete_sentinels(l, x):
    '''
    delete an element for a linked list with sentinel

    Parameters:
        l - the linked list
        x - the element need to be deleted
    Returns:
        none
    '''
    x.prev.next = x.next
    x.next.prev = x.prev

def list_search_sentinels(l, k):
    '''
    search an element whose value equals k in the linked list with sentinel

    Parameters:
        l - the linked list
        k - the value need to search in the linked list
    Returns:
        the element whose value equals k
    '''
    x = l.nil.next
    while x != l.nil and x.value != k:
        x = x.next
    return x

def list_insert_sentinels(l, x):
    '''
    insert an element into the linked list with sentinel

    Parameters:
        l - the linked list
        x - the node needs to be inserted into the linked list
    Returns:
        none
    '''
    x.next = l.nil.next
    l.nil.next.prev = x
    l.nil.next = x
    x.prev = l.nil



# test
l = Linked_list()
# make the linked list
print("make the linked list")
for i in range(0, 10):
    x = Node()
    x.value = i
    list_insert_sentinels(l, x)
print(l)
# search the value
print("search in the linked list")
print(list_search_sentinels(l, 2))
print(list_search_sentinels(l, 5))
# delete element
print("delete the element in the linked list")
print("delete 3")
list_delete_sentinels(l, list_search_sentinels(l, 3))
print(l)
print("delete 7")
list_delete_sentinels(l, list_search_sentinels(l, 7))
print(l)