Git-Mirrors/master-algorithms-py
1
0
Fork 0
mirror of https://github.com/autistic-symposium/master-algorithms-py.git synced 2025-04-29 20:26:07 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix few details, linked lists

Browse Source
This commit is contained in:
Mari Wahl 2014-08-26 21:12:57 -04:00
parent c45a65f119
commit 2e28142075
6 changed files with 184 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
book/book_second_edition.pdf
View File

Binary file not shown.

0
src/abstract_structures/linked_list/hash_table.py → src/abstract_structures/hash_table.py
View File

229
src/abstract_structures/linked_list/linked_list_fifo.py
View File

@ -1,183 +1,108 @@
#!/usr/bin/python3
# mari von steinkirch @2013
# steinkirch at gmail
#!/usr/bin/python
__author__ = "Mari Wahl"
__email__ = "marina.w4hl@gmail.com"
''' A class for a linked list that has the nodes in a FIFO order (such as a queue)'''
class Node(object):
def __init__(self, value = None, next = None):
self.value = value
self.next = next
from node import Node
class LinkedListFIFO(object):
class LinkList(object):
def __init__(self):
self.head = None
self.tail = None
self.length = 0
self.tail = None # this is different from ll lifo
def addNode(self, value):
node = Node(value)
if not self.head:
self.head = node
if self.tail:
self.tail.next = node
self.tail = node
self.length += 1
def printList(self):
# print each node's value, starting from the head
def _printList(self):
node = self.head
while node:
print(node.value)
node = node.next
node = node.pointer
def addInOrder(self, item):
new_node = Node(item)
node = self.head
previous = None
stop = False
while node and not stop:
if node.value > item:
stop = True
else:
previous = node
node = node.next
# add a node in the first position
# read will never be changed again while not empty
def _addFirst(self, value):
self.length = 1
node = Node(value)
self.head = node
self.tail = node
if not previous:
new_node.next = self.head
self.head = new_node
# delete a node in the first position, ie
# when there is no previous node
def _deleteFirst(self):
self.length = 0
self.head = None
self.tail = None
print('The list is empty.')
# add a node in a position different from head,
# ie, in the end of the list
def _add(self, value):
self.length += 1
node = Node(value)
if self.tail:
self.tail.pointer = node
self.tail = node
# delete a node in some position
def _delete(self, prev, node):
self.length -= 1
prev.pointer = node.pointer
if not node.pointer:
self.tail = prev
# add nodes in general
def addNode(self, value):
if not self.head:
self._addFirst(value)
else:
new_node.next = node
previous.next = new_node
self._add(value)
def deleteNode(self, index):
# locate node with some index
def _find(self, index):
prev = None
node = self.head
i = 0
while node and i < index:
prev = node
node = node.next
node = node.pointer
i += 1
if i == index:
if not prev:
self.head = node.next
else:
prev.next = node.next
self.length -= 1
return node, prev, i
# delete nodes in general
def deleteNode(self, index):
if not self.head or not self.head.pointer:
self._deleteFirst()
else:
print('Index not found!')
def deleteNodeIfOrdered(self, item):
node = self.head
previous = None
found = False
while node and not found:
if node.value == item:
found = True
node, prev, i = self._find(index)
if i == index:
self._delete(prev, node)
else:
previous = node
node = node.next
if found:
if not previous:
self.head = node.next
else:
previous.next = node.next
else:
print('Node not found!')
def removeDupl(self):
prev = None
node = self.head
aux_dict = Counter()
while node:
value_here = node.value
if aux_dict[value_here] == 0:
aux_dict[value_here] = 1
else:
if prev == None:
self.head = node.next
else:
prev.next = node.next
self.length -= 1
prev = node
node = node.next
def removeDupl_no_buf(self):
node = self.head
while node:
pivot = node.value
pointer = node.next
prev = node
while pointer:
value_here = pointer.value
if value_here == pivot:
prev.next = pointer.next
self.length -= 1
prev = pointer
pointer = pointer.next
node = node.next
def searchIfOrdered(self, item):
node = self.head
found = False
stop = False
while node and not found and not stop:
if node.value == item:
found = True
else:
if node.value > item:
stop = True
else:
node = node.next
return found
print('Node with index {} not found'.format(index))
from collections import Counter
def main():
ll = LinkList()
for i in range(1, 10):
ll.addNode(i)
ll.addNode(i+1)
print('Linked List with duplicates:')
ll.printList()
print('Length before deleting duplicate is: ', ll.length)
ll.removeDupl()
ll.printList()
print('Lenght after deleting duplicates is: ', ll.length)
ll = LinkList()
for i in range(1, 10):
ll.addNode(i)
ll.addNode(i+1)
print('Linked List with duplicates:')
ll.printList()
print('Length before deleting duplicate is: ', ll.length)
ll.removeDupl_no_buf()
ll.printList()
print('Lenght after deleting duplicates is: ', ll.length)
ll = LinkList()
l1 = [4, 2, 5, 7, 1, 9]
for i in l1:
ll.addInOrder(i)
ll.printList()
print(ll.searchIfOrdered(7))
print(ll.searchIfOrdered(3))
ll.deleteNodeIfOrdered(7)
ll.printList()
if __name__ == '__main__':
main()
ll = LinkedListFIFO()
for i in range(1, 5):
ll.addNode(i)
print('The list is:')
ll._printList()
print('The list after deleting node with index 2:')
ll.deleteNode(2)
ll._printList()
print('The list after adding node with value 15')
ll._add(15)
ll._printList()
print("The list after deleting everything...")
for i in range(ll.length-1, -1, -1):
ll.deleteNode(i)
ll._printList()

127
src/abstract_structures/linked_list/linked_list_lifo.py
View File

@ -1,82 +1,105 @@
#!/usr/bin/python3
# mari von steinkirch @2013
# steinkirch at gmail
#!/usr/bin/python
__author__ = "Mari Wahl"
__email__ = "marina.w4hl@gmail.com"
''' Implement a unordered linked list, i.e. a LIFO linked list (like a stack) '''
class Node(object):
def __init__(self, value = None, next = None):
self.value = value
self.next = next
from node import Node
class LinkedListLIFO(object):
class LinkList(object):
def __init__(self):
self.head = None
self.lenght = 0
self.length = 0
def addNode(self, value):
node = Node(value)
node.next = self.head
self.head = node
self.lenght += 1
def printList(self):
# print each node's value, starting from the head
def _printList(self):
node = self.head
while node:
print(node.value)
node = node.next
node = node.pointer
def deleteNode(self, index):
# delete a node, given the previous node
def _delete(self, prev, node):
self.length -= 1
if not prev:
self.head = node.pointer
else:
prev.pointer = node.pointer
# add a new node, pointing to the previous node
# in the head
def _add(self, value):
self.length += 1
self.head = Node(value, self.head)
# locate node with some index
def _find(self, index):
prev = None
node = self.head
i = 0
while node and i < index:
prev = node
node = node.next
node = node.pointer
i += 1
if index == i:
self.lenght -= 1
if prev == None:
self.head = node.next
return node, prev, i
# locate node by value
def _find_by_value(self, value):
prev = None
node = self.head
found = 0
while node and not found:
if node.value == value:
found = True
else:
prev.next = node.next
prev = node
node = node.pointer
return node, prev, found
# find and delete a node by index
def deleteNode(self, index):
node, prev, i = self._find(index)
if index == i:
self._delete(prev, node)
else:
print('Node with index {} not found'.format(index))
def deleteNodeByValue(self, item):
prev = None
node = self.head
found = False
while node and not found:
if node.value == item:
found = True
else:
prev = node
node = node.next
# find and delete a node by value
def deleteNodeByValue(self, value):
node, prev, found = self._find_by_value(value)
if found:
self.lenght -= 1
if prev == None:
self.head = node.next
else:
prev.next = node.next
self._delete(prev, node)
else:
print('Node with value {} not found'.format(item))
print('Node with value {} not found'.format(value))
def main():
ll = LinkList()
for i in range(1, 11):
ll.addNode(i)
print('The list is:')
ll.printList()
print('The list after deleting node with index 2 (value 8):')
ll.deleteNode(2)
ll.printList()
print('The list after deleting node with value 2 (index 7):')
ll.deleteNodeByValue(2)
ll.printList()
if __name__ == '__main__':
main()
ll = LinkedListLIFO()
for i in range(1, 5):
ll._add(i)
print('The list is:')
ll._printList()
print('The list after deleting node with index 2:')
ll.deleteNode(2)
ll._printList()
print('The list after deleting node with value 3:')
ll.deleteNodeByValue(2)
ll._printList()
print('The list after adding node with value 15')
ll._add(15)
ll._printList()
print("The list after deleting everything...")
for i in range(ll.length-1, -1, -1):
ll.deleteNode(i)
ll._printList()

28
src/abstract_structures/linked_list/node.py
View File

@ -1,23 +1,35 @@
#!/usr/bin/python3
# mari von steinkirch @2013
# steinkirch at gmail
#!/usr/bin/python
__author__ = "Mari Wahl"
__email__ = "marina.w4hl@gmail.com"
class Node(object):
def __init__(self, value):
def __init__(self, value=None, pointer=None):
self.value = value
self.next = None
self.pointer = pointer
def getData(self):
return self.value
def getNext(self):
return self.next
return self.pointer
def setData(self, newdata):
self.value = newdata
def setNext(self, newnext):
self.next = newnext
def setNext(self, newpointer):
self.pointer = newpointer
if __name__ == '__main__':
L = Node("a", Node("b", Node("c", Node("d"))))
assert(L.pointer.pointer.value=='c')
print(L.getData())
print(L.getNext().getData())
L.setData('aa')
L.setNext(Node('e'))
print(L.getData())
print(L.getNext().getData())