Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Skip to content

Commit d0861cd

Browse files
author
Ram swaroop
committed
clone with random pointers almost done + code refactoring
1 parent 0739b45 commit d0861cd

File tree

9 files changed

+100
-26
lines changed

9 files changed

+100
-26
lines changed

‎src/me/ramswaroop/common/DoubleLinkedList.java

Lines changed: 10 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -188,12 +188,18 @@ public void printList() {
188188
}
189189
out.println(curr.item + "]");
190190
// prints the list from last node
191-
out.print("[");
191+
/*out.print("[");
192192
while (curr.prev != null) {
193193
out.print(curr.item + ",");
194194
curr = curr.prev;
195195
}
196-
out.println(curr.item + "]");
196+
out.println(curr.item + "]");*/
197+
}
198+
199+
public static <E> DoubleLinkedList<E> getLinkedList(DoubleLinkedNode<E> node) {
200+
DoubleLinkedList<E> linkedList = new DoubleLinkedList<>();
201+
linkedList.head = node;
202+
return linkedList;
197203
}
198204

199205
private DoubleLinkedNode<E> getPredecessorNode(int index) {
@@ -204,7 +210,7 @@ private DoubleLinkedNode<E> getPredecessorNode(E item) {
204210
return getNode(item) != null ? getNode(item).prev : null;
205211
}
206212

207-
protected DoubleLinkedNode<E> getNode(int index) {
213+
public DoubleLinkedNode<E> getNode(int index) {
208214
isElementIndex(index);
209215

210216
DoubleLinkedNode<E> curr = head;
@@ -216,7 +222,7 @@ protected DoubleLinkedNode<E> getNode(int index) {
216222
return curr;
217223
}
218224

219-
protected DoubleLinkedNode<E> getNode(E item) {
225+
public DoubleLinkedNode<E> getNode(E item) {
220226
DoubleLinkedNode<E> curr = head;
221227
if (item == null) {
222228
while (curr != null) { // when item is null, use == rather than equals()

‎src/me/ramswaroop/common/DoubleLinkedNode.java

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -9,17 +9,17 @@
99
*/
1010
public class DoubleLinkedNode<E> {
1111

12-
E item;
13-
DoubleLinkedNode<E> next;
14-
DoubleLinkedNode<E> prev;
12+
public E item;
13+
public DoubleLinkedNode<E> next;
14+
public DoubleLinkedNode<E> prev;
1515

16-
DoubleLinkedNode(DoubleLinkedNode<E> prev, E item, DoubleLinkedNode<E> next) {
16+
public DoubleLinkedNode(DoubleLinkedNode<E> prev, E item, DoubleLinkedNode<E> next) {
1717
this.item = item;
1818
this.next = next;
1919
this.prev = prev;
2020
}
2121

22-
DoubleLinkedNode(DoubleLinkedNode<E> node) {
22+
public DoubleLinkedNode(DoubleLinkedNode<E> node) {
2323
if (node == null) return;
2424

2525
this.item = node.item;

‎src/me/ramswaroop/common/SingleLinkedList.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -201,7 +201,7 @@ private SingleLinkedNode<E> getPredecessorNode(E item) {
201201
return null;
202202
}
203203

204-
protected SingleLinkedNode<E> getNode(int index) {
204+
public SingleLinkedNode<E> getNode(int index) {
205205
isElementIndex(index);
206206

207207
SingleLinkedNode<E> curr = head;
@@ -213,7 +213,7 @@ protected SingleLinkedNode<E> getNode(int index) {
213213
return curr;
214214
}
215215

216-
protected SingleLinkedNode<E> getNode(E item) {
216+
public SingleLinkedNode<E> getNode(E item) {
217217
SingleLinkedNode<E> curr = head;
218218
if (item == null) {
219219
while (curr != null) { // when item is null, use == rather than equals()

‎src/me/ramswaroop/common/SingleLinkedNode.java

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -12,12 +12,12 @@ public class SingleLinkedNode<E> {
1212
public E item;
1313
public SingleLinkedNode<E> next;
1414

15-
SingleLinkedNode(E item, SingleLinkedNode<E> next) {
15+
public SingleLinkedNode(E item, SingleLinkedNode<E> next) {
1616
this.item = item;
1717
this.next = next;
1818
}
1919

20-
SingleLinkedNode(SingleLinkedNode<E> node) {
20+
public SingleLinkedNode(SingleLinkedNode<E> node) {
2121
if (node == null) return;
2222

2323
this.item = node.item;

‎src/me/ramswaroop/linkedlists/CloneWithRandPointers.java

Lines changed: 62 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,62 @@
1+
package me.ramswaroop.linkedlists;
2+
3+
import me.ramswaroop.common.DoubleLinkedList;
4+
import me.ramswaroop.common.DoubleLinkedNode;
5+
6+
/**
7+
* Created by IntelliJ IDEA.
8+
*
9+
* @author: ramswaroop
10+
* @date: 6/20/15
11+
* @time: 1:00 PM
12+
*/
13+
public class CloneWithRandPointers<E> extends DoubleLinkedList<E> {
14+
15+
public static <E> DoubleLinkedList<E> clone(DoubleLinkedNode<E> node) {
16+
DoubleLinkedNode<E> curr = node;
17+
18+
// copy node and insert after it
19+
while (curr != null && curr.next != null) {
20+
DoubleLinkedNode<E> newNode = new DoubleLinkedNode<>(null, curr.item, curr.next);
21+
curr.next = newNode;
22+
curr = curr.next.next;
23+
}
24+
25+
curr = node;
26+
27+
// copy all random pointers
28+
while (curr != null && curr.next != null) {
29+
curr.next.prev = curr.prev;
30+
curr = curr.next.next;
31+
}
32+
33+
curr = node;
34+
DoubleLinkedNode<E> cloneHead = node.next;
35+
DoubleLinkedNode<E> dupNode;
36+
// separate the copy nodes into a different linked list
37+
while (curr != null) {
38+
dupNode = curr.next;
39+
curr.next = (dupNode != null) ? dupNode.next : null;
40+
if (dupNode != null) {
41+
dupNode.next = (curr.next != null) ? curr.next.next : null;
42+
}
43+
curr = curr.next;
44+
}
45+
return DoubleLinkedList.getLinkedList(cloneHead);
46+
}
47+
48+
public static void main(String a[]) {
49+
DoubleLinkedList<Integer> linkedList = new DoubleLinkedList<>();
50+
linkedList.add(00);
51+
linkedList.add(11);
52+
linkedList.add(22);
53+
linkedList.add(33);
54+
linkedList.getNode(0).prev = linkedList.getNode(2);
55+
linkedList.getNode(1).prev = linkedList.getNode(3);
56+
linkedList.getNode(2).prev = linkedList.getNode(0);
57+
linkedList.getNode(3).prev = linkedList.getNode(1);
58+
linkedList.printList();
59+
DoubleLinkedList<Integer> clonedList = clone(linkedList.getNode(0));
60+
clonedList.printList();
61+
}
62+
}

‎src/me/ramswaroop/linkedlists/DeleteNode.java

Lines changed: 9 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,19 +12,25 @@
1212
*/
1313
public class DeleteNode<E> extends SingleLinkedList<E> {
1414

15-
public void deleteNode(SingleLinkedNode<E> node) {
15+
/**
16+
* Given a pointer to a node, delete it.
17+
*
18+
* @param node
19+
* @param <E>
20+
*/
21+
public static <E> void deleteNode(SingleLinkedNode<E> node) {
1622
// assert node isn't the last node in the linked list
1723
node.item = node.next.item;
1824
node.next = node.next.next;
1925
}
2026

2127
public static void main(String a[]) {
22-
DeleteNode<Integer> linkedList = new DeleteNode<>();
28+
SingleLinkedList<Integer> linkedList = new SingleLinkedList<>();
2329
linkedList.add(00);
2430
linkedList.add(11);
2531
linkedList.add(22);
2632
linkedList.printList();
27-
linkedList.deleteNode(linkedList.getNode(1));
33+
deleteNode(linkedList.getNode(1));
2834
linkedList.printList();
2935
}
3036
}

‎src/me/ramswaroop/linkedlists/DetectLoop.java

Lines changed: 4 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -30,7 +30,7 @@ public class DetectLoop<E> extends SingleLinkedList<E> {
3030
* @param node
3131
* @return
3232
*/
33-
public boolean isLoopPresent(SingleLinkedNode<E> node) {
33+
public static <E> boolean isLoopPresent(SingleLinkedNode<E> node) {
3434
SingleLinkedNode<E> prev = node, curr = node;
3535
while (curr != null && curr.next != null) {
3636
prev = prev.next;
@@ -51,7 +51,7 @@ public boolean isLoopPresent(SingleLinkedNode<E> node) {
5151
* @param node
5252
* @return
5353
*/
54-
public boolean isLoopPresentUsingHashMap(SingleLinkedNode<E> node) {
54+
public static <E> boolean isLoopPresentUsingHashMap(SingleLinkedNode<E> node) {
5555
HashMap<SingleLinkedNode<E>, Boolean> map = new HashMap<>();
5656
SingleLinkedNode<E> curr = node;
5757
while (curr != null) {
@@ -65,14 +65,14 @@ public boolean isLoopPresentUsingHashMap(SingleLinkedNode<E> node) {
6565
}
6666

6767
public static void main(String a[]) {
68-
DetectLoop<Integer> linkedList = new DetectLoop<>();
68+
SingleLinkedList<Integer> linkedList = new SingleLinkedList<>();
6969
linkedList.add(00);
7070
linkedList.add(11);
7171
linkedList.add(22);
7272
linkedList.add(33);
7373
linkedList.add(44);
7474
linkedList.add(55);
7575
linkedList.getNode(4).next = linkedList.getNode(3);
76-
System.out.println(linkedList.isLoopPresent(linkedList.getNode(0)));
76+
System.out.println(isLoopPresent(linkedList.getNode(0)));
7777
}
7878
}

‎src/me/ramswaroop/linkedlists/MiddleNode.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
*/
1313
public class MiddleNode<E> extends SingleLinkedList<E> {
1414

15-
public SingleLinkedNode<E> getMiddleNode(SingleLinkedNode<E> node) {
15+
public static <E> SingleLinkedNode<E> getMiddleNode(SingleLinkedNode<E> node) {
1616
SingleLinkedNode<E> slow = node;
1717
SingleLinkedNode<E> fast = node;
1818
while (fast != null && fast.next != null) {
@@ -23,7 +23,7 @@ public SingleLinkedNode<E> getMiddleNode(SingleLinkedNode<E> node) {
2323
}
2424

2525
public static void main(String a[]) {
26-
MiddleNode<Integer> linkedList = new MiddleNode<>();
26+
SingleLinkedList<Integer> linkedList = new SingleLinkedList<>();
2727
linkedList.add(00);
2828
linkedList.add(11);
2929
linkedList.add(22);
@@ -33,6 +33,6 @@ public static void main(String a[]) {
3333
linkedList.add(66);
3434
linkedList.add(77);
3535
linkedList.add(88);
36-
System.out.println(linkedList.getMiddleNode(linkedList.getNode(0)).item);
36+
System.out.println(getMiddleNode(linkedList.getNode(0)).item);
3737
}
3838
}

‎src/me/ramswaroop/linkedlists/NthNodeFromLast.java

Lines changed: 3 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@
1212
*/
1313
public class NthNodeFromLast<E> extends SingleLinkedList<E> {
1414

15-
public SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedNode<E> node, int n) {
15+
public static <E> SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedNode<E> node, int n) {
1616
SingleLinkedNode<E> slow = node;
1717
SingleLinkedNode<E> fast = node;
1818
// move the fast reference ahead of slow reference by 'n' nodes
@@ -28,7 +28,7 @@ public SingleLinkedNode<E> getNthNodeFromLast(SingleLinkedNode<E> node, int n) {
2828
}
2929

3030
public static void main(String a[]) {
31-
NthNodeFromLast<Integer> linkedList = new NthNodeFromLast<>();
31+
SingleLinkedList<Integer> linkedList = new SingleLinkedList<>();
3232
linkedList.add(00);
3333
linkedList.add(11);
3434
linkedList.add(22);
@@ -38,6 +38,6 @@ public static void main(String a[]) {
3838
linkedList.add(66);
3939
linkedList.add(77);
4040
linkedList.add(88);
41-
System.out.println(linkedList.getNthNodeFromLast(linkedList.getNode(0), 3).item);
41+
System.out.println(getNthNodeFromLast(linkedList.getNode(0), 3).item);
4242
}
4343
}

0 commit comments

Comments
 (0)