data-structures/lists/singlyLinked.py at main · uni-projs/data-structures · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
from nodes import SimpleNode


class SinglyLinkedList:
    def __init__(self):
        self._head = None
        self._tail = None
        self._size = 0

    def add_start(self, data: int):
        if self._head is None:
            node = SimpleNode(data)
            self._head = node
            self._tail = node
        else:
            node = SimpleNode(data)
            node.next = self._head
            self._head = node
            self._tail = node
        self._size += 1

    def add_at(self, data: int, position: int):
        if self._head is None:
            node = SimpleNode(data)
            self._head = node
            self._tail = node
            self._size += 1
        else:
            counter = 0
            previous_node = self._head
            actual_node = self._head
            node = SimpleNode(data)

            if actual_node.next:
                while actual_node.next and counter <= position:
                    if counter > 0:
                        previous_node = actual_node

                    actual_node = actual_node.next
                    counter += 1

                previous_node.next = node
                node.next = actual_node
                self._tail = actual_node
            else:
                if position == 0:
                    self._head = node
                    node.next = previous_node
                    self._tail = previous_node
                else:
                    previous_node.next = node
                    self._tail = node
        self._size += 1

    def add_end(self, data: int):
        if self._head is None:
            node = SimpleNode(data)
            self._head = node
            self._tail = node
            self._size += 1
        else:
            node = SimpleNode(data)
            if self._size == 1:
                self._head.next = node
                self._tail = node
            else:
                self._tail.next = node
                self._tail = node
            self._size += 1

    def remove_first_occurrence(self, data):
        if self._head is None:
            return "This element doesn't exists"
        else:
            element_found = False
            counter = 0
            previous_node = self._head
            actual_node = self._head
            while actual_node.next:
                if counter > 0:
                    previous_node = actual_node
                if actual_node.data == data:
                    element_found = True
                    actual_node = actual_node.next
                    break

            if element_found:
                if actual_node:
                    previous_node.next = actual_node.next
                elif actual_node.next is None:
                    previous_node = None
                del actual_node
                return "Element removed"
            else:
                return "Element not found"

    def get(self, index) -> int:
        temp = self._head
        for i in range(index):
            if temp:
                temp = temp.next
            else:
                raise IndexError("list index out of range")
        if temp:
            return temp.data
        else:
            raise IndexError("list index out of range")

    def set(self, index, value):
        temp = self._head
        for i in range(index):
            if temp:
                temp = temp.next
            else:
                raise IndexError("list index out of range")
        if temp:
            temp.data = value
        else:
            raise IndexError("list index out of range")

    def search(self, elem) -> str:
        if self._head.data is elem:
            return f'The element {elem} was found!'
        else:
            temp = self._head
            while temp.next:
                if temp.data is elem:
                    return f'The element {elem} was found!'
                else:
                    temp = temp.next

            if temp.data is elem:
                return f"The element {elem} was found!"
            else:
                return f"The element {elem} wasn't found!"

    def size(self) -> int:
        return self._size

    def get_head_data(self) -> int:
        return self._head.data

    def get_tail_data(self) -> int:
        return self._tail.data

    def print(self):
        print("#### PRINTING ELEMENTS ####")
        if self._head is None:
            print("There is no any element in the list")
        else:
            temp = self._head
            while temp.next:
                print(temp.data)
                temp = temp.next
            print(temp.data)
        print("#### FINISHING PRINT ####")