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

Commit 346a22c

Browse files
author
Ram swaroop
committed
Double LinkedList operations done and tested
1 parent c84eb46 commit 346a22c

File tree

3 files changed

+233
-26
lines changed

3 files changed

+233
-26
lines changed

‎src/me/ramswaroop/Main.java

Lines changed: 71 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -14,14 +14,16 @@ public static void main(String[] args) {
1414
Stack<Integer> stack = new LinkedStack<>();
1515
Queue<Integer> queue = new LinkedQueue<>();
1616
LinkedList<Integer> singleLinkedList = new SingleLinkedList<>();
17+
LinkedList<Integer> doubleLinkedList = new DoubleLinkedList<>();
1718
chooseModule:
1819
while (true) {
1920
out.println("Choose module:");
2021
out.println("==============");
2122
out.println("1. Stack");
2223
out.println("2. Queue");
2324
out.println("3. SingleLinkedList");
24-
out.println("4. Exit");
25+
out.println("4. DoubleLinkedList");
26+
out.println("5. Exit");
2527
k1 = Integer.parseInt(in.nextLine());
2628
switch (k1) {
2729
case 1:
@@ -161,6 +163,74 @@ public static void main(String[] args) {
161163
}
162164
}
163165
case 4:
166+
while (true) {
167+
out.println("Select operation:");
168+
out.println("=================");
169+
out.println("1. Add");
170+
out.println("2. Add at index");
171+
out.println("3. Remove");
172+
out.println("4. Remove at index");
173+
out.println("5. Remove item");
174+
out.println("6. Edit item");
175+
out.println("7. Delete LinkedList");
176+
out.println("8. Print");
177+
out.println("9. Exit module");
178+
k2 = Integer.parseInt(in.nextLine());
179+
int item, index;
180+
switch (k2) {
181+
case 1:
182+
out.println("Enter value:");
183+
item = Integer.parseInt(in.nextLine());
184+
doubleLinkedList.add(item);
185+
doubleLinkedList.printList();
186+
break;
187+
case 2:
188+
out.println("Enter value:");
189+
item = Integer.parseInt(in.nextLine());
190+
out.println("Enter index:");
191+
index = Integer.parseInt(in.nextLine());
192+
doubleLinkedList.add(index, item);
193+
doubleLinkedList.printList();
194+
break;
195+
case 3:
196+
out.println("Removed element: " + doubleLinkedList.remove());
197+
doubleLinkedList.printList();
198+
break;
199+
case 4:
200+
out.println("Enter index:");
201+
index = Integer.parseInt(in.nextLine());
202+
out.println("Removed element: " + doubleLinkedList.remove(index));
203+
doubleLinkedList.printList();
204+
break;
205+
case 5:
206+
out.println("Enter value:");
207+
item = Integer.parseInt(in.nextLine());
208+
out.println("Removed: " + doubleLinkedList.removeItem(item));
209+
doubleLinkedList.printList();
210+
break;
211+
case 6:
212+
out.println("Enter index to edit:");
213+
index = Integer.parseInt(in.nextLine());
214+
out.println("Enter new value:");
215+
item = Integer.parseInt(in.nextLine());
216+
doubleLinkedList.set(index, item);
217+
doubleLinkedList.printList();
218+
break;
219+
case 7:
220+
doubleLinkedList.clear();
221+
out.println("LinkedList deleted.");
222+
doubleLinkedList.printList();
223+
break;
224+
case 8:
225+
doubleLinkedList.printList();
226+
break;
227+
case 9:
228+
continue chooseModule;
229+
default:
230+
out.println("Wrong choice!");
231+
}
232+
}
233+
case 5:
164234
out.println("Exiting...");
165235
System.exit(0);
166236
default:

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

Lines changed: 160 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,7 @@
11
package me.ramswaroop.common;
22

3+
import java.util.NoSuchElementException;
4+
35
import static java.lang.System.out;
46

57
/**
@@ -11,31 +13,71 @@
1113
*/
1214
public class DoubleLinkedList<E> implements LinkedList<E> {
1315

14-
DoubleLinkedNode<E> head;
16+
public DoubleLinkedNode<E> head;
17+
public int size;
1518

1619
@Override
1720
public boolean add(E item) {
18-
return false;
21+
DoubleLinkedNode<E> newNode = new DoubleLinkedNode<>(null, item, null);
22+
if (head == null) { // list empty
23+
head = newNode;
24+
} else { // add to the end of list
25+
DoubleLinkedNode<E> curr = head;
26+
while (curr.next != null) {
27+
curr = curr.next;
28+
}
29+
curr.next = newNode;
30+
newNode.prev = curr;
31+
}
32+
size++;
33+
return true;
1934
}
2035

2136
@Override
2237
public boolean add(int index, E item) {
23-
return false;
38+
isIndexOutOfBounds(index);
39+
40+
if (index == 0) { // add at first
41+
addFirst(item);
42+
} else { // add at any other location
43+
DoubleLinkedNode<E> prevNode = getPredecessorNode(index);
44+
DoubleLinkedNode<E> nextNode = prevNode.next;
45+
DoubleLinkedNode<E> newNode = new DoubleLinkedNode<>(prevNode, item, prevNode.next);
46+
prevNode.next = newNode;
47+
if (nextNode != null) nextNode.prev = newNode;
48+
size++;
49+
}
50+
return true;
2451
}
2552

2653
@Override
2754
public void addFirst(E item) {
28-
55+
DoubleLinkedNode<E> newNode = new DoubleLinkedNode<>(null, item, head);
56+
if (head != null) head.prev = newNode;
57+
head = newNode;
58+
size++;
2959
}
3060

3161
@Override
3262
public void addLast(E item) {
33-
63+
add(item);
3464
}
3565

3666
@Override
3767
public void clear() {
38-
68+
// Clearing all of the links between nodes is "unnecessary", but:
69+
// - helps a generational GC if the discarded nodes inhabit
70+
// more than one generation
71+
// - is sure to free memory even if there is a reachable Iterator
72+
for (DoubleLinkedNode<E> node = head; node != null; ) {
73+
DoubleLinkedNode<E> next = node.next;
74+
node.item = null;
75+
node.next = null;
76+
node.prev = null;
77+
node = next;
78+
}
79+
head = null;
80+
size = 0;
3981
}
4082

4183
@Override
@@ -45,47 +87,90 @@ public LinkedList<E> clone() {
4587

4688
@Override
4789
public boolean contains(E item) {
48-
return false;
90+
return getNode(item) != null;
4991
}
5092

5193
@Override
5294
public E get(int index) {
53-
return null;
95+
return getNode(index).item;
5496
}
5597

5698
@Override
5799
public E getFirst() {
58-
return null;
100+
isLinkedListEmpty();
101+
return head.item;
59102
}
60103

61104
@Override
62105
public E getLast() {
63-
return null;
106+
return getNode(size - 1).item;
64107
}
65108

66109
@Override
67110
public E remove() {
68-
return null;
111+
isLinkedListEmpty();
112+
113+
E item = head.item;
114+
head = head.next;
115+
if (head != null) head.prev = null; // check for linked list size = 1
116+
size--;
117+
return item;
69118
}
70119

71120
@Override
72121
public E remove(int index) {
73-
return null;
122+
isLinkedListEmpty();
123+
124+
DoubleLinkedNode<E> prevNode = getPredecessorNode(index);
125+
DoubleLinkedNode<E> nextNode;
126+
DoubleLinkedNode<E> delNode;
127+
if (prevNode == null) { // index = 0
128+
delNode = head;
129+
head = head.next;
130+
if (head != null) head.prev = null; // check for linked list size = 1
131+
size--;
132+
return delNode.item;
133+
} else {
134+
delNode = prevNode.next;
135+
nextNode = delNode.next;
136+
prevNode.next = nextNode;
137+
if (nextNode != null) nextNode.prev = prevNode; // check needed if node to be deleted is last node
138+
size--;
139+
return delNode.item;
140+
}
74141
}
75142

76143
@Override
77144
public boolean removeItem(E item) {
78-
return false;
145+
isLinkedListEmpty();
146+
147+
if (!contains(item)) return false;
148+
149+
DoubleLinkedNode<E> prevNode = getPredecessorNode(item);
150+
DoubleLinkedNode<E> nextNode;
151+
if (prevNode == null) { // index = 0
152+
head = head.next;
153+
if (head != null) head.prev = null; // condition for list size = 1
154+
size--;
155+
} else {
156+
nextNode = prevNode.next.next;
157+
prevNode.next = nextNode;
158+
if (nextNode != null) nextNode.prev = prevNode;
159+
size--;
160+
}
161+
return true;
79162
}
80163

81164
@Override
82165
public E set(int index, E item) {
83-
return null;
166+
DoubleLinkedNode<E> node = getNode(index);
167+
node.item = item;
168+
return node.item;
84169
}
85170

86171
@Override
87172
public int size() {
88-
return 0;
173+
return size;
89174
}
90175

91176
@Override
@@ -96,10 +181,70 @@ public void printList() {
96181
out.println("]");
97182
return;
98183
}
184+
// prints the list from first node
99185
while (curr.next != null) {
100186
out.print(curr.item + ",");
101187
curr = curr.next;
102188
}
103189
out.println(curr.item + "]");
190+
// prints the list from last node
191+
out.print("[");
192+
while (curr.prev != null) {
193+
out.print(curr.item + ",");
194+
curr = curr.prev;
195+
}
196+
out.println(curr.item + "]");
197+
}
198+
199+
private DoubleLinkedNode<E> getPredecessorNode(int index) {
200+
return index > 0 ? getNode(index - 1) : null;
201+
}
202+
203+
private DoubleLinkedNode<E> getPredecessorNode(E item) {
204+
return getNode(item) != null ? getNode(item).prev : null;
205+
}
206+
207+
protected DoubleLinkedNode<E> getNode(int index) {
208+
isIndexOutOfBounds(index);
209+
210+
DoubleLinkedNode<E> curr = head;
211+
int i = 0;
212+
while (i < index) {
213+
curr = curr.next;
214+
i++;
215+
}
216+
return curr;
217+
}
218+
219+
protected DoubleLinkedNode<E> getNode(E item) {
220+
DoubleLinkedNode<E> curr = head;
221+
if (item == null) {
222+
while (curr != null) { // when item is null, use == rather than equals()
223+
if (curr.item == item) {
224+
return curr;
225+
}
226+
curr = curr.next;
227+
}
228+
} else {
229+
while (curr != null) {
230+
if (curr.item.equals(item)) {
231+
return curr;
232+
}
233+
curr = curr.next;
234+
}
235+
}
236+
return null;
237+
}
238+
239+
private void isLinkedListEmpty() {
240+
if (head == null) {
241+
throw new NoSuchElementException("LinkedList empty");
242+
}
243+
}
244+
245+
private void isIndexOutOfBounds(int index) {
246+
if (index < 0 || index > size) {
247+
throw new IndexOutOfBoundsException("Index [" + index + "] must be less than size [" + size + "]");
248+
}
104249
}
105250
}

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

Lines changed: 2 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -175,15 +175,7 @@ public void printList() {
175175
}
176176

177177
private SingleLinkedNode<E> getPredecessorNode(int index) {
178-
isIndexOutOfBounds(index);
179-
180-
SingleLinkedNode<E> curr = head;
181-
int i = 0;
182-
while (i < index - 1) {
183-
curr = curr.next;
184-
i++;
185-
}
186-
return (index == 0) ? null : curr;
178+
return getNode(index - 1);
187179
}
188180

189181
private SingleLinkedNode<E> getPredecessorNode(E item) {
@@ -249,7 +241,7 @@ private void isLinkedListEmpty() {
249241

250242
private void isIndexOutOfBounds(int index) {
251243
if (index < 0 || index > size) {
252-
throw new IndexOutOfBoundsException("Index must be less than " + size);
244+
throw new IndexOutOfBoundsException("Index [" + index + "] must be less than size [" + size + "]");
253245
}
254246
}
255247
}

0 commit comments

Comments
 (0)