here is the starter code:
public class LinkedListPracticeLab {
private LinkedListPracticeLab(){}
public static void main(String[] args) {
// Test all methods here
}
/**
* Given the heads of two sorted linked lists, merges the two lists in a one
sorted list.
* The list is made by splicing together the nodes of the original two lists,
without
* creating any new nodes.
*
* Returns the head of the merged linked list.
*/
public static ListNode mergeLists(ListNode head1, ListNode head2) {
return null;
}
/**
* Given the head of a sorted linked list, deletes all duplicates such that
each element appears only once.
*
* Returns the head of the resulting linked list, which is still sorted.
*/
public static ListNode deleteDuplicates(ListNode head) {
return null;
}
/**
* Given the head of a linked list and an integer val, removes all the nodes of
the linked list that has
* Node.val == val.
*
* Returns the head of the resulting list.
*/
public static ListNode removeElements(ListNode head, int val) {
return null;
}
/**
* Given the head of a zero-indexed linked list and two indices i and j, swaps
the elements at these indices.
*
* Returns the head of the resulting list.
*/
public static ListNode swapElements(ListNode head, int i, int j) {
return null;
}
/**
* Given the head of a singly linked list, reverse the list, and return the
reversed list.
*/
public static ListNode reverseList(ListNode head) {
return null;
}
/**
* Given the head of a singly linked list, returns the middle node of the
linked list.
*
* If there are an even number of elements -- and thus two middle nodes --
returns the second middle node.
*/
public static ListNode middleNode(ListNode head) {
return null;
}
}
list node.java code:
/**
* Definition for singly-linked list.
*/
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
List utils.java code
/**
* Utilities for singly-linked non-circular lists.
*/
public class ListUtils {
private ListUtils() {}
static ListNode copyList(ListNode list) {
ListNode head = new ListNode(list.val);
ListNode currentNew = head;
ListNode currentOld = list.next;
while(currentOld != null) {
currentNew.next = new ListNode(currentOld.val);
currentNew = currentNew.next;
currentOld = currentOld.next;
}
return head;
}
static void displayList(ListNode list) {
if(list == null) {
System.out.println("[]");
return;
}
StringBuilder sb = new StringBuilder();
sb.append('[');
while(list != null) {
sb.append(list.val);
sb.append(',');
sb.append(' ');
list = list.next;
}
sb.delete(sb.lastIndexOf(","), sb.length());
sb.append(']');
System.out.println(sb);
}
static ListNode arrayToLinkedList(int[] arr) {
if(arr.length == 0)
return null;
ListNode head = new ListNode(arr[0]);
ListNode current = head;
for(int i = 1; i < arr.length; i++) {
current.next = new ListNode(arr[i]);
current = current.next;
}
return head;
}
}
For this lab you will solve a few separate problem.
here is the starter code public class LinkedListPracticeLab.pdf
1. here is the starter code:
public class LinkedListPracticeLab {
private LinkedListPracticeLab(){}
public static void main(String[] args) {
// Test all methods here
}
/**
* Given the heads of two sorted linked lists, merges the two lists in a one
sorted list.
* The list is made by splicing together the nodes of the original two lists,
without
* creating any new nodes.
*
* Returns the head of the merged linked list.
*/
public static ListNode mergeLists(ListNode head1, ListNode head2) {
return null;
}
/**
* Given the head of a sorted linked list, deletes all duplicates such that
each element appears only once.
*
* Returns the head of the resulting linked list, which is still sorted.
*/
public static ListNode deleteDuplicates(ListNode head) {
return null;
}
/**
* Given the head of a linked list and an integer val, removes all the nodes of
the linked list that has
* Node.val == val.
*
* Returns the head of the resulting list.
*/
public static ListNode removeElements(ListNode head, int val) {
return null;
}
/**
* Given the head of a zero-indexed linked list and two indices i and j, swaps
the elements at these indices.
*
* Returns the head of the resulting list.
2. */
public static ListNode swapElements(ListNode head, int i, int j) {
return null;
}
/**
* Given the head of a singly linked list, reverse the list, and return the
reversed list.
*/
public static ListNode reverseList(ListNode head) {
return null;
}
/**
* Given the head of a singly linked list, returns the middle node of the
linked list.
*
* If there are an even number of elements -- and thus two middle nodes --
returns the second middle node.
*/
public static ListNode middleNode(ListNode head) {
return null;
}
}
list node.java code:
/**
* Definition for singly-linked list.
*/
public class ListNode {
int val;
ListNode next;
ListNode() {}
ListNode(int val) { this.val = val; }
ListNode(int val, ListNode next) { this.val = val; this.next = next; }
}
List utils.java code
/**
* Utilities for singly-linked non-circular lists.
*/
public class ListUtils {
private ListUtils() {}
static ListNode copyList(ListNode list) {
ListNode head = new ListNode(list.val);
ListNode currentNew = head;
3. ListNode currentOld = list.next;
while(currentOld != null) {
currentNew.next = new ListNode(currentOld.val);
currentNew = currentNew.next;
currentOld = currentOld.next;
}
return head;
}
static void displayList(ListNode list) {
if(list == null) {
System.out.println("[]");
return;
}
StringBuilder sb = new StringBuilder();
sb.append('[');
while(list != null) {
sb.append(list.val);
sb.append(',');
sb.append(' ');
list = list.next;
}
sb.delete(sb.lastIndexOf(","), sb.length());
sb.append(']');
System.out.println(sb);
}
static ListNode arrayToLinkedList(int[] arr) {
if(arr.length == 0)
return null;
ListNode head = new ListNode(arr[0]);
ListNode current = head;
for(int i = 1; i < arr.length; i++) {
current.next = new ListNode(arr[i]);
current = current.next;
}
return head;
}
}
For this lab you will solve a few separate problems that involve linked lists. Some of these
problems are taken from leetcode, but in a few instances are made small changes. TASK 1
display linked lists. TASK 2 Download this starter code: LinkedListPracticeLab.java you are trying
to solve! And when designing your solution you may want to make some drawings of how the
linked lists are being manipulated. TASK 3 the tests. But make sure you include several tests for
4. each solution, and that you test for "special" or "boundary" cases. Submit: Your version of
LinkedListPracticeLab.java. For each implemented method, a screenshot showing tests for that
method.
![here is the starter code:
public class LinkedListPracticeLab {
private LinkedListPracticeLab(){}
public static void main(String[] args) {
// Test all methods here
}
/**
* Given the heads of two sorted linked lists, merges the two lists in a one
sorted list.
* The list is made by splicing together the nodes of the original two lists,
without
* creating any new nodes.
*
* Returns the head of the merged linked list.
*/
public static ListNode mergeLists(ListNode head1, ListNode head2) {
return null;
}
/**
* Given the head of a sorted linked list, deletes all duplicates such that
each element appears only once.
*
* Returns the head of the resulting linked list, which is still sorted.
*/
public static ListNode deleteDuplicates(ListNode head) {
return null;
}
/**
* Given the head of a linked list and an integer val, removes all the nodes of
the linked list that has
* Node.val == val.
*
* Returns the head of the resulting list.
*/
public static ListNode removeElements(ListNode head, int val) {
return null;
}
/**
* Given the head of a zero-indexed linked list and two indices i and j, swaps
the elements at these indices.
*
* Returns the head of the resulting list.](https://image.slidesharecdn.com/hereisthestartercodepublicclasslinkedlistpracticelab-230321055532-6a84a397/85/here-is-the-starter-code-public-class-LinkedListPracticeLab-pdf-1-320.jpg)
