From e259e806f5a20e6b2748d35d2ccd9d2d4abf8769 Mon Sep 17 00:00:00 2001 From: BZAghalarov Date: Sat, 11 Jan 2020 12:24:24 +0400 Subject: [PATCH 1/4] Initial contribution after clone --- Linked Lists/EvenOddPartition/EvenOddPartition.py | 4 ++++ 1 file changed, 4 insertions(+) create mode 100644 Linked Lists/EvenOddPartition/EvenOddPartition.py diff --git a/Linked Lists/EvenOddPartition/EvenOddPartition.py b/Linked Lists/EvenOddPartition/EvenOddPartition.py new file mode 100644 index 0000000..f432ca3 --- /dev/null +++ b/Linked Lists/EvenOddPartition/EvenOddPartition.py @@ -0,0 +1,4 @@ +""" + Solution for the same problem + +""" \ No newline at end of file From ba36a63ee1f787e01aacc5da9f2d292fdca0e43d Mon Sep 17 00:00:00 2001 From: BZAghalarov Date: Sat, 11 Jan 2020 13:12:32 +0400 Subject: [PATCH 2/4] Solution + rename + typo --- .../EvenOddPartition/EvenOddPartition.py | 4 -- .../OddEvenPartition.java} | 2 +- .../OddEvenPartition/OddEvenPartition.py | 61 +++++++++++++++++++ 3 files changed, 62 insertions(+), 5 deletions(-) delete mode 100644 Linked Lists/EvenOddPartition/EvenOddPartition.py rename Linked Lists/{EvenOddPartition/EvenOddPartition.java => OddEvenPartition/OddEvenPartition.java} (94%) create mode 100644 Linked Lists/OddEvenPartition/OddEvenPartition.py diff --git a/Linked Lists/EvenOddPartition/EvenOddPartition.py b/Linked Lists/EvenOddPartition/EvenOddPartition.py deleted file mode 100644 index f432ca3..0000000 --- a/Linked Lists/EvenOddPartition/EvenOddPartition.py +++ /dev/null @@ -1,4 +0,0 @@ -""" - Solution for the same problem - -""" \ No newline at end of file diff --git a/Linked Lists/EvenOddPartition/EvenOddPartition.java b/Linked Lists/OddEvenPartition/OddEvenPartition.java similarity index 94% rename from Linked Lists/EvenOddPartition/EvenOddPartition.java rename to Linked Lists/OddEvenPartition/OddEvenPartition.java index 8e5d4eb..fc27df8 100644 --- a/Linked Lists/EvenOddPartition/EvenOddPartition.java +++ b/Linked Lists/OddEvenPartition/OddEvenPartition.java @@ -1,6 +1,6 @@ /* Odd Even Linked List - LeetCode: https://leetcode.com/problems/odd-even-linked-list/ - This code passes all Leetcode test cases as of Oct. 30th 2019 + This code passed all Leetcode test cases as of Oct. 30th 2019 */ class WithDummyHead { diff --git a/Linked Lists/OddEvenPartition/OddEvenPartition.py b/Linked Lists/OddEvenPartition/OddEvenPartition.py new file mode 100644 index 0000000..31d3cbd --- /dev/null +++ b/Linked Lists/OddEvenPartition/OddEvenPartition.py @@ -0,0 +1,61 @@ +""" + Even Odd Linked List - Leetcode: https://leetcode.com/problems/odd-even-linked-list/ + Geekforgeeks - https://www.geeksforgeeks.org/rearrange-a-linked-list-such-that-all-even-and-odd-positioned-nodes-are-together/ + This 2 solutions passed all Leetcode test cases on 11.01.2020 +""" + + +class ListNode: + def __init__(self, val): + self.val = val + self.next = None + + +class LinkedList: + def __init__(self): + self.head = None + +class Solution: + def oddEvenList(self, head): + if head is None or head.next is None: + return head + oddDummy = ListNode(-1) + evenDummy = ListNode(-1) + + oddTail = oddDummy + evenTail = evenDummy + + index = 0 + curr = head + while curr: + if index % 2 == 0: + evenTail.next = curr + evenTail = curr + else: + oddTail.next = curr + oddTail = curr + + curr = curr.next + index += 1 + evenTail.next = oddDummy.next + oddTail.next = None + + return evenDummy.next + +class WithLessPointers: + def oddEvenList(self, head): + if not head or not head.next: + return head + + even = head + odd = head.next + + oddHead = odd + + while odd and odd.next: + even.next = odd.next + even = odd.next + odd.next = even.next + odd = even.next + even.next = oddHead + return head \ No newline at end of file From 26c0c65c0f7dbc6046d2fc7b7ca8c618ffafae32 Mon Sep 17 00:00:00 2001 From: BZAghalarov Date: Sat, 11 Jan 2020 16:22:37 +0400 Subject: [PATCH 3/4] Added LinkedList Fundemetals functions --- .../LinkedListFundamentals.py | 336 ++++++++++++++++++ 1 file changed, 336 insertions(+) create mode 100644 Linked Lists/LinkedListFundamentals/LinkedListFundamentals.py diff --git a/Linked Lists/LinkedListFundamentals/LinkedListFundamentals.py b/Linked Lists/LinkedListFundamentals/LinkedListFundamentals.py new file mode 100644 index 0000000..7d4b4bb --- /dev/null +++ b/Linked Lists/LinkedListFundamentals/LinkedListFundamentals.py @@ -0,0 +1,336 @@ +""" + +""" + +class ListNode: + def __init__(self, val): + self.val = val + self.next = None + + +class LinkedList: + def __init__(self): + self.head = None + + def printListIterative( head ): + """ + Common pattern. Create a reference variable to point to the + head node so that we can operate on the LinkedList + """ + workingPointer = head + + while workingPointer: + """ + Our work - this can be anything we want to do to 'node'. 'workingPointer' + literally points to an object on the heap that is a 'Listnode' + """ + print(workingPointer.val) + workingPointer = workingPointer.next # go to the next node in the list + + + def printListRecursive(node): + if not node: + return + # Our work - this can be anything we want to do to 'node' + print(node.val) + + # Continue the recursion + LinkedList.printListRecursive(node.next) + + def printListInReverseRecursive(node): + if not node: + return + + """ + Recursion first - drill down to the end of the list. Base + case will catch us. + """ + LinkedList.printListInReverseRecursive(node.next) + + """ + Our work. This will be fired by the last node first, then the 2nd to last node, + and so on...because we recursed first, got a ton of nodes on the stack in recursive calls, + and now they will run this as the recursion goes "back up" + """ + print(node.val) + + def printListInReverseIterative(head): + """ + Replace call stack with our own stack + """ + stack = [] + workingPointer = head + while workingPointer: + stack.append(workingPointer.val) + workingPointer = workingPointer.next + + while stack: + node = ListNode(stack.pop()) + print(node.val) + + def deepCopyListIterative(head): + """ + A 'dummy head' node allows us to not have to handle the + initial empty case of a new list not being initialized with a first node. + + We can immediately begin appending to this new list and 'chop off' this node + at the end and it will be garbage collected (probably, if no one is using the reference later) + """ + newListHead = ListNode(-1) + + """ + Point a working pointer to the old list, point a working pointer + to the dummy head. + + We will build off the 'next' field of the dummy head immediately. + """ + oldListWorkingPointer = head + newListWorkingPointer = newListHead + + while oldListWorkingPointer: + newNode = ListNode(oldListWorkingPointer.val) + + # Append the deep copied node to the new list we are building + newListWorkingPointer.next = newNode + + # Advance to the next node in the old list to process + oldListWorkingPointer = oldListWorkingPointer.next + + # Move to the new node we just appended + newListWorkingPointer = newListWorkingPointer.next + + """ + We can also do the following, same reference to the same + node (the newly appended node): + """ + # "Cut off" the dummy head just leaving the pure list created + return newListHead.next + + def reverseLinkedListIterative(head): + """ + Common pattern. We keep 2 pointers, 1 to the previous element and 1 + to the current element + """ + prev = None + curr = head + + while curr: + """ + Another common pattern - preserve the pointer to the next node in + the list since we will overwrite this value later. + + Literally preserving the pointer to the next obkect in memory that + we want to visit...in a reference variable. + """ + preservedNextNode = curr.next + curr.next = prev + + prev = curr + curr = preservedNextNode + + """ + Useless pointer to rename things to make it clear what is happening, + prev is pointing to the last element when the above iteration ends. + + That is the head of the new reversed linked list. + """ + reversedLinkedListHead = prev + return reversedLinkedListHead + + def reverseLinkedListRecursive(node): + if not node or node.next is None: + return node + + """ + We need to preserve teh reference to the last node in the orginal + linked list since it will be the head of the new reversed linked list. + + We "bubble" that value up in our calls to the roor caller by recursing + deep first to get reference to the last node (and in the process creating n stack + frames on the call stack, each with reference to a node) + """ + headOfReversedList = LinkedList.reverseLinkedListRecursive(node.next) + + """ + When the base case is hit & returns, we will return to here. + 1 node before the final node in the list: + + O -> O -> O -> O -> O -> O -> O -> x + ^ + me + + In that frame we will have reference to a node 1 before + the end of the linked list. We point the node 'nodeToMyRight' + to 'me'. + + Then we cut off 'me's next because 'me' may be the last node in + the reversed linked list + """ + nodeToMyRight = node.next + nodeToMyRight.next = node + node.next = None + + # We continue "bubbling up" reference to the tail node up and up and up + return headOfReversedList + + def getMiddleNodeReference(head): + slow = head + fast = head + + """ + Even + O -> O -> O -> O -> O -> O -> x + ^ + ^ + + O -> O -> O -> O -> O -> O -> x + ^ + ^ + + O -> O -> O -> O -> O -> O -> x + ^ + ^ + + Odd + O -> O -> O -> O -> O -> x + ^ + ^ + + O -> O -> O -> O -> O -> x + ^ + ^ + + O -> O -> O -> O -> O -> x + ^ + ^ + + Keep going until 'fast' is null or 'fast.next' is null. + Then return the reference; + + """ + while fast and fast.next: + slow = slow.next + fast = fast.next.next + + # Useless pointer to rename for teaching purposes + middleNode = slow + return middleNode + + # k==1 is the last node + def getKthToLastNodeReference(head, k): + + leftOfWindow = head + rightOfWindow = head + + """ + Move the right of the window so that the gap between the 2 references is length 'k' + Imagine k = 3, we want: + O -> O -> O -> O -> O -> O -> x + ^ + We do: + O -> O -> O -> O -> O -> O -> x + l + r + + O -> O -> O -> O -> O -> O -> x + l + r + """ + + for i in range(k): + rightOfWindow = rightOfWindow.next + + """ + Now we do: + O -> O -> O -> O -> O -> O -> x + l + r + + O -> O -> O -> O -> O -> O -> x + l + r + + + O -> O -> O -> O -> O -> O -> x + l + r + + O -> O -> O -> O -> O -> O -> x + l + r + And we have found the kth to last node + + """ + while rightOfWindow: + leftOfWindow = leftOfWindow.next + rightOfWindow = rightOfWindow.next + + # Useless pointer to rename for teaching purposes + kthToLastNode = leftOfWindow + return kthToLastNode + + +a = ListNode(0) +b = ListNode(1) +c = ListNode(2) +d = ListNode(3) + +a.next = b +b.next = c +c.next = d + +head = LinkedList() +head = a +head1 = LinkedList() +head1 = a + +print("printlistiterative") +LinkedList.printListIterative(head) +print('\n') + +print("printListRecursive") +LinkedList.printListRecursive(head) +print('\n') + +print('printListInReverseRecursive') +LinkedList.printListInReverseRecursive(head) +print('\n') + +print('printListInReverseIterative') +LinkedList.printListInReverseIterative(head) +print('\n') + +print('deepCopyListIterative') +newListHead = LinkedList.deepCopyListIterative(head) +LinkedList.printListIterative(newListHead) +print("New list head value: " + str(newListHead.val)) +print("Are the 2 list head's equivalent in memory?" + str(a == newListHead)) + +print("reverseLinkedListIterative") +reversedListHead1 = LinkedList.reverseLinkedListIterative(head) +LinkedList.printListIterative(reversedListHead1) +print('\n') + +""" + Restore the orginal list by reversing again...itis sitting reversed + in memory...we have to restore it +""" +LinkedList.reverseLinkedListIterative(reversedListHead1) + +print("reverseLinkedListRecursive") +reversedListHead2 = LinkedList.reverseLinkedListRecursive(head) +LinkedList.reverseLinkedListIterative(reversedListHead2) +print('\n') + +# Restore +LinkedList.reverseLinkedListIterative(reversedListHead2) + +print("getMiddleNodeReference") +middle = LinkedList.getMiddleNodeReference(head) +print("Middle node value: " + str(middle.val)) +print('\n') + +print("getKthToLastNodeReference") +kthToLast = LinkedList.getKthToLastNodeReference(head, 3) +print("3rd To Last Node Value: " + str(kthToLast.val)) +print('\n') \ No newline at end of file From 4735cc1c4aff10081f2ab06e7ce5dbfa0693af02 Mon Sep 17 00:00:00 2001 From: BZAghalarov Date: Sat, 11 Jan 2020 23:17:07 +0400 Subject: [PATCH 4/4] Design Single Linked List with given conditions --- .../DesingALinkedList/DesignALinkedList.py | 69 +++++++++++++++++++ 1 file changed, 69 insertions(+) create mode 100644 Linked Lists/DesingALinkedList/DesignALinkedList.py diff --git a/Linked Lists/DesingALinkedList/DesignALinkedList.py b/Linked Lists/DesingALinkedList/DesignALinkedList.py new file mode 100644 index 0000000..d0b1f44 --- /dev/null +++ b/Linked Lists/DesingALinkedList/DesignALinkedList.py @@ -0,0 +1,69 @@ +""" + Leetcode : https://leetcode.com/problems/design-linked-list/ + Geekforgeeks : https://www.educative.io/edpresso/how-to-create-a-linked-list-in-python + This code passed all test cases in Leetcode on 10.01.2020: +""" + +class ListNode: + def __init__(self, val): + self.val = val + self.next = None + + +class MyLinkedList(object): + def __init__(self): + self.head = None + self.size = 0 + + def get(self, index): + if index < 0 or index >= self.size: + return -1 + + dummyHead = self.head + for i in range(index): + dummyHead = dummyHead.next + return dummyHead.val + + def addAtHead(self, val): + newNode = ListNode(val) + newNode.next = self.head + self.head = newNode + self.size += 1 + + def addAtTail(self, val): + newNode = ListNode(val) + + curr = self.head + while curr.next: + curr = curr.next + curr.next = newNode + self.size += 1 + + def addAtIndex(self, index, val): + if index > self.size: + return + + newNode = ListNode(val) + curr = self.head + if index <= 0: + newNode.next = curr + self.head = newNode + else: + for i in range(index - 1): + curr = curr.next + newNode.next = curr.next + curr.next = newNode + self.size += 1 + + def deleteAtIndex(self, index): + if index < 0 or index >= self.size: + return + + curr = self.head + if index == 0: + self.head = self.head.next + else: + for i in range(index - 1): + curr = curr.next + curr.next = curr.next.next + self.size -= 1 \ No newline at end of file