I am working on a project for my Data Structures class that asks me to write a class to implement a linked list of ints. Use an inner class for the Node. Include the methods below. Write a tester to enable you to test all of the methods with whatever data you want in any order. I have to create three different constructors. One of the constructors is meant to be a constructor that creates a linked list of N random integers between low and high. I've written methods that do what the constructor is asking for and therefore wrote the code I would have in a method as a constructor. However, I don't think I'm right. Can someone let me know If I'm doing the right thing? If not tell me what I need to do?
import java.util.Random;
public class LinkedListOfInts {
Node head;
private class Node {
int value;
Node nextNode;
public Node(int value, Node nextNode) {
this.value = value;
this.nextNode = nextNode;
}
}
public LinkedListOfInts() {
}
public LinkedListOfInts(int N, int low, int high) {
Random random = new Random();
int[] result = new int[N];
for (int i = 0; i < N; i++)
result[i] = random.nextInt(high - low) + low;
}
public void addToFront(int x) {
head = new Node(x, head);
}
public String toString() {
String result = " ";
for (Node ptr = head; ptr != null; ptr = ptr.nextNode)
result += ptr.value + " ";
return result;
}
public static void main(String[] args) {
LinkedListOfInts list = new LinkedListOfInts();
for (int i = 0; i < 15; i++)
list.addToFront(i);
System.out.println(list);
}
}
Instead of creating an unused array, you should call addToFront
for each random integer to initialize the LinkedListOfInts
. Additionally, you should use random.nextInt(high - low + 1) + low
so that high
is not excluded.
public LinkedListOfInts(int N, int low, int high) {
Random random = new Random();
for (int i = 0; i < N; i++)
this.addToFront(random.nextInt(high - low + 1) + low);
}
To test it:
public static void main(String[] args) {
LinkedListOfInts list = new LinkedListOfInts(5, 1, 10);
System.out.println(list);
}
// Java program to select a random node from singly linked list
import java.util.*;
// Linked List Class
class LinkedList {
static Node head; // head of list
/* Node Class */
static class Node {
int data;
Node next;
// Constructor to create a new node
Node(int d) {
data = d;
next = null;
}
}
// A reservoir sampling based function to print a
// random node from a linked list
void printrandom(Node node) {
// If list is empty
if (node == null) {
return;
}
// Use a different seed value so that we don't get
// same result each time we run this program
Math.abs(UUID.randomUUID().getMostSignificantBits());
// Initialize result as first node
int result = node.data;
// Iterate from the (k+1)th element to nth element
Node current = node;
int n;
for (n = 2; current != null; n++) {
// change result with probability 1/n
if (Math.random() % n == 0) {
result = current.data;
}
// Move to next node
current = current.next;
}
System.out.println("Randomly selected key is " + result);
}
// Driver program to test above functions
public static void main(String[] args) {
LinkedList list = new LinkedList();
list.head = new Node(5);
list.head.next = new Node(20);
list.head.next.next = new Node(4);
list.head.next.next.next = new Node(3);
list.head.next.next.next.next = new Node(30);
list.printrandom(head);
}
}
Algorithm : (1) Initialize result as first node
result = head->key
(2) Initialize n = 2
(3) Now one by one consider all nodes from 2nd node onward.
(3.a) Generate a random number from 0 to n-1.
Let the generated random number is j.
(3.b) If j is equal to 0 (we could choose other fixed number
between 0 to n-1), then replace result with current node.
(3.c) n = n+1
(3.d) current = current->next
The technical post webpages of this site follow the CC BY-SA 4.0 protocol. If you need to reprint, please indicate the site URL or the original address.Any question please contact:yoyou2525@163.com.