python-wars/dataStructures/linkedList.py at main · Ry4nW/python-wars · 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
class Node:

  def __init__(self, data):
    self.data = data
    self.next = None

class LinkedList:

  def __init__(self):
    self.head = None

  def print_list(self):

    cur_node = self.head

    while cur_node:
      print(cur_node.data)
      cur_node = cur_node.next

  def find_node(self, data):

    node = self.head

    while node.data != data:
      node = node.next

    return node

  def append(self, data):

    new_node = Node(data)

    if self.head is None:
      self.head = new_node
      return

    last_node = self.head

    while last_node.next:
      last_node = last_node.next

    last_node.next = new_node

  def prepend(self, data):
    new_node = Node(data)

    new_node.next = self.head
    self.head = new_node

  def insert_after_node(self, prev_node, data):

    if not prev_node:
      print("Previous node does not exist.")
      return

    new_node = Node(data)

    new_node.next = prev_node.next
    prev_node.next = new_node

  def delete_node(self, key):

    cur_node = self.head

    if cur_node and cur_node.data == key:

      self.head = cur_node.next
      cur_node = None

      return

    prev = None

    while cur_node and cur_node.data != key:
      prev = cur_node
      cur_node = cur_node.next

    if cur_node is None:
      print('Node does not exist.')
      return

    prev.next = cur_node.next
    cur_node = None

  def swap_nodes(self, key_1, key_2):

    if key_1 == key_2:
      return

    prev_1 = None
    curr_1 = self.head
    while curr_1 and curr_1.data != key_1:
      prev_1 = curr_1
      curr_1 = curr_1.next

    prev_2 = None
    curr_2 = self.head
    while curr_2 and curr_2.data != key_2:
      prev_2 = curr_2
      curr_2 = curr_2.next

    if not curr_1 or not curr_2:
      return

    if prev_1:
      prev_1.next = curr_2
    else:
      self.head = curr_2

    if prev_2:
        prev_2.next = curr_1
    else:
        self.head = curr_1

    curr_1.next, curr_2.next = curr_2.next, curr_1.next

  def reverse_iterative(self):

        prev = None
        cur = self.head

        while cur:
            nxt = cur.next
            cur.next = prev
            prev = cur
            cur = nxt

        self.head = prev

llist = LinkedList()
llist.append("A")
llist.append("B")
llist.append("C")
llist.append("D")

llist.reverse_iterative()

llist.print_list()