# nextnode = list[0]
# node = list[0]
# while nextnode != "null":
# node = nextnode
# if node in seennodes:
# return True
# else:
# seennodes.add(node)
# nextnode = node.values()
#
# return False
# testing
a = Node("a", None)
b = Node("b", a)
c = Node("c", b)
d = Node("d", c)
list1 = LinkedList()
list1.append(a)
list1.prepend(b)
list1.prepend(c)
list1.prepend(d)
print(list1)
# print(containscycle(list2)) #false
# print(containscycle(list3)) #false
# print(containscycle(list4)) #false
def setUp(self):
self.linked_list = LinkedList()
from random import randrange
from LinkedList import LinkedList
linkedList = LinkedList()
for i in range(10):
linkedList.insertEnd(randrange(0, 10))
linkedList.insertStart(123)
print("t1")
linkedList.traverseList()
print("size:", linkedList.size())
linkedList.remove(123)
print("t2")
linkedList.traverseList()
print("size:", linkedList.size())
linkedList.insertIndex(2, 100)
print("t3")
linkedList.traverseList()
print("size:", linkedList.size())
print("element 3: ", linkedList.index(2))
def reverseListRecur(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
if not head or not head.next:
# Return the last node in the list all the way back to the beginning
return head
node = self.reverseListRecur(head.next)
# In the present node, set the node after it from the original list
# equal to the present node. (i.e., reverse the node ahead of the present one)
head.next.next = head
head.next = None
return node
if __name__ == "__main__":
from LinkedList import LinkedList
linked = LinkedList()
for c in "string":
linked.add(c)
print("Before")
linked.displayList()
obj = Solution()
# linked.head = obj.reverseList(linked.head)
linked.head = obj.reverseListRecur(linked.head)
print("After")
linked.displayList()
"""
# if linked-list is empty
if not linked_list.head or not linked_list.head.next:
return False
slow = fast = linked_list.head
while fast and fast.next:
slow = slow.next #slow takes one step at a time
fast = fast.next.next #fast takes two step at a time
#if slow meets with fast that means linked-list is cyclic
if fast == slow:
return True
return False
linked_list = LinkedList()
linked_list.insert_end(1)
linked_list.insert_end(2)
linked_list.insert_end(3)
linked_list.insert_end(4)
linked_list.insert_end(5)
linked_list.insert_end(6)
#making the linked-list cyclic
linked_list.tail.next = linked_list.head
result = is_cyclic(linked_list)
print(result)
)
print('4.Enter d to delete a list')
print(
'5.Enter m to merge two lists into a binary list and transform it to a decimal number'
)
print('6.Enter e to exit menu')
def random_list(size, lower_bound, higher_bound):
new_linked_list = LinkedList()
for z in range(0, size):
new_linked_list.prepend(random.randint(lower_bound, higher_bound))
return new_linked_list
tester = LinkedList()
available_linked_lists = []
while True:
menu()
user_choice = input()
if user_choice == 'e':
break
elif user_choice == 'a':
try:
new_list_size = int(input('Enter the size of a new linked list: '))
lower_end = int(
input('Enter the lower end of possible random numbers: '))
higher_end = int(
input('Enter the higher end of possible random numbers: '))
def sum_lists_followup(first_list: LinkedList, second_list: LinkedList) -> LinkedList:
(first_list, second_list) = zero_pad_if_different_lengths(first_list, second_list)
result_list = LinkedList()
(result_list, carryover) = calculate_sum_lists(first_list.head, second_list.head, 0, result_list)
return result_list
def LLInit():
ll = LinkedList()
return True
def LLLen_1():
ll = LinkedList([1, 2, 3])
if len(ll) == 3:
return True
return False
def test_append(self):
"""测试添加节点（尾部）"""
link = LinkedList(head)
node1 = Node(2)
link.append_element(node1)
self.assertTrue(link.get_size() == 2)
def test_index(self):
"""测试链表结构的正确性（一个节点指向下一个节点）"""
link = LinkedList(head)
link.append_element(2)
link.append_element(3)
self.assertTrue(link.get_size() == 3)
def test_size(self):
"""测试获取链表大小"""
link1 = LinkedList(head)
self.assertTrue(link1.get_size() == 1)
"""Write code to remove duplicates from an unsorted linked list.
FOLLOW UP
How would you solve this problem if a temporary buffer is not allowed?"""
#O(N^2)
from LinkedList import LinkedList
def remove_duplicates(list_):
head = list_.head
while head.next:
temp = head.value
temp_head = head
while temp_head.next:
if temp_head.next.value == temp:
temp_head.next = temp_head.next.next
else:
temp_head = temp_head.next
if head == None: break
head = head.next
if head == None: break
return list_
if __name__ == '__main__':
list_ = LinkedList()
list_.generate(40, 0, 8)
print(list_)
list_ = remove_duplicates(list_)
print(list_)
return True
elif all(counter[val] % 2 == 0 for val in counter if val != middle_value):
return True
else:
return False
def count_length(ll):
val = ll.head
length = 1
while val.next != None:
length += 1
val = val.next
return length
ll_true = LinkedList([1, 2, 3, 4, 5, 4, 3, 2, 1])
print(is_palindrome(ll_true))
print 'Should be true', '\n'
ll_true2 = LinkedList([1, 4, 6, 6, 4, 1])
print(is_palindrome(ll_true2))
print 'Should be true', '\n'
ll_true3 = LinkedList([1, 4, 6, 2, 6, 4, 1])
print(is_palindrome(ll_true3))
print 'Should be true', '\n'
ll_false = LinkedList([1, 2, 3, 4, 5, 6, 7, 8, 9])
print(is_palindrome(ll_false))
print 'Should be false', '\n'
def kidx_to_n(inp, kth_idx):
curr = inp.head
for i in range(0, kth_idx):
if not curr:
return None
else:
curr = curr.next
inp.head = curr
return inp
def kval_to_n(inp, kth_val):
curr = inp.head
while curr:
if curr.value == kth_val:
break
else:
curr = curr.next
inp.head = curr
return inp
random_num = LinkedList().generate(10, 1, 100)
print(random_num)
print(kidx_to_n(random_num, 4))
print('')
random_num = LinkedList().generate(20, 1, 5)
print(random_num)
print(kval_to_n(random_num, 4))
while node1 is not None or node2 is not None:
value1 = node1.value if node1 is not None else 0
value2 = node2.value if node2 is not None else 0
value = value1 + value2 + carry
result.add_to_tail(value % 10)
carry = 1 if value/10 >= 1 else 0
if node1 is not None:
node1 = node1.next
if node2 is not None:
node2 = node2.next
return result
ll1 = LinkedList()
ll2 = LinkedList()
ll1.add_to_tail(1)
ll1.add_to_tail(2)
ll1.add_to_tail(3)
ll2.add_to_tail(8)
ll2.add_to_tail(9)
result = add_lists(ll1.top, ll2.top)
print(result.top.value)
print(result.top.next.value)
print(result.top.next.next.value)
def loop_detection(ll):
fast = slow = ll.head
while fast and fast.next:
fast = fast.next.next
slow = slow.next
if fast is slow:
break
if fast is None or fast.next is None: # no loop
return None
slow = ll.head
while fast is not slow:
fast = fast.next
slow = slow.next
return fast
if __name__ == '__main__':
ll = LinkedList([3, 1, 5, 9, 7, 2, 1])
count = 3
current = ll.head
for i in range(count):
current = current.next
ll.tail.next = current
print loop_detection(ll)
def __init__(self, capacity):
if capacity < MIN_CAPACITY:
capacity = MIN_CAPACITY
self.capacity = capacity
self.storage = [LinkedList()] * capacity
self.count = 0
def random_list(size, lower_bound, higher_bound):
new_linked_list = LinkedList()
for z in range(0, size):
new_linked_list.prepend(random.randint(lower_bound, higher_bound))
return new_linked_list
from P_match import p_match as pm
from Queue import Queue
from LinkedList import LinkedList
# exp = "[5-(4*6)+{3(6-4)[3]}]"
# if pm(exp):
# print("Valid")
# else:
# print("Invalid")
# q = Queue("1")
# q.insert_at_rear("2")
# q.insert_at_rear("3")
# q.insert_at_rear("4")
# q.insert_at_rear("2")
# q.insert_at_rear("3")
# q.insert_at_rear("4")
x = LinkedList("z")
x.insert_as_head("ss")
print(x.delete_head())
def check_if_intersects(lines_list, max_y):
lines_dictionary, q = read_lines_list(lines_list)
start_points_used_dictionary = dict()
end_points_used_dictionary = dict()
for line in lines_dictionary:
start_points_used_dictionary[line] = False
end_points_used_dictionary[line] = False
lines_collection = LinesCollection(lines_list)
my_scene = Scene([], [lines_collection])
my_plot = Plot([my_scene])
#print("\n\nLines:")
#for line in lines_list:
# print(line)
t = LinkedList(lines_dictionary)
intersections_dictionary = dict()
prev_point = None
prev_line = None
# Q: x->y
while q.size > 0:
event = q.findTheSmallest(q.root)
point = (event.key, event.value)
#print("\n-------------------------------------------------\n" + str(point), end="")
# update T
begin_line = is_start_point_checked(start_points_used_dictionary,
point)
end_line = []
if begin_line is None:
end_line = is_end_point_checked(end_points_used_dictionary, point)
if begin_line is not None:
handle_line_begin_event(begin_line, t)
#print("found line: " + str(begin_line))
elif end_line is not None:
handle_line_end_event(end_line, t)
#print("found line: " + str(end_line))
else: # intersection point
handle_intersection_event(lines_dictionary, point, t,
intersections_dictionary)
# handle two line ends in the same point
if prev_point == point:
if end_line:
#print("Two ends intersection in: " + str(point))
intersections_dictionary[point] = (prev_line, end_line)
# update Q
look_for_intersections(lines_dictionary, point, t, q,
intersections_dictionary)
q.delete(event.key, event.value)
prev_line = end_line
prev_point = point
#print("\nintersections number: " + str(len(intersections_dictionary)))
for intersection in intersections_dictionary:
point = intersection
line1 = intersections_dictionary[intersection][0]
line2 = intersections_dictionary[intersection][1]
#print(str(point) + " is intersection of " + str(line1) + " and " + str(line2))
new_line = [(point[0], max_y), (point[0], 1)]
new_lines_collection = LinesCollection([new_line], color="red")
points_collection = PointsCollection([point],
color="green",
marker="^")
new_scene = Scene([points_collection],
[lines_collection, new_lines_collection])
my_plot.add_scene(new_scene)
my_plot.draw()
return intersections_dictionary
def __init__(self):
self.__lst = LinkedList()
self.__strategy = None
#! /usr/bin/env python
from LinkedList import Node, LinkedList
def find_loop(list1):
nodes = []
for n in list1:
if n in nodes:
return n
nodes.append(n)
return None
node1 = Node(2)
node2 = Node(8)
node3 = Node(5)
node4 = Node(3)
node5 = Node(10)
node6 = Node(4)
link1 = LinkedList()
link1.insert(node1)
link1.insert(node2)
link1.insert(node2)
link1.insert(node3)
link1.insert(node4)
link1.insert(node5)
link1.insert(node6)
link1.insert(node3)
print("is loop {0}".format(find_loop(link1)))
# Prompt: Implement a function to check if a linked list is a palindrome
from LinkedList import LinkedList
def palindrome(ll: LinkedList) -> bool:
vals = ll.get_vals()
mid = int(len(vals) / 2)
left = vals[:mid]
right = vals[mid:][::-1]
if len(vals) % 2 == 1:
right.pop()
return left == right
test1 = LinkedList('m')
test1.append('o')
test1.append('o')
test1.append('m')
test2 = LinkedList('a')
test2.append('a')
test2.append('a')
test3 = LinkedList('a')
test3.append('a')
test3.append('b')
assert (palindrome(test1) == True)
assert (palindrome(test2) == True)
assert (palindrome(test3) == False)
# EX: input: 3 -> 5 -> 8 -> 5 -> 10 -> 2 -> 1 [partition = 5]
# output: 3 -> 1 -> 2 -> 10 -> 5 -> 5 -> 8
from LinkedList import LinkedList
def partition(ll, x):
current = ll.tail = ll.head
print current
while current:
nextNode = current.next
current.next = None
if current.value < x:
current.next = ll.head
ll.head = current
else:
ll.tail.next = current
ll.tail = current
current = nextNode
# Error check in case all nodes are less than x
if ll.tail.next is not None:
ll.tail.next = None
ll = LinkedList()
ll.generate(10, 0, 99)
print(ll)
partition(ll, ll.head.value)
print(ll)
from random import randint
from LinkedList import LinkedList
def get_value(l):
ans = 0
for i, val in enumerate(l):
# giv digits value in reverse order (3->4->5) = 543
ans += val * (10**i)
return ans
# example given
list1 = LinkedList()
list1.add(3)
list1.add(1)
list1.add(5)
list2 = LinkedList()
list2.add(5)
list2.add(9)
list2.add(2)
print(list1, list2)
print(get_value(list1), "+", get_value(list2), "=",
get_value(list1) + get_value(list2))
print()
# random test
l1, l2 = LinkedList(), LinkedList()
def create_arr(self, size):
arrayList = []
for i in range(0, size):
arrayList.append(LinkedList())
return arrayList
def __init__(self):
self.items = LinkedList()
def generate_test_linked_list(length):
linked_list = LinkedList()
for i in range(length, 0, -1):
linked_list.insert_beginning(i)
return linked_list
newnode.next = temp
temp = newnode
else:
temp = newnode
head = head.next
return temp
def is_palindrome(head):
rev = reverse(head)
while head:
if rev.data != head.data:
return False
rev = rev.next
head = head.next
return True
obj = LinkedList()
obj.add(1)
obj.add(2)
obj.add(3)
obj.add(4)
obj.add(3)
obj.add(2)
# obj.add(2)
obj.add(1)
# obj.add(1)
print(is_palindrome(obj.head))
