def union(llist_1, llist_2):
# edge case, if either of the lists is null, we return the other list
if llist_1 is None or llist_1.head is None:
return llist_2
if llist_2 is None or llist_2.head is None:
return llist_1
# the final linked list which we will return
unioned_list = LinkedList()
# in union, we need to make sure that elements in list 1 aren't repeated in list 2
# so we need to use a set to ensure no duplicates
unioned_set = set()
# we loop through the first linked list, and add its elements to the set
current_node = llist_1.head
while current_node is not None:
unioned_set.add(current_node.value)
current_node = current_node.next
# we loop through the second linked list, and add its elements to the set
current_node = llist_2.head
while current_node is not None:
unioned_set.add(current_node.value)
current_node = current_node.next
# now we create the final linked list and return it
for value in unioned_set:
unioned_list.append(value)
return unioned_list
def test_right_append(self):
ll = LinkedList()
ll.right_append(5)
ll.right_append(7)
self.assertEqual(ll.head.data, 5)
self.assertEqual(ll.head.pointer_next.data, 7)
self.assertIsNone(ll.head.pointer_next.pointer_next)
def test_delete_last_el(self):
n1 = Node(1)
n2 = Node(7)
n1.pointer_next = n2
ll = LinkedList(n1)
ll.delete_last_el()
self.assertEqual(ll.head.data, 1)
self.assertIsNone(ll.head.pointer_next)
def test__delitem__(self):
""" Removes an item by index"""
n1 = Node(12)
n2 = Node(2)
n1.pointer_next = n2
ll = LinkedList(n1)
self.assertRaises(IndexError, ll.__delitem__, 2)
self.assertRaises(TypeError, ll.__delitem__, "Ivan")
ll.__delitem__(1)
self.assertEqual(len(ll), 1)
self.assertEqual(ll[0].data, 12)
def test__getitem__(self):
""" get by index an element : l[]"""
ll = LinkedList(Node(10))
self.assertRaises(IndexError, ll.__getitem__, 2)
self.assertRaises(TypeError, ll.__getitem__, False)
self.assertRaises(TypeError, ll.__getitem__, "test data")
self.assertEqual(ll[0].data, 10)
self.assertEqual(ll[-1].data, 10)
def test__iter__(self):
ll = LinkedList()
ll.right_append(100)
ll.right_append(99)
ll.left_append(0)
iterator = iter(ll)
self.assertEqual(next(iterator), 0)
self.assertEqual(next(iterator), 100)
self.assertEqual(next(iterator), 99)
self.assertRaises(StopIteration, next, iterator)
def __createdVertexInsertion(self, v):
'''
This is a helper function to simply inserted a given vertex into a
hash table of existing vertices
INPUT:
v: Vertex that we are inserting
OUTPUT:
Graph with a new given vertex
'''
self.vertices[v] = LinkedList.LinkedList()
def getBuzzfeed(word):
firstNode = LinkedListNode("")
firstNode.setNext(None)
LLlist= LinkedList(firstNode)
jsonStr = '{ \"results\": ['
url = "http://www.buzzfeed.com/tag/"+word
html = urllib.urlopen(url).read()
htmlObject = BeautifulSoup(html, features="lxml")
headlines = []
count =0
##print ("Second tag")
##print (htmlObject)
for item in htmlObject.findAll(re.compile("h2", re.S)):
if count <3:
# #print(item)
pattern = re.compile("<a href=\"(.*)\" rel:gt_act=\"post/titl.*>(.*)</a>", re.S)
match = pattern.match(repr(item.a))
if match != None:
url = "http://www.buzzfeed.com"+match.groups()[0]
match= match.groups()[1].replace("\\n\\t\\t\\n\\t\\t\\t","")
match = match.replace("\\xa0", " ")
match = match.replace('u201c', ' ')
match = match.replace('u201d', ' ')
match = match.replace('u2026', ' ')
match = match.replace("\\n\\t\\t", "")
match = re.sub(r'\W+', ' ', match)
match = match.replace("u2019", "'")
node = LinkedListNode(url)
node.setTitle(match)
LLlist.insertFirst(node)
count= count+1
currentJSON = LLlist.deleteFirst()
while(currentJSON.getNext().getNext() != None):
jsonStr+= " {\"title\": \" "+currentJSON.getTitle()+ "\", \"url\": \""+currentJSON.getURL() +"\" }, "
currentJSON = LLlist.deleteFirst()
jsonStr+= " {\"title\": \" "+currentJSON.getTitle()+ "\", \"url\": \""+currentJSON.getURL() +"\" } "
jsonStr+= ' ]}'
sentiment = getSentiment(getBuzzfeedPost(jsonStr), word)
return sentiment
def test_left_append(self):
ll = LinkedList()
ll.left_append(3)
ll.left_append(1000)
self.assertEqual(ll.head.data, 1000)
self.assertEqual(ll.head.pointer_next.data, 3)
self.assertIsNone(ll.head.pointer_next.pointer_next)
def bstToLinkedLst(self):
'''
This converts a binary search tree into a linked list. In order to achieve this we need
to do a inorder traversal and then simply insert the list into our linked list.
INPUT: None
OUTPUT:
Binary tree to a doubly linked list
'''
linked = LinkedList.LinkedList()
lst = self.inOrderTraverasl()
linked.insertList([node.getData() for node in lst])
return linked
def intersection(llist_1, llist_2):
# edge case, if any of the lists is null, we return null
if llist_1 is None or llist_2 is None:
return None
if llist_1.head is None or llist_2.head is None:
return None
# the final linked list which we will return
intersected_list = LinkedList()
# in intersection, we need to store items which appear in both lists
# so we use a set to store the elements in list 1
set_1 = set()
# and another set to store the intersected elements
intersected_set = set()
# we loop through the first linked list, and add its elements to set 1
current_node = llist_1.head
while current_node is not None:
set_1.add(current_node.value)
current_node = current_node.next
# we loop through the second linked list
current_node = llist_2.head
while current_node is not None:
# if the value of the current node exists in list 1, we add it to our final set
if current_node.value in set_1:
intersected_set.add(current_node.value)
current_node = current_node.next
# now we add the intersected elements to our final linked list and return it
for value in intersected_set:
intersected_list.append(value)
# if the intersection is an empty list, we return None
# otherwise we return the list
return intersected_list if intersected_list.head is not None else None
def __init__(self):
'''
Our graph will keep track of a set of vertices and a linked list of edges as
mentioned in the description of an adjacency list.
Runtime
Implementation 1: O(n)
Implementation 2: O(n ^ 2)
Implementation 3: O(n)
'''
self.vertices = {}
self.edges = LinkedList.LinkedList()
self.connectedComponents = 0
self.cycles = False
def __init__(self, head = None):
'''
A constructor for our queue.
INPUT:
head: Head of a chain of nodes (if applicable).
OUTPUT:
Queue
We defined one class variables:
queue = A linked list, that is composed of variables such as size,
nodes, and functionality that can be seen in the linked list folder.
The queue can automatically be initialized from an existing
chain of nodes. Check out initializer() in the linked list class.
'''
self.queue = LinkedList.LinkedList(head)
def insertVertex(self, key):
'''
Here all we do is create a new vertex object with the key parameter and insert it
into our set of vertices. The reason we use a set is because it is implemented
using a hashtable and allows us to have constant lookups.
INPUT:
key: Key or data we want to insert
OUTPUT:
Inserted vertex into our graph
Runtime
Implementation 1: O(1)
Implementation 2: O(1) + O(n) amortized
Implementation 3: O(1) ?
'''
vert = Vertex(key)
self.vertices[vert] = LinkedList.LinkedList()
def test_right_append_empty_list(self):
ll = LinkedList()
ll.right_append(700)
self.assertEqual(ll.head.data, 700)
self.assertIsNone(ll.head.pointer_next)
count = 0
node = input_list.get_root()
while node is not None:
count += 1
node = node.get_next()
return count
def recursive_count(input_list):
node = input_list.get_root()
return _recursive_count(node, 0)
def _recursive_count(node, count):
if node is not None:
return _recursive_count(node.get_next(), count + 1)
return count
cool_list = LinkedList()
cool_list.insert(1)
cool_list.insert(1)
cool_list.insert(2)
cool_list.insert(1)
cool_list.insert(1)
cool_list.in_order()
print()
print(iterate_count(cool_list))
print(recursive_count(cool_list))
def test_left_append_empty_list(self):
ll = LinkedList()
ll.left_append(10)
self.assertCountEqual(ll, LinkedList(Node(10)))
def test__contains__(self):
ll = LinkedList()
ll.right_append(3)
ll.right_append(5)
self.assertEqual(ll.__contains__(3), True)
self.assertEqual(ll.__contains__(10), False)
from Node import Node
from Linked_List import LinkedList
if __name__ == '__main__':
"""
help()
The Python help function can be super helpful for easily pulling up documentation for classes and methods.
We can call the help function on one of our classes, which will return some basic info about the methods defined
in our class
"""
"""create LinkedList"""
n1 = Node(1)
n2 = Node(7)
n1.pointer_next = n2
ll = LinkedList(n1)
ll.left_append(100)
print(ll)
# # ll = LinkedList()
# print(ll)
# if ll:
# print("Not empty!")
"""length of LinkedList"""
# print(len(ll))
"""append to left"""
# print(ll)
# ll.left_append(42)
# ll.left_append(2)
# print(ll)
"""check list for emptiness"""
def test__delitem__empty_list(self):
self.assertRaises(IndexError, LinkedList().__delitem__, 0)
def test__len__list(self):
n1 = Node(1)
n2 = Node(7)
n1.pointer_next = n2
ll = LinkedList(n1)
self.assertEqual(len(ll), 2)
def test__len__empty_list(self):
ll = LinkedList()
self.assertEqual(len(ll), 0)
# itr = itr.prev
# return print('Doubly Linked List in reverse: ', revs)
if __name__ == '__main__':
# dll = DoublyLinkedList()
# dll.print()
# dll.insert_at_beginning(30)
# dll.print()
# dll.insert_at_beginning(10)
# dll.print()
# dll.insert_at_end(40)
# dll.print()
# dll.insert_at(20, 1)
# dll.print()
# dll.insert_at_end(50)
# dll.print()
# dll.insert_at(25,2)
# dll.print()
# dll.remove_at(2)
# dll.print()
# dll.insert_after_value(40, 45)
# dll.print()
# dll.remove_by_value(45)
# dll.print()
# dll.print_forward()
# dll.print_reverse()
ll = LinkedList()
ll.insert_values([1, 2, 3, 4, 5, 6])
ll.print()
ll.insert_at(2, 200)
ll.print()
'머리노드삽입', '꼬리노드삽입', '머리노드삭제', '꼬리노드삭제', '주목노드출력', '주목노드이동', '주목노드삭제',
'모든노드삭제', '검색', '멤버십판단', '모든노드출력', '스캔', '종료'
])
def select_menu() -> Menu:
s = [f'({m.value}){m.name}' for m in Menu]
while True:
print(*s, sep=' ', end='')
n = int(input(' : '))
if 1 <= n <= len(Menu):
return Menu(n)
lst = LinkedList()
while True:
menu = select_menu()
if menu == Menu.머리노드삽입:
lst.add_first(int(input('머리노드를 넣을 값을 입력하세요 : ')))
elif menu == Menu.꼬리노드삽입:
lst.add_last(int(input('꼬리노드를 넣을 값을 입력하세요 : ')))
elif menu == Menu.머리노드삭제:
lst.remove_first()
elif menu == Menu.꼬리노드삭제:
lst.remove_last()
from Linked_List import LinkedList
from Union import union
from Intersection import intersection
# Test case 1, 2 linked lists with elements in union and intersection
print("\nChecking TEST_CASE_1: 2 linked lists with elements in union and intersection\n")
linked_list_1 = LinkedList()
linked_list_2 = LinkedList()
element_1 = [3,2,4,35,6,65,6,4,3,21]
element_2 = [6,32,4,9,6,1,11,21,1]
for i in element_1:
linked_list_1.append(i)
for i in element_2:
linked_list_2.append(i)
print (union(linked_list_1,linked_list_2))
print (intersection(linked_list_1,linked_list_2))
'''
Checking TEST_CASE_1: 2 linked lists with elements in union and intersection
32 -> 65 -> 2 -> 35 -> 4 -> 6 -> 1 -> 9 -> 11 -> 3 -> 21 ->
4 -> 21 -> 6 ->
'''
# Test case 2, 2 linked lists with elements in union but no intersection
print("\nChecking TEST_CASE_2: 2 linked lists with elements in union but no intersection\n")
def test_delete_last_el_empty_list(self):
ll = LinkedList()
self.assertRaises(ValueError, ll.delete_last_el)
def test__str__list(self):
n1 = Node(1)
n2 = Node(7)
n1.pointer_next = n2
ll = LinkedList(n1)
self.assertEqual(str(ll), "LinkedList(1, 7)")
def __init__(self, num_elements):
self.num_elements = num_elements
self.main_array = [LinkedList() for i in range(0, num_elements)]
def test__str__empty_list(self):
ll = LinkedList()
self.assertEqual(str(ll), "LinkedList()")
from Linked_List import LinkedList LL1 = LinkedList(93) LL2 = LinkedList(94, LL1) print LL2.getChild().getData()
def test__bool__(self):
"""Unittest checks if __bool__ method works correctly"""
n1 = Node(1)
ll = LinkedList(n1)
self.assertTrue(ll)
self.assertFalse(LinkedList())
