Commit 664e5cbf authored by Ing. Petr Pauš, Ph.D.'s avatar Ing. Petr Pauš, Ph.D.
Browse files

Linked List

parent 0647e645
Loading
Loading
Loading
Loading
+107 −0
Original line number Diff line number Diff line
class Node:
    def __init__(self, next, data):
        self.next = next
        self.data = data

    def __str__(self):
        return str(self.data)
    

class LinkedList:
    def __init__(self):
        self.head = Node(None, None)
        self.tail = self.head
        self.size = 0

    def add_at_begin(self, d):
        tmp = self.head
        self.head = Node(tmp, d)
        self.size += 1

    def __str__(self):
        tmp = self.head
        result = "["
        while tmp != self.tail:
            result += str(tmp)
            tmp = tmp.next
            if tmp != self.tail:
                result += ", "
        return result + "]"
    
    def append(self, d):
        self.tail.data = d
        self.tail.next = Node(None, None)
        self.tail = self.tail.next
        self.size += 1

    def find(self, d) -> Node:
        tmp = self.head
        self.tail.data = d
        while tmp.data != d:
            tmp = tmp.next
        if tmp==self.tail:
            return None
        else:
            return tmp
        
    def add(self, node:Node, d):
        if node==self.tail:
            raise Exception("Vlozeni za zarazku")
        node.next = Node(node.next, d)
        self.size += 1

    def delete(self, node:Node):
        if node==self.tail:
            raise Exception("Mazani zarazky")
        if node.next == self.tail:
            self.tail = node
            node.next = None
        else:
            node.data = node.next.data
            node.next = node.next.next
        self.size -= 1

    def delete_index(self, index:int):
        tmp = self.head
        k = 0
        if index>=self.size:
            raise Exception("Spatny index")
        while k<index:
            tmp = tmp.next
            k += 1

        self.delete(tmp)


seznam = LinkedList()
print(seznam)

seznam.add_at_begin(5)
seznam.add_at_begin(2)
seznam.add_at_begin(6)
seznam.add_at_begin(-100)
print(seznam)

seznam.append(0)
seznam.append(-1)

print(seznam)

seznam2 = LinkedList()
seznam2.append(5)

print(seznam2)

prvek = seznam.find(2)
seznam.add(prvek, -100)
print(seznam)

print("Mazani")
seznam.delete_index(0)
print(seznam)

seznam.delete_index(2)
print(seznam)

seznam.delete_index(4)
print(seznam)
 No newline at end of file
+125 −0
Original line number Diff line number Diff line
class Node:
    def __init__(self, next, data):
        self.next = next
        self.data = data

    def __str__(self):
        return str(self.data)



class LinkedList:
    def __init__(self):
        self.head = Node(None, None)
        self.tail = self.head
        self.size = 0

    def prepend(self, d):
        self.head = Node(self.head, d)
        self.size += 1

    def __str__(self):
        result = "["
        tmp = self.head
        while tmp!=self.tail:
            result += str(tmp.data)
            tmp = tmp.next
            if tmp != self.tail:
                result += ", "
        return result + "]"
    
    def __str__2(self):
        result = "["
        tmp = self.head
        while True:
            result += str(tmp.data)
            tmp = tmp.next
            if tmp != self.tail:
                result += ", "
            else:
                break
        return result + "]"
    
    def append(self, d):
        self.tail.data = d
        self.tail.next = Node(None, None)
        self.tail = self.tail.next
        self.size += 1

    def find(self, d) -> Node:
        tmp = self.head
        # self.tail.data = d                verze 2
        # while tmp.data != d:              verze 2
        while tmp.data != d and tmp!=self.tail:
            tmp = tmp.next
        
        if tmp==self.tail:
            raise Exception("Not found")
        return tmp
    
    def insert(self, f:Node, d):
        if f==self.tail:
            raise Exception("Insert after tail")
        f.next = Node(f.next, d)
        self.size += 1

    def delete(self, f:Node):
        if f == self.tail:
            raise Exception("Delete tail")
        if f.next==self.tail:
            f.next = None
            self.tail = f
        else:
            f.data = f.next.data
            f.next = f.next.next
        self.size -= 1

    def find_index(self, index:int) -> Node:
        if index>=self.size:
            raise Exception("Bad index")
        tmp = self.head
        k = 0
        # for k in range(index):
        while k<index:
            k += 1
            tmp = tmp.next
        return tmp


    def delete_index(self, index: int):
        x = self.find_index(index)
        self.delete(x)

    def __getitem__(self, index:int)-> Node:
       return self.find_index(index)
     
seznam = LinkedList()
seznam.append(5)
seznam.prepend(10)
seznam.prepend(-10)
print(seznam)

seznam.append(1000)
seznam.append(2000)
print(seznam)

x = seznam.find(1000)
seznam.insert(x, 5000)
print(seznam)

seznam.insert(seznam.head, 1000)
print(seznam)

print(seznam.find_index(0))
print(seznam.find_index(2))
print(seznam.find_index(6))


seznam.append("Ahoj")
seznam.append(1+3j)
print(seznam)

seznam.delete_index(2)
print(seznam)

print(seznam[2])