I have been tasked to write a code for a Singly Linked list that inc.pdf
•
0 likes•3 views
I have been tasked to write a code for a Singly Linked list that includes the following: Implement a singly linked list class with the following methods: - `void insertAtBeginning(int value)`: Inserts a new node with the given value at the beginning of the list. - `void insertAtEnd(int value)`: Inserts a new node with the given value at the end of the list. - `void deleteNode(int value)`: Deletes the first occurrence of a node with the given value. - `void display()`: Displays the elements of the linked list. I have everything EXCEPT for the deleteNode. I have it included, but it is throwing an error....I just need a little extra help to fix that part. My Code: # #include using namespace std; class Node { //user defined type. public: // public class modifier to access the class node. int value; Node* next; }; void display(Node *head) { if(head == NULL){ cout << "NULL" << endl; } else { cout << head->value << endl; display(head->next); } } void insertAtBeginning(Node**head, int newValue){ // Steps to add a Node to the beginning of the linked list //1. Prepare a newNode Node * newNode = new Node(); newNode ->value = newValue; //2. Put it in front of the current head newNode->next = *head; //3. Move head of the list to point to the newNode *head= newNode; } void insertAtEnd(Node**head, int newValue) { //1.Prepare a newNode Node* newNode= new Node(); newNode ->value = newValue; newNode->next = NULL; //2. If Linked list is empty, newNode will be a head node if(*head ==NULL){ *head = newNode; return; } //3. Find last node Node* last= *head; while(last->next!=NULL){ last=last->next; } //4. Insert newNode after last node (at the end of List) last->next =newNode; } void deleteNode(Node**before_del){ Node* temp; temp = before_del->next; before_del->next = temp->next; delete temp; } int main() { Node* head=new Node(); Node* second=new Node(); Node* third=new Node(); Node* fourth=new Node(); head->value = 7; head->next = second; second->value = 12; second->next = third; third->value = 15; third->next = fourth; fourth->value = 20; fourth->next = NULL; insertAtBeginning(&head, 4); insertAtBeginning(&head, 6); insertAtEnd(&head, 23); del(&head(15)->next); display(head); }.
Report
Share
Report
Share
Download to read offline
Recommended
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem: Describe an algorithm for concatenating two singly linked lists L and M, into a single
list L that contains all the nodes of L followed by all the nodes of M.
Modify the SinglyLinkedList class to contain the method:
public void concatenate(SinglyLinkedList other) { ... }
---------------Below is the code--------------------
public class SinglyLinkedList<E> implements Cloneable {
//---------------- nested Node class ----------------
/**
* Node of a singly linked list, which stores a reference to its
* element and to the subsequent node in the list (or null if this
* is the last node).
*/
private static class Node<E> {
/** The element stored at this node */
private E element; // reference to the element stored at this node
/** A reference to the subsequent node in the list */
private Node<E> next; // reference to the subsequent node in the list
/**
* Creates a node with the given element and next node.
*
* @param e the element to be stored
* @param n reference to a node that should follow the new node
*/
public Node(E e, Node<E> n) {
element = e;
next = n;
}
// Accessor methods
/**
* Returns the element stored at the node.
* @return the element stored at the node
*/
public E getElement() { return element; }
/**
* Returns the node that follows this one (or null if no such node).
* @return the following node
*/
public Node<E> getNext() { return next; }
// Modifier methods
/**
* Sets the node's next reference to point to Node n.
* @param n the node that should follow this one
*/
public void setNext(Node<E> n) { next = n; }
} //----------- end of nested Node class -----------
// instance variables of the SinglyLinkedList
/** The head node of the list */
private Node<E> head = null; // head node of the list (or null if empty)
/** The last node of the list */
private Node<E> tail = null; // last node of the list (or null if empty)
/** Number of nodes in the list */
private int size = 0; // number of nodes in the list
/** Constructs an initially empty list. */
public SinglyLinkedList() { } // constructs an initially empty list
// access methods
/**
* Returns the number of elements in the linked list.
* @return number of elements in the linked list
*/
public int size() { return size; }
/**
* Tests whether the linked list is empty.
* @return true if the linked list is empty, false otherwise
*/
public boolean isEmpty() { return size == 0; }
/**
* Returns (but does not remove) the first element of the list
* @return element at the front of the list (or null if empty)
*/
public E first() { // returns (but does not remove) the first element
if (isEmpty()) return null;
return head.getElement();
}
/**
* Returns (but does not remove) the last element of the list.
* @return element at the end of the list (or null if empty)
*/
public E last() { // returns (but does not remove) the last element
if (isEmpty()) return null;
return tail.getElement();
}
// update methods
/**
* Adds an element to the front of the list.
* @param e the new element to add
*/
publ.
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem: Describe an algorithm for concatenating two singly linked lists L and M, into a single
list L that contains all the nodes of L followed by all the nodes of M. Modify the
SinglyLinkedList class to contain the method:
public void concatenate(SinglyLinkedList other) { ... }
PLEASE PLEASE USE THE CODE BELOW..... THANK YOU
public class SinglyLinkedList<E> implements Cloneable {
//---------------- nested Node class ----------------
/**
* Node of a singly linked list, which stores a reference to its
* element and to the subsequent node in the list (or null if this
* is the last node).
*/
private static class Node<E> {
/** The element stored at this node */
private E element; // reference to the element stored at this node
/** A reference to the subsequent node in the list */
private Node<E> next; // reference to the subsequent node in the list
/**
* Creates a node with the given element and next node.
*
* @param e the element to be stored
* @param n reference to a node that should follow the new node
*/
public Node(E e, Node<E> n) {
element = e;
next = n;
}
// Accessor methods
/**
* Returns the element stored at the node.
* @return the element stored at the node
*/
public E getElement() { return element; }
/**
* Returns the node that follows this one (or null if no such node).
* @return the following node
*/
public Node<E> getNext() { return next; }
// Modifier methods
/**
* Sets the node's next reference to point to Node n.
* @param n the node that should follow this one
*/
public void setNext(Node<E> n) { next = n; }
} //----------- end of nested Node class -----------
// instance variables of the SinglyLinkedList
/** The head node of the list */
private Node<E> head = null; // head node of the list (or null if empty)
/** The last node of the list */
private Node<E> tail = null; // last node of the list (or null if empty)
/** Number of nodes in the list */
private int size = 0; // number of nodes in the list
/** Constructs an initially empty list. */
public SinglyLinkedList() { } // constructs an initially empty list
// access methods
/**
* Returns the number of elements in the linked list.
* @return number of elements in the linked list
*/
public int size() { return size; }
/**
* Tests whether the linked list is empty.
* @return true if the linked list is empty, false otherwise
*/
public boolean isEmpty() { return size == 0; }
/**
* Returns (but does not remove) the first element of the list
* @return element at the front of the list (or null if empty)
*/
public E first() { // returns (but does not remove) the first element
if (isEmpty()) return null;
return head.getElement();
}
/**
* Returns (but does not remove) the last element of the list.
* @return element at the end of the list (or null if empty)
*/
public E last() { // returns (but does not remove) the last element
if (isEmpty()) return null;
return tail.getElement();
}
// update methods
/**
* Adds an element to the front of the list.
* @param e the new element to add
*/
public vo.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
C++: Doubly-Linked Lists
The goal of the exercise is to implement a class List of doubly- linked lists.
My goal is to implement the class in a file doubly-linked.cpp.
The class List implements lists using the following structures for list ele- ments:
struct Node { int val ;
Node next;
Node prev; };
Each Node contains a value (an integer) and two pointers: one meant to point to the next element
of the list and one meant to point to the previous element in the list. The class provides the
following methods that you need to implement:
• A constructor and a destructor, with no arguments;
• void insert(int n): insert an integer at the end of the list;
• void reverse(): reverse the list;
• void print(): print the list to cout in the same format as the input (i.e. integers separated by
spaces);
doubly-linked.h
#ifndef __dll__
#define __dll__
#include
using namespace std;
// Basic structure to store elements of a list
struct Node {
int val; // contains the value
Node * next; // pointer to the next element in the list
Node * prev; // pointer to the previous element in the list
};
// Class List
class List {
public:
List(void); // Constructor
~List(void); // Destructor
void insert(int n); // This should insert n in the list
void reverse(void); // This should reverse the list
void print(void); // This shoiuld print the list
private:
Node * first; // Pointer to the first (if any) element in the list
};
#endif
main.cpp
#include
#include \"doubly-linked.h\"
using namespace std;
int main(void){
List l;
int n;
while(cin >> n){
l.insert(n);
}
// Print list as read from cin
l.print();
// Reverse the list and print it
l.reverse();
l.print();
// Reverse again and print it
l.reverse();
l.print();
return 0;
}
Solution
#include
using namespace std;
/* Linked list structure */
struct list {
struct list *prev;
int data;
struct list *next;
} *node = NULL, *first = NULL, *last = NULL, *node1 = NULL, *node2 = NULL;
class linkedlist {
public:
/* Function for create/insert node at the beginning of Linked list */
void insrt_frnt() {
list *addBeg = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addBeg->data;
if(first == NULL) {
addBeg->prev = NULL;
addBeg->next = NULL;
first = addBeg;
last = addBeg;
cout << \"Linked list Created!\" << endl;
}
else {
addBeg->prev = NULL;
first->prev = addBeg;
addBeg->next = first;
first = addBeg;
cout << \"Data Inserted at the beginning of the Linked list!\" << endl;
}
}
/* Function for create/insert node at the end of Linked list */
void insrt_end() {
list *addEnd = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addEnd->data;
if(first == NULL) {
addEnd->prev = NULL;
addEnd->next = NULL;
first = addEnd;
last = addEnd;
cout << \"Linked list Created!\" << endl;
}
else {
addEnd->next = NULL;
last->next = addEnd;
addEnd->prev = last;
last = addEnd;
cout << \"Data Inserted at the end of the Linked list!\" << endl;
}
}
/* Function for Display Linked list */
void display() {
node = first;
cout << \"List of data in L.
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
Recommended
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem: Describe an algorithm for concatenating two singly linked lists L and M, into a single
list L that contains all the nodes of L followed by all the nodes of M.
Modify the SinglyLinkedList class to contain the method:
public void concatenate(SinglyLinkedList other) { ... }
---------------Below is the code--------------------
public class SinglyLinkedList<E> implements Cloneable {
//---------------- nested Node class ----------------
/**
* Node of a singly linked list, which stores a reference to its
* element and to the subsequent node in the list (or null if this
* is the last node).
*/
private static class Node<E> {
/** The element stored at this node */
private E element; // reference to the element stored at this node
/** A reference to the subsequent node in the list */
private Node<E> next; // reference to the subsequent node in the list
/**
* Creates a node with the given element and next node.
*
* @param e the element to be stored
* @param n reference to a node that should follow the new node
*/
public Node(E e, Node<E> n) {
element = e;
next = n;
}
// Accessor methods
/**
* Returns the element stored at the node.
* @return the element stored at the node
*/
public E getElement() { return element; }
/**
* Returns the node that follows this one (or null if no such node).
* @return the following node
*/
public Node<E> getNext() { return next; }
// Modifier methods
/**
* Sets the node's next reference to point to Node n.
* @param n the node that should follow this one
*/
public void setNext(Node<E> n) { next = n; }
} //----------- end of nested Node class -----------
// instance variables of the SinglyLinkedList
/** The head node of the list */
private Node<E> head = null; // head node of the list (or null if empty)
/** The last node of the list */
private Node<E> tail = null; // last node of the list (or null if empty)
/** Number of nodes in the list */
private int size = 0; // number of nodes in the list
/** Constructs an initially empty list. */
public SinglyLinkedList() { } // constructs an initially empty list
// access methods
/**
* Returns the number of elements in the linked list.
* @return number of elements in the linked list
*/
public int size() { return size; }
/**
* Tests whether the linked list is empty.
* @return true if the linked list is empty, false otherwise
*/
public boolean isEmpty() { return size == 0; }
/**
* Returns (but does not remove) the first element of the list
* @return element at the front of the list (or null if empty)
*/
public E first() { // returns (but does not remove) the first element
if (isEmpty()) return null;
return head.getElement();
}
/**
* Returns (but does not remove) the last element of the list.
* @return element at the end of the list (or null if empty)
*/
public E last() { // returns (but does not remove) the last element
if (isEmpty()) return null;
return tail.getElement();
}
// update methods
/**
* Adds an element to the front of the list.
* @param e the new element to add
*/
publ.
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem: Describe an algorithm for concatenating two singly linked lists L and M, into a single
list L that contains all the nodes of L followed by all the nodes of M. Modify the
SinglyLinkedList class to contain the method:
public void concatenate(SinglyLinkedList other) { ... }
PLEASE PLEASE USE THE CODE BELOW..... THANK YOU
public class SinglyLinkedList<E> implements Cloneable {
//---------------- nested Node class ----------------
/**
* Node of a singly linked list, which stores a reference to its
* element and to the subsequent node in the list (or null if this
* is the last node).
*/
private static class Node<E> {
/** The element stored at this node */
private E element; // reference to the element stored at this node
/** A reference to the subsequent node in the list */
private Node<E> next; // reference to the subsequent node in the list
/**
* Creates a node with the given element and next node.
*
* @param e the element to be stored
* @param n reference to a node that should follow the new node
*/
public Node(E e, Node<E> n) {
element = e;
next = n;
}
// Accessor methods
/**
* Returns the element stored at the node.
* @return the element stored at the node
*/
public E getElement() { return element; }
/**
* Returns the node that follows this one (or null if no such node).
* @return the following node
*/
public Node<E> getNext() { return next; }
// Modifier methods
/**
* Sets the node's next reference to point to Node n.
* @param n the node that should follow this one
*/
public void setNext(Node<E> n) { next = n; }
} //----------- end of nested Node class -----------
// instance variables of the SinglyLinkedList
/** The head node of the list */
private Node<E> head = null; // head node of the list (or null if empty)
/** The last node of the list */
private Node<E> tail = null; // last node of the list (or null if empty)
/** Number of nodes in the list */
private int size = 0; // number of nodes in the list
/** Constructs an initially empty list. */
public SinglyLinkedList() { } // constructs an initially empty list
// access methods
/**
* Returns the number of elements in the linked list.
* @return number of elements in the linked list
*/
public int size() { return size; }
/**
* Tests whether the linked list is empty.
* @return true if the linked list is empty, false otherwise
*/
public boolean isEmpty() { return size == 0; }
/**
* Returns (but does not remove) the first element of the list
* @return element at the front of the list (or null if empty)
*/
public E first() { // returns (but does not remove) the first element
if (isEmpty()) return null;
return head.getElement();
}
/**
* Returns (but does not remove) the last element of the list.
* @return element at the end of the list (or null if empty)
*/
public E last() { // returns (but does not remove) the last element
if (isEmpty()) return null;
return tail.getElement();
}
// update methods
/**
* Adds an element to the front of the list.
* @param e the new element to add
*/
public vo.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
C++: Doubly-Linked Lists
The goal of the exercise is to implement a class List of doubly- linked lists.
My goal is to implement the class in a file doubly-linked.cpp.
The class List implements lists using the following structures for list ele- ments:
struct Node { int val ;
Node next;
Node prev; };
Each Node contains a value (an integer) and two pointers: one meant to point to the next element
of the list and one meant to point to the previous element in the list. The class provides the
following methods that you need to implement:
• A constructor and a destructor, with no arguments;
• void insert(int n): insert an integer at the end of the list;
• void reverse(): reverse the list;
• void print(): print the list to cout in the same format as the input (i.e. integers separated by
spaces);
doubly-linked.h
#ifndef __dll__
#define __dll__
#include
using namespace std;
// Basic structure to store elements of a list
struct Node {
int val; // contains the value
Node * next; // pointer to the next element in the list
Node * prev; // pointer to the previous element in the list
};
// Class List
class List {
public:
List(void); // Constructor
~List(void); // Destructor
void insert(int n); // This should insert n in the list
void reverse(void); // This should reverse the list
void print(void); // This shoiuld print the list
private:
Node * first; // Pointer to the first (if any) element in the list
};
#endif
main.cpp
#include
#include \"doubly-linked.h\"
using namespace std;
int main(void){
List l;
int n;
while(cin >> n){
l.insert(n);
}
// Print list as read from cin
l.print();
// Reverse the list and print it
l.reverse();
l.print();
// Reverse again and print it
l.reverse();
l.print();
return 0;
}
Solution
#include
using namespace std;
/* Linked list structure */
struct list {
struct list *prev;
int data;
struct list *next;
} *node = NULL, *first = NULL, *last = NULL, *node1 = NULL, *node2 = NULL;
class linkedlist {
public:
/* Function for create/insert node at the beginning of Linked list */
void insrt_frnt() {
list *addBeg = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addBeg->data;
if(first == NULL) {
addBeg->prev = NULL;
addBeg->next = NULL;
first = addBeg;
last = addBeg;
cout << \"Linked list Created!\" << endl;
}
else {
addBeg->prev = NULL;
first->prev = addBeg;
addBeg->next = first;
first = addBeg;
cout << \"Data Inserted at the beginning of the Linked list!\" << endl;
}
}
/* Function for create/insert node at the end of Linked list */
void insrt_end() {
list *addEnd = new list;
cout << \"Enter value for the node:\" << endl;
cin >> addEnd->data;
if(first == NULL) {
addEnd->prev = NULL;
addEnd->next = NULL;
first = addEnd;
last = addEnd;
cout << \"Linked list Created!\" << endl;
}
else {
addEnd->next = NULL;
last->next = addEnd;
addEnd->prev = last;
last = addEnd;
cout << \"Data Inserted at the end of the Linked list!\" << endl;
}
}
/* Function for Display Linked list */
void display() {
node = first;
cout << \"List of data in L.
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Create a link list. Add some nodes to it, search and delete nodes from it.
Solution
#include
#include
using std::cout;
using std::endl;
/*
A linked list is a list constructed using pointers. It is not fixed in
size and could grow and shrink while the program is running.
A typical defination of list nodes contains at least two parts, both the
content or date of each element and the pointer to the next element,
which is shown in the figure below.
+---------+
| Data | -----> holds the data of this element in the list.
+---------+
| pointer | -----> is a pointer to the next element in the list.
+---------+
***Attention***:
The pointer holds the address of the next element, not the address of the
data in the next element, even though they are the same in value sometimes.
And It should be set to NULL while acting as the last node of the list.
Implementation of the single linked list:
+---------+ --->+---------+ --->+---------+
| Data | | | Data | | | Data |
+---------+ | +---------+ | +---------+
| pointer |----- | pointer |----- | pointer |
+---------+ +---------+ +---------+
*/
/* definition of the list node class */
class Node
{
friend class LinkedList;
private:
int _value; /* data, can be any data type, but use integer for easiness */
Node *_pNext; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: _pNext(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: _value(val), _pNext(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: _value(val), _pNext(next)
{}
/* Getters */
int getValue(void)
{ return _value; }
Node* getNext(void)
{ return _pNext; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *_pHead;
/* pointer of tail node */
Node *_pTail;
public:
/* Constructors with No Arguments */
LinkedList(void);
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to add a node at the head of a linked list */
void headInsert(int val);
/* Function to add a node in the middle of a linked list */
void insertAfter(Node* afterMe, int val);
/* Function to append a node to the end of a linked list */
void tailAppend(int val);
/* Function to get the node in the specific position */
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
LinkedList::LinkedList()
{
/* Initialize the head and tail node */
_pHead = _pTail = NULL;
}
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
_pHead = new Node(val);
_pTail = _pHead;
}
LinkedList::~LinkedList()
{
/*
* Leave it empty temporarily.
* It will be described in detail in the example \"How to delete a linkedlist\".
*/
}
void LinkedList::headInsert(int val)
{
/* The list is empty? */
if (_pHead == NULL) {
/* the same to create a new list with a given value */
_pTail = _pHead = new Node(val);
.
Describe an algorithm for concatenating two singly linked lists L and.pdf
Dataset:
https://docs.google.com/spreadsheets/d/1NxuGt4LJ3ofi2PaWLWpAl90JmfqMKcGV/edit?usp=sharing&ouid=111109979069524025260&rtpof=true&sd=true
Q1) What is the average tenure of those customers of the telecom operator who are still with the
company as a customer and also those who have stopped using the services provided by the
company? (1 mark)
Here, churn = 'No' means that the customer is currently associated with the company, and churn
= 'Yes' means that the customer has stopped using the services provided by the company.
Q2)What is the monthly average revenue generated by the customers who are with the company
and also those who have left? (1 mark)
Q3) Find the percentage of churn and non-churn customers for each category of the following
services: (4 marks)
-MultipleLines
-PaperlessBilling
-OnlineSecurity
-OnlineBackup
-DeviceProtection
-TechSupport
-StreamingTV
-StreamingMovies.
please help me in C++Objective Create a singly linked list of num.pdf
please help me in C++
Objective: Create a singly linked list of numbers based upon user input.
Program logic: Ask for a number, add that number to the front of the list, print the list. Repeat
until they enter -1 for the number. .
Sample Input: 10, 15, 5, 2, 4, -1 Output: 4, 2, 5, 15, 10
Solution
#include
#include
using namespace std;
// It contains the value and the pointer to the next element in the list.
struct element {
int value;
struct element *next;
};
struct element *head = NULL;
// The list is stored in the object of this class.
class linkedlist {
public:
// To display list, we first see if head is NULL,
// If head is NULL it means the list is empty.
// Then we traverse along the list and display each item, until the next pointer is NULL.
void display() {
if(head == NULL){
cout << \"The list is empty\ \";
} else {
struct element *temp;
temp = head;
while(temp != NULL){
cout << temp->value << \" \" ;
temp = temp->next;
}
cout << \"\ \";
}
}
// To add an element to the list,create a newElement and store the value.
// If head is NULL, add the newElement to the head.
// To add an element at the starting of the list.
// The next pointer of the newElement must point to the old head.
// The new head must be pointed to the newElement.
void add(int a){
struct element *newElement;
newElement = (struct element *)malloc(sizeof(struct element));
newElement->value = a;
newElement->next = NULL;
if(head == NULL) {
head = newElement;
} else {
newElement->next = head;
head = newElement;
}
}
};
int main()
{
// Create an object of the class linkedlist.
linkedlist l = linkedlist();
int a;
do {
cout << \"Enter a number : \";
cin >> a;
if(a!=-1) { // If the number is -1 do not add it to the list.
l.add(a); // Add the number to the list.
}
l.display(); // Display the list.
} while(a!=-1); // Keep asking for a number until -1 is pressed.
return 0;
}.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header using C?
Solution
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
// Update current
current = next;
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* A utility function to insert a node at the beginning of linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = new node;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf(\"Linked List before sorting \ \");
printList(a);
insertionSort(&a);
printf(\"\ Linked List after sorting \ \");
printList(a);
return 0;
}
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct.
C Homework Help
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
C++ Please write the whole code that is needed for this assignment- wr.docx
Brianca plans to save $5,000, $1,000, and $42,000 a year over the next three years, respectively. How much would you need to deposit in one lump sum today to have the same amount as Brianca three years from now if you both earn 10.9 percent, compounded annually? $36,115 $35,192 $43,282 $41,635 $35,372
.
Using the provided table interface table.h and the sample linked lis.pdf
Using the provided table interface table.h and the sample linked list code linkedList.c, complete
an implementation of the Table ADT. Make sure that you apply the concepts of design by
contract (DbC) to your implementation.
Once you have fully implemented the table, create a main.c file that implements a testing
framework for your table.
Your table implementation must ensure that values inserted are unique, and internally sorted
within a linked list.
table.h
linkedList.c
Solution
khsdg
#include
#include
typedef enum BOOL { false, true } bool;
// Linked list node definition
typedef struct Node node;
struct Node
{
int number;
node *next;
};
static node *top = NULL;
// used to track where we are for the list traversal methods
static node *traverseNode = NULL;
// \"destroy\" will deallocate all nodes in a linked list object
// and will set \"top\" to NULL.
void destroy()
{
node *curr = top;
node *temp = NULL;
while ( curr != NULL )
{
// flip order to see it blow up...
temp = curr;
curr = curr->next;
free( temp );
}
top = NULL;
}
// \"build\" will create an ordered linked list consisting
// of the first \"size\" even integers.
void build( int size )
{
node *newNode = NULL;
int i = 0;
// make sure we don\'t have a list yet
destroy();
for ( i=size ; i>0 ; i-- )
{
newNode = malloc( sizeof( node ) );
newNode->number = i*2;
newNode->next = top;
top = newNode;
}
}
// starts a list traversal by getting the data at top.
// returns false if top == NULL.
bool firstNode( int *item )
{
bool result = false;
if ( top )
{
*item = top->number;
traverseNode = top->next;
result = true;
}
return result;
}
// gets the data at the current traversal node and increments the traversal.
// returns false if we\'re at the end of the list.
bool nextNode( int *item )
{
bool result = false;
if ( traverseNode )
{
*item = traverseNode->number;
traverseNode = traverseNode->next;
result = true;
}
return result;
}
// \"print\" will output an object\'s entire linked list
// to the standard output device -- one \"number\" per line.
void print()
{
int value;
if ( firstNode( &value ) )
{
do
{
printf( \"%d\ \", value );
} while ( nextNode( &value ) );
}
}
int main( int argc, char *argv[] )
{
build( 10 );
print();
destroy();
build( 5 );
build( 20 );
print();
destroy();
return 0;
}.
C code on linked list #include stdio.h #include stdlib.h.pdf
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps
Solution
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps.
To complete the task, you need to fill in the missing code. I’ve inc.pdf
To complete the task, you need to fill in the missing code. I’ve included code to create an
Iterator. An Iterator is an object that iterates over another object – in this case, a circular linked
list. You can use the .next() method to advance the Iterator to the next item (the first time you
call it, the iterator will travel to node at index 0). Using iterator’s .remove() removes the node the
iterator is currently at. Say that we had a CircularLinkedList that looked like this: A ==> B ==>
C ==> D ==> E ==> Calling .next() three times will advance the iterator to index 2. Calling
.remove() once will remove the node at index 2. A ==> B ==> D ==> E ==> Calling .remove()
once more will remove the node now at index 2. A ==> B ==> E ==> The Iterator methods
handle wrapping around the CircularLinkedList. Be sure to create the iterator using l.iterator()
and after you’ve added all the nodes to the list, where l is your CircularLinkedList
Solution
import java.util.Iterator;
class CircularLinkedList implements Iterable {
// Your variables
// You can include a reference to a tail if you want
Node head;
int size; // BE SURE TO KEEP TRACK OF THE SIZE
// implement this constructor
public CircularLinkedList() {
head=null;
}
// writing helper functions for add and remove, like the book did can help
// but remember, the last element\'s next node will be the head!
// attach a node to the end of the list
// Be sure to handle the adding to an empty list
// always returns true
public boolean add(E e) {
Node newNode=new Node(e);
if(size==0){
head=newNode;
}
else{
Node last=getNode(size-1);
last.next=newNode;
}
newNode.next=head; //last element node is set to head
size++;
return true;
}
// need to handle
// out of bounds
// empty list
// adding to front
// adding to middle
// adding to \"end\"
// REMEMBER TO INCREMENT THE SIZE
public boolean add(int index, E e){
if(index>size) return false;
Node tmp=new Node(e);
if(index==0){
tmp.next=head;
Node last=getNode(size-1);
head=tmp;
last.next=head;
}
else {
Node curr=getNode(index-1);
tmp.next=curr.next;
curr.next=tmp;
}
size++;
return true;
}
// I highly recommend using this helper method
// Return Node found at the specified index
// be sure to handle out of bounds cases
private Node getNode(int index ) {
Node prev=head;
for(int i=0;isize) {
e=null;
}
else if(index==0){
e = head.getElement();
Node last=getNode(size-1);
head=head.next;
last.next=head;
size--;
}
else{
Node prev=getNode(index-1);
Node curr=getNode(index);
e=curr.getElement();
prev.next=curr.next;
size--;
}
return e;
}
// Turns your list into a string
// Useful for debugging
public String toString(){
Node current = head;
StringBuilder result = new StringBuilder();
if(size == 0){
return \"\";
}
if(size == 1) {
return head.getElement().toString();
}
else{
do{
result.append(current.getElement());
result.append(\" ==> \");
current = current.next;
} while(current != head);
}
return result.toString();
}
public Iterator iterator() {
return new ListIterator();
}
/.
package linkedLists- import java-util-Iterator- --- A class representi.pdf
package linkedLists;
import java.util.Iterator;
/** A class representing a singly linked list from scratch. Fill in code.
*
* Note: you may NOT use any of Java's built in classes that store a collection of elements
* such as ArrayList, LinkedList (Java's built in), HashMap, HashTree, HashSet etc. */
public class LinkedList {
private Node head, tail;
/** Constructor */
public LinkedList() {
head = null;
tail = null;
}
/**
* Creates a new node with the given element and adds it to the back of the
* list. No need to change this method.
*/
public void append(int elem) {
Node newNode = new Node(elem);
if (tail != null) {
tail.setNext(newNode);
tail = newNode;
} else {
head = tail = newNode;
}
}
/** Prints all the nodes in the link list. No need to change this method. */
public void printNodes() {
Node current = head;
while (current != null) {
System.out.print(current.elem() + " ");
current = current.next();
}
}
/**
* Return a sublist of this list where the values of elements are in the range
* from value1 to value2, inclusive.
* Your method should not destroy the original list and its nodes should *not* reference
* the nodes in the input list (you need to create new nodes instead).
* Example:
* If the list is 6->40->3->17->1 and value1 is 3 and value2 is 20,
* then the result should be 6->3->17.
* @param value1 value 1
* @param value2 value 2
* @return a sublist of this list where the values of elements are in the range
* * from value1 to value2, inclusive.
*/
public LinkedList sublist(int value1, int value2) {
LinkedList res = new LinkedList();
// FILL IN CODE
return res;
}
/**
* Insert a new node with the given element into the sorted linked list.
* Insert it in the right place based on the value in the node. Assume the
* list is sorted by the elem, from smallest to largest. The
* list should remain sorted after this insert operation.
* Example: If this list is 5->10->18 and we insert 15, then after that the operation,
* the list will become 5->10->15->18.
*/
public void insertInSortedList(int elem) {
// insert a node into the sorted list
// FILL IN CODE
}
/**
* Assume this linked list is sorted in ascending order, and we do not know the
* * number of elements.
* * Return a LinkedList that contains k largest elements in the list.
* * Use slow & fast pointers to find the k-th node from the end (required). Note: This method
* * should be linear and should not count the number of nodes. Do NOT use reverse().
* @param k index from the end
* @return linked list that contains k largest elements (k elements from the end of the list)
*/
public LinkedList getKLargest(int k) {
LinkedList result = new LinkedList();
// FILL IN CODE
return result;
}
/**
* Merge two sorted linked lists into a single sorted linked list.
*
* @param list1
* @param list2
* Your method should not destroy the original list and its nodes should *not* reference
* the nodes in the input list (you need to create new nodes instead).
*/
public static LinkedList mergeSortedLists(LinkedLis.
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
1#include stdio.h#include stdlib.h#include assert.h .pdf
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
2
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
Solution
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node*.
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables: a double data value, a pointer to the next node, and a pointer to the previous
node. Each member variable is protected. So code outside of the class must use the provided
getter and setter member functions to get or set a member variable. Node.h is read only, since no
changes are required. Step 2: Implement the Insert() member function A class for a sorted,
doubly-linked list is declared in SortedNumberList.h. Implement the SortedNumberList class's
Insert() member function. The function must create a new node with the parameter value, then
insert the node into the proper sorted position in the linked list. Ex: Suppose a
SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node with data
value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's sorted order
and yielding: 23 35.5 47.25 86 Step 3: Test in develop mode Code in main() takes a space-
separated list of numbers and inserts each into a SortedNumberList. The list is displayed after
each insertion. Ex: If input is 77 15 -42 63.5 then output is: List after inserting 77: 77 List after
inserting 15: 15 77 List after inserting -42: -42 15 77 List after inserting 63.5: -42 15 63.5 77 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove() member function. The
function takes a parameter for the number to be removed from the list. If the number does not
exist in the list, the list is not changed and false is returned. Otherwise, the first instance of the
number is removed from the list and true is returned. Uncomment the commented-out part in
main() that reads a second input line and removes numbers from the list. Test in develop mode to
ensure that insertion and removal both work properly, then submit code for grading. Ex: If input
is 84 72 19 61 19 84 then output is: List after inserting 84: 84 List after inserting 72: 72 84 List
after inserting 19: 19 72 84 List after inserting 61: 19 61 72 84 List after removing 19: 61 72 84
List after removing 84: 61 72
main.cpp
#include
#include
#include
#include "Node.h"
#include "SortedNumberList.h"
using namespace std; void PrintList(SortedNumberList& list); vector SpaceSplit(string source);
int main(int argc, char *argv[]) { // Read the line of input numbers string inputLine; getline(cin,
inputLine); // Split on space character vector terms = SpaceSplit(inputLine); // Insert each value
and show the sorted list's contents after each insertion SortedNumberList list; for (auto term :
terms) { double number = stod(term); cout << "List after inserting " << number << ": " << endl;
list.Insert(number); PrintList(list); } /* // Read the input line with numbers to remove getline(cin,
inputLi.
C++Write a method Node Nodereverse() which reverses a list..pdf
C++
Write a method Node *Node::reverse() which reverses a list.
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf(\"Given linked list\ \");
printList(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
getchar();
}.
Here is selection filepublic class Selection { public static in.pdf
Here is selection file:
public class Selection { public static int select(int[] array, int n, int k)
{ return select(array, 0, n - 1, k); }
private static int select(int[] array, int left, int right, int k) { // complete this function } }
here is MedianOfMedians file:
public class MedianOfMedians { private static void insertionSort(int[] arr, int left, int right)
{ for (int i = left + 1; i <= right; i++) {
int j = i, temp = arr[j];
while (j > left && temp < arr[j - 1])
{ arr[j] = arr[j - 1];
j--; }
arr[j] = temp;
}
}
public static int select(int[] array, int n, int k) { return select(array, 0, n - 1, k); }
private static int select(int[] array, int left, int right, int k) { // complete this function
} }
here is Partition file needed to code this correctly
public class Partition {
static Random rand = new Random(System.currentTimeMillis());
protected static void swap(int[] array, int x, int y) { int temp = array[x];
array[x] = array[y];
array[y] = temp; }
public static int generateRandomPivot(int[] array, int left, int right)
{ return left + rand.nextInt(right - left + 1); }
public static int generateMedianOf3Pivot(int[] array, int left, int right) {
int mid = left + (right - left) / 2;
if (array[left] > array[mid]) swap(array, left, mid);
if (array[left] > array[right]) swap(array, left, right);
if (array[mid] > array[right]) swap(array, mid, right); return mid; }
public static int[] partition(int[] array, int left, int right, int pivotIndex) { // complete this
function } } 1.2 Part 2: Selection Algorithms In the second part, you are going to implement the
Selection algorithm for finding the kth smallest number in an array. For the pivot, you are going
to use a random one. Your task is to implement the following: - Quick-Selection Algorithm (File:
Selection) Implement select(int [] array, int left, int right, int k). For pivot generation, call the
function generateRandomPivot(int [] array, int left, int right). Since partition returns two indexes,
you must the appropriate quick-select algorithm from the notes that utilizes both the indexes. -
Median of Medians Algorithm (File: MedianOfMedians) Implement select(int [] array, int left,
int right, int k). Since partition returns two indexes, you must modify the median of medians
quick-select algorithm from the notes to utilize both the indexes - this modification is simple
(essentially copy and paste the final recursive part) if you have completed the randomized quick-
select.
- Partition Algorithm (File: Partition) Implement partition(int [] array, int left, int right, int
pivotIndex) using the partition method in notes that returns two indexes lower PartitionIndex and
upper PartitionIndex. Your code must satisfy all the criteria of a partition - linear time and in-
place. Additionally, it must scan the array no more than once. Otherwise, no credits will be
given..
Help me with these multiple-choice questions. Please dont use chat .pdf
Help me with these multiple-choice questions. Please don't use chat GPT. 8) Which of the
following are properties of relations? A) Each attribute has the same name. B) No two rows in a
relation are identical. C) There are multivalued attributes in a relation. D) All columns are
numeric. 9) The entity integrity rule states that: A) no primary key attribute can be null. B)
referential integrity must be maintained across all entities. C) each entity must have a primary
key. D) a primary key must have only one attribute. 10) The states that no primary key attribute
may be null. A) referential integrity constraint B) entity integrity rule C) partial specialization
rule D) range domain rule
11) An Internal schema describes the A) high-level description of the whole database B) views
of different user groups C) physical storage structures of the database D) none of the above 12)
A data manipulation language is used for A) specifying how primary and candidate keys should
be created B) specifying database retrievals and updates C) specifying database conceptual
schemas D) specifying user views and storage structures E) none of the above 13) In
Client/Server architecture, the middle tier is used to A) run application programs and storing
business rules B) implement graphical user interfaces of a web application C) access data from
the databases D) none of the above.
More Related Content
Similar to I have been tasked to write a code for a Singly Linked list that inc.pdf
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Create a link list. Add some nodes to it, search and delete nodes from it.
Solution
#include
#include
using std::cout;
using std::endl;
/*
A linked list is a list constructed using pointers. It is not fixed in
size and could grow and shrink while the program is running.
A typical defination of list nodes contains at least two parts, both the
content or date of each element and the pointer to the next element,
which is shown in the figure below.
+---------+
| Data | -----> holds the data of this element in the list.
+---------+
| pointer | -----> is a pointer to the next element in the list.
+---------+
***Attention***:
The pointer holds the address of the next element, not the address of the
data in the next element, even though they are the same in value sometimes.
And It should be set to NULL while acting as the last node of the list.
Implementation of the single linked list:
+---------+ --->+---------+ --->+---------+
| Data | | | Data | | | Data |
+---------+ | +---------+ | +---------+
| pointer |----- | pointer |----- | pointer |
+---------+ +---------+ +---------+
*/
/* definition of the list node class */
class Node
{
friend class LinkedList;
private:
int _value; /* data, can be any data type, but use integer for easiness */
Node *_pNext; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: _pNext(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: _value(val), _pNext(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: _value(val), _pNext(next)
{}
/* Getters */
int getValue(void)
{ return _value; }
Node* getNext(void)
{ return _pNext; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *_pHead;
/* pointer of tail node */
Node *_pTail;
public:
/* Constructors with No Arguments */
LinkedList(void);
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to add a node at the head of a linked list */
void headInsert(int val);
/* Function to add a node in the middle of a linked list */
void insertAfter(Node* afterMe, int val);
/* Function to append a node to the end of a linked list */
void tailAppend(int val);
/* Function to get the node in the specific position */
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
LinkedList::LinkedList()
{
/* Initialize the head and tail node */
_pHead = _pTail = NULL;
}
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
_pHead = new Node(val);
_pTail = _pHead;
}
LinkedList::~LinkedList()
{
/*
* Leave it empty temporarily.
* It will be described in detail in the example \"How to delete a linkedlist\".
*/
}
void LinkedList::headInsert(int val)
{
/* The list is empty? */
if (_pHead == NULL) {
/* the same to create a new list with a given value */
_pTail = _pHead = new Node(val);
.
Describe an algorithm for concatenating two singly linked lists L and.pdf
Dataset:
https://docs.google.com/spreadsheets/d/1NxuGt4LJ3ofi2PaWLWpAl90JmfqMKcGV/edit?usp=sharing&ouid=111109979069524025260&rtpof=true&sd=true
Q1) What is the average tenure of those customers of the telecom operator who are still with the
company as a customer and also those who have stopped using the services provided by the
company? (1 mark)
Here, churn = 'No' means that the customer is currently associated with the company, and churn
= 'Yes' means that the customer has stopped using the services provided by the company.
Q2)What is the monthly average revenue generated by the customers who are with the company
and also those who have left? (1 mark)
Q3) Find the percentage of churn and non-churn customers for each category of the following
services: (4 marks)
-MultipleLines
-PaperlessBilling
-OnlineSecurity
-OnlineBackup
-DeviceProtection
-TechSupport
-StreamingTV
-StreamingMovies.
please help me in C++Objective Create a singly linked list of num.pdf
please help me in C++
Objective: Create a singly linked list of numbers based upon user input.
Program logic: Ask for a number, add that number to the front of the list, print the list. Repeat
until they enter -1 for the number. .
Sample Input: 10, 15, 5, 2, 4, -1 Output: 4, 2, 5, 15, 10
Solution
#include
#include
using namespace std;
// It contains the value and the pointer to the next element in the list.
struct element {
int value;
struct element *next;
};
struct element *head = NULL;
// The list is stored in the object of this class.
class linkedlist {
public:
// To display list, we first see if head is NULL,
// If head is NULL it means the list is empty.
// Then we traverse along the list and display each item, until the next pointer is NULL.
void display() {
if(head == NULL){
cout << \"The list is empty\ \";
} else {
struct element *temp;
temp = head;
while(temp != NULL){
cout << temp->value << \" \" ;
temp = temp->next;
}
cout << \"\ \";
}
}
// To add an element to the list,create a newElement and store the value.
// If head is NULL, add the newElement to the head.
// To add an element at the starting of the list.
// The next pointer of the newElement must point to the old head.
// The new head must be pointed to the newElement.
void add(int a){
struct element *newElement;
newElement = (struct element *)malloc(sizeof(struct element));
newElement->value = a;
newElement->next = NULL;
if(head == NULL) {
head = newElement;
} else {
newElement->next = head;
head = newElement;
}
}
};
int main()
{
// Create an object of the class linkedlist.
linkedlist l = linkedlist();
int a;
do {
cout << \"Enter a number : \";
cin >> a;
if(a!=-1) { // If the number is -1 do not add it to the list.
l.add(a); // Add the number to the list.
}
l.display(); // Display the list.
} while(a!=-1); // Keep asking for a number until -1 is pressed.
return 0;
}.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header using C?
Solution
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
// Update current
current = next;
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* A utility function to insert a node at the beginning of linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = new node;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf(\"Linked List before sorting \ \");
printList(a);
insertionSort(&a);
printf(\"\ Linked List after sorting \ \");
printList(a);
return 0;
}
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct.
C Homework Help
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
C++ Please write the whole code that is needed for this assignment- wr.docx
Brianca plans to save $5,000, $1,000, and $42,000 a year over the next three years, respectively. How much would you need to deposit in one lump sum today to have the same amount as Brianca three years from now if you both earn 10.9 percent, compounded annually? $36,115 $35,192 $43,282 $41,635 $35,372
.
Using the provided table interface table.h and the sample linked lis.pdf
Using the provided table interface table.h and the sample linked list code linkedList.c, complete
an implementation of the Table ADT. Make sure that you apply the concepts of design by
contract (DbC) to your implementation.
Once you have fully implemented the table, create a main.c file that implements a testing
framework for your table.
Your table implementation must ensure that values inserted are unique, and internally sorted
within a linked list.
table.h
linkedList.c
Solution
khsdg
#include
#include
typedef enum BOOL { false, true } bool;
// Linked list node definition
typedef struct Node node;
struct Node
{
int number;
node *next;
};
static node *top = NULL;
// used to track where we are for the list traversal methods
static node *traverseNode = NULL;
// \"destroy\" will deallocate all nodes in a linked list object
// and will set \"top\" to NULL.
void destroy()
{
node *curr = top;
node *temp = NULL;
while ( curr != NULL )
{
// flip order to see it blow up...
temp = curr;
curr = curr->next;
free( temp );
}
top = NULL;
}
// \"build\" will create an ordered linked list consisting
// of the first \"size\" even integers.
void build( int size )
{
node *newNode = NULL;
int i = 0;
// make sure we don\'t have a list yet
destroy();
for ( i=size ; i>0 ; i-- )
{
newNode = malloc( sizeof( node ) );
newNode->number = i*2;
newNode->next = top;
top = newNode;
}
}
// starts a list traversal by getting the data at top.
// returns false if top == NULL.
bool firstNode( int *item )
{
bool result = false;
if ( top )
{
*item = top->number;
traverseNode = top->next;
result = true;
}
return result;
}
// gets the data at the current traversal node and increments the traversal.
// returns false if we\'re at the end of the list.
bool nextNode( int *item )
{
bool result = false;
if ( traverseNode )
{
*item = traverseNode->number;
traverseNode = traverseNode->next;
result = true;
}
return result;
}
// \"print\" will output an object\'s entire linked list
// to the standard output device -- one \"number\" per line.
void print()
{
int value;
if ( firstNode( &value ) )
{
do
{
printf( \"%d\ \", value );
} while ( nextNode( &value ) );
}
}
int main( int argc, char *argv[] )
{
build( 10 );
print();
destroy();
build( 5 );
build( 20 );
print();
destroy();
return 0;
}.
C code on linked list #include stdio.h #include stdlib.h.pdf
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps
Solution
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps.
To complete the task, you need to fill in the missing code. I’ve inc.pdf
To complete the task, you need to fill in the missing code. I’ve included code to create an
Iterator. An Iterator is an object that iterates over another object – in this case, a circular linked
list. You can use the .next() method to advance the Iterator to the next item (the first time you
call it, the iterator will travel to node at index 0). Using iterator’s .remove() removes the node the
iterator is currently at. Say that we had a CircularLinkedList that looked like this: A ==> B ==>
C ==> D ==> E ==> Calling .next() three times will advance the iterator to index 2. Calling
.remove() once will remove the node at index 2. A ==> B ==> D ==> E ==> Calling .remove()
once more will remove the node now at index 2. A ==> B ==> E ==> The Iterator methods
handle wrapping around the CircularLinkedList. Be sure to create the iterator using l.iterator()
and after you’ve added all the nodes to the list, where l is your CircularLinkedList
Solution
import java.util.Iterator;
class CircularLinkedList implements Iterable {
// Your variables
// You can include a reference to a tail if you want
Node head;
int size; // BE SURE TO KEEP TRACK OF THE SIZE
// implement this constructor
public CircularLinkedList() {
head=null;
}
// writing helper functions for add and remove, like the book did can help
// but remember, the last element\'s next node will be the head!
// attach a node to the end of the list
// Be sure to handle the adding to an empty list
// always returns true
public boolean add(E e) {
Node newNode=new Node(e);
if(size==0){
head=newNode;
}
else{
Node last=getNode(size-1);
last.next=newNode;
}
newNode.next=head; //last element node is set to head
size++;
return true;
}
// need to handle
// out of bounds
// empty list
// adding to front
// adding to middle
// adding to \"end\"
// REMEMBER TO INCREMENT THE SIZE
public boolean add(int index, E e){
if(index>size) return false;
Node tmp=new Node(e);
if(index==0){
tmp.next=head;
Node last=getNode(size-1);
head=tmp;
last.next=head;
}
else {
Node curr=getNode(index-1);
tmp.next=curr.next;
curr.next=tmp;
}
size++;
return true;
}
// I highly recommend using this helper method
// Return Node found at the specified index
// be sure to handle out of bounds cases
private Node getNode(int index ) {
Node prev=head;
for(int i=0;isize) {
e=null;
}
else if(index==0){
e = head.getElement();
Node last=getNode(size-1);
head=head.next;
last.next=head;
size--;
}
else{
Node prev=getNode(index-1);
Node curr=getNode(index);
e=curr.getElement();
prev.next=curr.next;
size--;
}
return e;
}
// Turns your list into a string
// Useful for debugging
public String toString(){
Node current = head;
StringBuilder result = new StringBuilder();
if(size == 0){
return \"\";
}
if(size == 1) {
return head.getElement().toString();
}
else{
do{
result.append(current.getElement());
result.append(\" ==> \");
current = current.next;
} while(current != head);
}
return result.toString();
}
public Iterator iterator() {
return new ListIterator();
}
/.
package linkedLists- import java-util-Iterator- --- A class representi.pdf
package linkedLists;
import java.util.Iterator;
/** A class representing a singly linked list from scratch. Fill in code.
*
* Note: you may NOT use any of Java's built in classes that store a collection of elements
* such as ArrayList, LinkedList (Java's built in), HashMap, HashTree, HashSet etc. */
public class LinkedList {
private Node head, tail;
/** Constructor */
public LinkedList() {
head = null;
tail = null;
}
/**
* Creates a new node with the given element and adds it to the back of the
* list. No need to change this method.
*/
public void append(int elem) {
Node newNode = new Node(elem);
if (tail != null) {
tail.setNext(newNode);
tail = newNode;
} else {
head = tail = newNode;
}
}
/** Prints all the nodes in the link list. No need to change this method. */
public void printNodes() {
Node current = head;
while (current != null) {
System.out.print(current.elem() + " ");
current = current.next();
}
}
/**
* Return a sublist of this list where the values of elements are in the range
* from value1 to value2, inclusive.
* Your method should not destroy the original list and its nodes should *not* reference
* the nodes in the input list (you need to create new nodes instead).
* Example:
* If the list is 6->40->3->17->1 and value1 is 3 and value2 is 20,
* then the result should be 6->3->17.
* @param value1 value 1
* @param value2 value 2
* @return a sublist of this list where the values of elements are in the range
* * from value1 to value2, inclusive.
*/
public LinkedList sublist(int value1, int value2) {
LinkedList res = new LinkedList();
// FILL IN CODE
return res;
}
/**
* Insert a new node with the given element into the sorted linked list.
* Insert it in the right place based on the value in the node. Assume the
* list is sorted by the elem, from smallest to largest. The
* list should remain sorted after this insert operation.
* Example: If this list is 5->10->18 and we insert 15, then after that the operation,
* the list will become 5->10->15->18.
*/
public void insertInSortedList(int elem) {
// insert a node into the sorted list
// FILL IN CODE
}
/**
* Assume this linked list is sorted in ascending order, and we do not know the
* * number of elements.
* * Return a LinkedList that contains k largest elements in the list.
* * Use slow & fast pointers to find the k-th node from the end (required). Note: This method
* * should be linear and should not count the number of nodes. Do NOT use reverse().
* @param k index from the end
* @return linked list that contains k largest elements (k elements from the end of the list)
*/
public LinkedList getKLargest(int k) {
LinkedList result = new LinkedList();
// FILL IN CODE
return result;
}
/**
* Merge two sorted linked lists into a single sorted linked list.
*
* @param list1
* @param list2
* Your method should not destroy the original list and its nodes should *not* reference
* the nodes in the input list (you need to create new nodes instead).
*/
public static LinkedList mergeSortedLists(LinkedLis.
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
1#include stdio.h#include stdlib.h#include assert.h .pdf
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
2
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int count = 0; /* the index of the node we\'re currently
looking at */
while (current != NULL)
{
if (count == index)
return(current->data);
count++;
current = current->next;
}
/* if we get to this line, the caller was asking
for a non-existent element so we assert fail */
assert(0);
}
/* Drier program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Use push() to construct below list
1->12->1->4->1 */
push(&head, 1);
push(&head, 4);
push(&head, 1);
push(&head, 12);
push(&head, 1);
/* Check the count function */
printf(\"Element at index 3 is %d\", GetNth(head, 3));
getchar();
}
Solution
1
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node*.
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node.h. Access Node.h by clicking
on the orange arrow next to main.cpp at the top of the coding window. The Node class has three
member variables: a double data value, a pointer to the next node, and a pointer to the previous
node. Each member variable is protected. So code outside of the class must use the provided
getter and setter member functions to get or set a member variable. Node.h is read only, since no
changes are required. Step 2: Implement the Insert() member function A class for a sorted,
doubly-linked list is declared in SortedNumberList.h. Implement the SortedNumberList class's
Insert() member function. The function must create a new node with the parameter value, then
insert the node into the proper sorted position in the linked list. Ex: Suppose a
SortedNumberList's current list is 23 47.25 86, then Insert(33.5) is called. A new node with data
value 33.5 is created and inserted between 23 and 47.25, thus preserving the list's sorted order
and yielding: 23 35.5 47.25 86 Step 3: Test in develop mode Code in main() takes a space-
separated list of numbers and inserts each into a SortedNumberList. The list is displayed after
each insertion. Ex: If input is 77 15 -42 63.5 then output is: List after inserting 77: 77 List after
inserting 15: 15 77 List after inserting -42: -42 15 77 List after inserting 63.5: -42 15 63.5 77 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove() member function. The
function takes a parameter for the number to be removed from the list. If the number does not
exist in the list, the list is not changed and false is returned. Otherwise, the first instance of the
number is removed from the list and true is returned. Uncomment the commented-out part in
main() that reads a second input line and removes numbers from the list. Test in develop mode to
ensure that insertion and removal both work properly, then submit code for grading. Ex: If input
is 84 72 19 61 19 84 then output is: List after inserting 84: 84 List after inserting 72: 72 84 List
after inserting 19: 19 72 84 List after inserting 61: 19 61 72 84 List after removing 19: 61 72 84
List after removing 84: 61 72
main.cpp
#include
#include
#include
#include "Node.h"
#include "SortedNumberList.h"
using namespace std; void PrintList(SortedNumberList& list); vector SpaceSplit(string source);
int main(int argc, char *argv[]) { // Read the line of input numbers string inputLine; getline(cin,
inputLine); // Split on space character vector terms = SpaceSplit(inputLine); // Insert each value
and show the sorted list's contents after each insertion SortedNumberList list; for (auto term :
terms) { double number = stod(term); cout << "List after inserting " << number << ": " << endl;
list.Insert(number); PrintList(list); } /* // Read the input line with numbers to remove getline(cin,
inputLi.
C++Write a method Node Nodereverse() which reverses a list..pdf
C++
Write a method Node *Node::reverse() which reverses a list.
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf(\"Given linked list\ \");
printList(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
getchar();
}.
Similar to I have been tasked to write a code for a Singly Linked list that inc.pdf (20)
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Describe an algorithm for concatenating two singly linked lists L and.pdf
Describe an algorithm for concatenating two singly linked lists L and.pdf
please help me in C++Objective Create a singly linked list of num.pdf
please help me in C++Objective Create a singly linked list of num.pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header usin.pdf
C++ Please write the whole code that is needed for this assignment- wr.docx
C++ Please write the whole code that is needed for this assignment- wr.docx
Using the provided table interface table.h and the sample linked lis.pdf
Using the provided table interface table.h and the sample linked lis.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
To complete the task, you need to fill in the missing code. I’ve inc.pdf
To complete the task, you need to fill in the missing code. I’ve inc.pdf
package linkedLists- import java-util-Iterator- --- A class representi.pdf
package linkedLists- import java-util-Iterator- --- A class representi.pdf
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++I am really new to C++, so links are really .pdf
1#include stdio.h#include stdlib.h#include assert.h .pdf
1#include stdio.h#include stdlib.h#include assert.h .pdf
Program to insert in a sorted list #includestdio.h#include.pdf
Program to insert in a sorted list #includestdio.h#include.pdf
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
Inspect the class declaration for a doubly-linked list node in Node-h-.pdf
C++Write a method Node Nodereverse() which reverses a list..pdf
C++Write a method Node Nodereverse() which reverses a list..pdf
More from arkmuzikllc
Here is selection filepublic class Selection { public static in.pdf
Here is selection file:
public class Selection { public static int select(int[] array, int n, int k)
{ return select(array, 0, n - 1, k); }
private static int select(int[] array, int left, int right, int k) { // complete this function } }
here is MedianOfMedians file:
public class MedianOfMedians { private static void insertionSort(int[] arr, int left, int right)
{ for (int i = left + 1; i <= right; i++) {
int j = i, temp = arr[j];
while (j > left && temp < arr[j - 1])
{ arr[j] = arr[j - 1];
j--; }
arr[j] = temp;
}
}
public static int select(int[] array, int n, int k) { return select(array, 0, n - 1, k); }
private static int select(int[] array, int left, int right, int k) { // complete this function
} }
here is Partition file needed to code this correctly
public class Partition {
static Random rand = new Random(System.currentTimeMillis());
protected static void swap(int[] array, int x, int y) { int temp = array[x];
array[x] = array[y];
array[y] = temp; }
public static int generateRandomPivot(int[] array, int left, int right)
{ return left + rand.nextInt(right - left + 1); }
public static int generateMedianOf3Pivot(int[] array, int left, int right) {
int mid = left + (right - left) / 2;
if (array[left] > array[mid]) swap(array, left, mid);
if (array[left] > array[right]) swap(array, left, right);
if (array[mid] > array[right]) swap(array, mid, right); return mid; }
public static int[] partition(int[] array, int left, int right, int pivotIndex) { // complete this
function } } 1.2 Part 2: Selection Algorithms In the second part, you are going to implement the
Selection algorithm for finding the kth smallest number in an array. For the pivot, you are going
to use a random one. Your task is to implement the following: - Quick-Selection Algorithm (File:
Selection) Implement select(int [] array, int left, int right, int k). For pivot generation, call the
function generateRandomPivot(int [] array, int left, int right). Since partition returns two indexes,
you must the appropriate quick-select algorithm from the notes that utilizes both the indexes. -
Median of Medians Algorithm (File: MedianOfMedians) Implement select(int [] array, int left,
int right, int k). Since partition returns two indexes, you must modify the median of medians
quick-select algorithm from the notes to utilize both the indexes - this modification is simple
(essentially copy and paste the final recursive part) if you have completed the randomized quick-
select.
- Partition Algorithm (File: Partition) Implement partition(int [] array, int left, int right, int
pivotIndex) using the partition method in notes that returns two indexes lower PartitionIndex and
upper PartitionIndex. Your code must satisfy all the criteria of a partition - linear time and in-
place. Additionally, it must scan the array no more than once. Otherwise, no credits will be
given..
Help me with these multiple-choice questions. Please dont use chat .pdf
Help me with these multiple-choice questions. Please don't use chat GPT. 8) Which of the
following are properties of relations? A) Each attribute has the same name. B) No two rows in a
relation are identical. C) There are multivalued attributes in a relation. D) All columns are
numeric. 9) The entity integrity rule states that: A) no primary key attribute can be null. B)
referential integrity must be maintained across all entities. C) each entity must have a primary
key. D) a primary key must have only one attribute. 10) The states that no primary key attribute
may be null. A) referential integrity constraint B) entity integrity rule C) partial specialization
rule D) range domain rule
11) An Internal schema describes the A) high-level description of the whole database B) views
of different user groups C) physical storage structures of the database D) none of the above 12)
A data manipulation language is used for A) specifying how primary and candidate keys should
be created B) specifying database retrievals and updates C) specifying database conceptual
schemas D) specifying user views and storage structures E) none of the above 13) In
Client/Server architecture, the middle tier is used to A) run application programs and storing
business rules B) implement graphical user interfaces of a web application C) access data from
the databases D) none of the above.
Hello I am stuck in my code I know is everything is goid but I think.pdf
Hello I am stuck in my code I know is everything is goid but I think I am doing something wrong
with the numbers. Help please. It's written in Coral Coding language.
Here's the question:
On a piano, a key has a frequency, say f0. Each higher key (black or white) has a frequency of
f0 * rn, where n is the distance (number of keys) from that key, and r is 2(1.0/12.0). Given an
initial key frequency, output that frequency and the next 4 higher key frequencies.
Output all frequencies with five digits after the decimal point, which can be achieved as follows:
Put frequency to output with 5 decimal places
Ex: If the input is:
440.0
(which is the A key near the middle of a piano keyboard), the output is:
440.00000 466.16376 493.88330 523.25113 554.36526
Note: Use one statement to compute r = 2(1.0/12.0) using the RaiseToPower() function. Then
use that r in subsequent statements that use the formula fn = f0 * rn with n being 1, 2, 3, and
finally 4.
Here's my code:
float r
float f0
float f1
float f2
float f3
float f4
f0 = 440.0
r = RaiseToPower(2, 1.0 / 12.0)
f1 = f0 * r
f2 = f1 * r
f3 = f2 * r
f4 = f3 * r
Put f0 to output with 5 decimal places
Put " " to output
Put f1 to output with 5 decimal places
Put " " to output
Put f2 to output with 5 decimal places
Put " " to output
Put f3 to output with 5 decimal places
Put " " to output
Put f4 to output with 5 decimal places
I know if I put 44.0 in input I get the answer my only problem is for example if I put 22. 0 I get
440.00000 466.16376 493.88330 523.25113 554.36526 but the expected output is 220.00000
233.08188 246.94165 261.62557 277.18263..
HeadWallRam Inc. has expanded its reach globally and needs to re-lay.pdf
HeadWallRam Inc. has expanded its reach globally and needs to re-layout it is IP architecture.
The executive team has hired you as a consultant to propose a greenfield network design.
Follow all the same guidlines, restrictions and provisions from Lab Report writing. Include the
following information:
Full IP documentation (not just an IP Grid).
Network Diagram from Draw.io
VyOS route configuration (i.e the "set protocols static" commands) that would be used to
impliment all route entries in all routers. ONLY include the route commands
ISP provides a single DHCP public IP address
Plan for ONE connection to the internet connected to the US site
Interior IP ranges that the company uses (172.18.128.0/17)
Plan a STAR topology for the network core between sites
Plan for networks needed for connections between sites
Plan for all pieces of equipment to be located at one of the Head-Wall-Ram sites (No routers in
space)
Think about WHY you were called in and plan for that too!
US site has five subdivisions: Sales (40 hosts), Technical (600 hosts), Support (300 hosts), Local
Management (150 hosts), Global Management (300 hosts)
China site has six subdivisions: Manufacturing (800 hosts), Sales (20 hosts), Technical (1200
hosts), Support (50 hosts), Legal (40 hosts), R&D (200 hosts)
Europe site has seven subdivisions: Manufacturing (80 hosts), Sales (20 hosts), Technical (400
hosts), Support (40 hosts), Legal (30 hosts), R&D (200 hosts), Management (10 hosts).
HINT For i = 1 , . . . ,n, let S[i] be the max sum ending with A[i].pdf
HINT: For i = 1 , . . . ,n, let S[i] be the max sum ending with A[i] while allowing size-1 gaps.
Derive a recurrence for S[i] Problem 4. Max sum with 1-gaps Given a length- n array of integers
A[1n], we would like to find maximum sum which could be obtained by adding elements in a
subsequence of A if we are allowed to start anywhere in A but once we start, we can either take
the element after the previously selected element or the one after, i.e, gaps of length at most 1 are
allowed in the subsequence. More formally, given A find the maximum S such that there is an
integer 0mn and indices 1i1<.
Hi, I need some assistance with this UML use case diagram. I manage .pdf
Hi, I need some assistance with this UML use case diagram. I manage to brainstorm on what
needs to be in diagram, but I'm unsure if what I started off with is correct. Below is an image of
what I have so far using the template:
My notes:
Actors:
Customer (Student)
- Represents the individuals who are taking driving lessons and using the DriverPass system
for online training, reservations, and interactions.
Administrator (IT Officer)
- Represents the IT officer, Ian, who has administrative privileges to manage and maintain the
system.
Secretary
- Represents the secretary responsible for managing appointments and customer interactions.
DMV (External System) - Is this a stick figure ?
- Represents the external DMV system, which provides updates and notifications related to
driving rules and policies.
Use Cases:
Login
- Allows customers, administrators, and the secretary to log into the system with their
respective credentials.
- Actors: Customer, Administrator, Secretary
Access Training Resources
- Enables customers to access online driver training resources and practice tests.
- Actors: Customer
Schedule Driving Lesson
- Allows customers to schedule on-the-go driving lessons, specifying date, time, and driver
preferences.
- Actors: Customer
Manage Appointments
- Allows customers to view, modify, or cancel their scheduled driving lesson appointments.
- Actors: Customer
Remote System Management
- Enables the administrator (IT Officer, Ian) to remotely access the system for maintenance,
updates, and adjustments.
- Actors: Administrator
Track User Activity
- Tracks user interactions and activities within the system, including reservations, changes, and
cancellations.
- Actors: Administrator
Connect to DMV - How do I show the connection between DMV and Administrator?
- Establishes a connection to the DMV external system to receive updates, notifications, and
compliance information.
- Actors: Administrator
User Registration
- Allows new customers to register on the system by providing their personal information.
- Actors: Customer
Password Reset
- Allows users (customers) to reset their password in case they forget it, using their registered
email address.
- Actors: Customer
System Reporting
- Provides access to system reports, including activity logs, reservation history, and user
statistics.
- Actors: Administrator
Do I need to show the relationships?.
Give an NFA that recognizes the language (10 + 110 + 101) and then .pdf
Give an NFA that recognizes the language (10 + 110 + 101)* and then convert it to an equivalent
DFA
A solution I had in mind was making an NFA for each subtopic, and what I had was essentially:
For 10: q0 on a 1 moves to q1, which epsilon transitions to q2, and q2 transitions to accepting
state 3 on a 1
For 110: q0 on a 1 moves to q1, which epsilon transitions to 2, and q2 transitions to q4 on input
1, q4 goes to q5 on epsilon, and q5 goes to q6 on input 0
For 101: q0 goes to q1 on 1, q1 to q2 on epsilon, q2 to q3 on input 0, q4 to q5 on input epsilon,
q5 to q6 on input 1.
How would I go about linking these seperate NFA's together? My instinct was that they should
just flow into one another, maybe with just epsilon transitions?.
IN JAVA BJP5 Exercise 6.19 leetSpeak LanguageType Java file pr.pdf
IN JAVA
BJP5 Exercise 6.19: leetSpeak Language/Type: Java file processing Scanner Author: Marty
Stepp (on 2019/09/19) Write a method leetSpeak that accepts two parameters: a Scanner
representing an input file, and a PrintStream representing an output file. Your method should
convert the input file's text to "leet speak" (aka 1337 speak), an internet dialect where various
letters are replaced by other letters/numbers. Output the leet version of the text to the given
output file. Preserve the original line breaks from the input. Also wrap each word of input in
parentheses. Perform the following replacements: For example, if the input file lincoln.txt
contains the following text: four score and seven years ago our fathers brought forth on this
continent a new nation And your method is called in the following way: Scanner input = new
Scanner(new File("lincoln.txt")); PrintStream output = new PrintStream(new File("leet.txt"));
leetSpeak(input, output); Then after the call, the output file leet.txt should contain the following
text: (four) (scor3) (4nd) (s3v3n)(y34rz)(4g) (Our) (f47h3rz) (brough7) (for7h) (0n) (7hiz)
(c0n7in3n7) (4) (n3w) (n47ion) You may assume that each token from the input file is separated
by exactly one space. Hint: You may want to use the String object's replace method, which is
used as follows: String str = "mississippi"; str = str.replace("s", "*"); // str = "mi**i**ippi" Type
your solution here:.
Goal Create a hypothetical threat assessment based on vulnerabilities.pdf
Goal: Create a hypothetical threat assessment based on vulnerabilities you expect to find when
you perform your actual scans against the clients network. Procedure: Assume the scenarios
below are what you are most likely to encounter when you begin your actual work. Deliverable:
Provide a spreadsheet or document showing the following items. Make sure you factor in the
appropriate context. For example, if you think you might be able to penetrate the APOLLO
system, evaluate those risks according to that systems sensitivity and criticality. Description of
the vulnerability Operating systems/versions affected Risks of attempting to exploit (e.g., might
crash the host or lock out an account) Risk (what could you or a threat actor do upon successful
exploitation)? Identify as many attack vectors as you can. Examples: launch an attack on
internal systems, obtain password hashes, crack passwords, access other systems, move laterally,
and so on). Identify potential blocking mechanisms such as AV software or IDS/IPS, and how
you might try to bypass them. Document how you plan on cracking passwords. This will depend
on the source systems course, but you should be ready for whatever you run into. Include online
tools as well. Remediation action CVSS score Scenario 5: Web server is exposing sensitive
data Scenario 6: Web application has broken access control Scenario 7: Oracle WebLogic Server
vulnerable to CVE-2020-14882 Scenario 8: Misconfigured cloud storage (AWS security group
misconfiguration, lack of access restrictions) Scenario 9: Microsoft Exchange Server vulnerable
to CVE-2021-26855.
import React, { useEffect } from react;import { BrowserRouter as.pdf
import React, { useEffect } from 'react';
import { BrowserRouter as Router, Route, Routes, Link, useLocation, Outlet, Navigate } from
'react-router-dom'; // Added useLocation
import { App } from './App';
import Cookies from 'js-cookie';
import LoginButton from './authentication/LoginButton'; // Import the LoginButton component
import { useAuth0 } from '@auth0/auth0-react';
const isAuthenticated = true;
export default function RouterPage() {
useEffect(() => {
// Fetch the userId from the Flask backend
fetch('http://localhost:5000/callback', {
method: 'GET',
credentials: 'include', // Important for sending cookies across origins
})
.then(response => response.json())
.then(data => {
// Assuming the userId is returned in the data object
const userId = data.userId;
Cookies.set('userId', userId, { expires: 7 });
})
.catch((error) => console.error('Error:', error));
}, []);
// These could be different components for your different pages
const Title = ({ isAuthenticated }) => (
TasktasticTest Environment
{isAuthenticated ? (
Logout
) : (
)}
);
return (.
im solving tha m-puzzel sliding tail problem where m = n^2 - 1 I ha.pdf
i'm solving tha m-puzzel sliding tail problem where m = n^2 - 1 I have made this code using
python using A* with taking into considration the Misplaced, Euclidean, and Manhattan
heuristics to the problem.
however i want it to work for 3*3 and 4*4 and 5*5 and 6*6 matrix it did worked for 3*3 but not
with the rest i couldnot run it ( you can just change the value of n in the code) is the problem
form the code or my device code not run it dou to time and memory considretion
import heapq
import random
class PuzzleNode:
def __init__(self, state, g_cost, heuristic, parent=None):
self.state = state # 2D array representing the puzzle state
self.g_cost = g_cost # cost to reach this state from the initial state
self.heuristic = heuristic # heuristic value
self.parent = parent # reference to the parent node
def f_cost(self):
# The total cost is the sum of g_cost and heuristic value
return self.g_cost + self.heuristic
def __lt__(self, other):
# Comparing nodes based on f_cost and depth for priority queue
if self.f_cost() == other.f_cost():
return self.g_cost > other.g_cost # For tie-breaking, prefer nodes with lower depth
return self.f_cost() < other.f_cost()
def generate_successors(node):
# Generate successor nodes by sliding tiles in four directions
successors = []
empty_x, empty_y = find_empty_space(node.state)
for dx, dy in [(0, 1), (0, -1), (1, 0), (-1, 0)]:
new_x, new_y = empty_x + dx, empty_y + dy
if 0 <= new_x < len(node.state) and 0 <= new_y < len(node.state[0]):
new_state = [row[:] for row in node.state]
new_state[new_x][new_y], new_state[empty_x][empty_y] =
new_state[empty_x][empty_y], new_state[new_x][new_y]
successors.append(PuzzleNode(new_state, node.g_cost + 1, 0)) # The heuristic will be
calculated separately
return successors
def misplaced_tiles_heuristic(current_state, goal_state):
# Calculate the Misplaced Tiles heuristic value
h = 0
for i in range(len(current_state)):
for j in range(len(current_state[0])):
if current_state[i][j] != goal_state[i][j] and current_state[i][j] != 0:
h += 1
return h
def manhattan_distance_heuristic(current_state, goal_state):
# Calculate the Manhattan Distance heuristic value
h = 0
for i in range(len(current_state)):
for j in range(len(current_state[0])):
if current_state[i][j] != 0:
x, y = find_tile_position(current_state[i][j], goal_state)
h += abs(i - x) + abs(j - y)
return h
def euclidean_distance_heuristic(current_state, goal_state):
# Calculate the Euclidean Distance heuristic value
h = 0
for i in range(len(current_state)):
for j in range(len(current_state[0])):
if current_state[i][j] != 0:
x, y = find_tile_position(current_state[i][j], goal_state)
h += ((i - x) ** 2 + (j - y) ** 2) ** 0.5
return h
def find_empty_space(state):
# Helper function to find the position of the empty space (0) in the state
for i in range(len(state)):
for j in range(len(state[0])):
if state[i][j] == 0:
return i, j
def find_tile_position(tile, state):
# Helper function to find the position of a tile in the state
for i in rang.
Im creating a skip list program for my Algorithms and Advanced Data.pdf
I'm creating a skip list program for my Algorithms and Advanced Data Structure class. I was
tasked with implementing a find & add method for the skiplist. Here is my program, I'm running
into a segmentation fault when I add my second value into the skiplist. My first issue that I fixed
was that I wasn't checking the first node in the list to see if it was nullptr, but that was not my
only issue apparently.
Add Method:
void SkipList::add(const ElemType &el) {
// Create a new node with the given element
Node *newNode = new Node(el);
// Get the height of the new node
int newHeight = newNode->nodeHeight;
// If the height of the new node is greater than the current list height,
// update the list height.
if (newHeight > listHeight) {
listHeight = newHeight;
}
// Array to keep track of nodes to update
Node *update[MAX_NUM_LISTS];
// Start from the top level
Node *current = head[listHeight - 1]; // Initialize current correctly
// If the list is empty, assign the first node to head
if (head[0] == nullptr) {
head[0] = newNode;
} else {
// Loop to traverse through list
for (int i = listHeight - 1; i >= 0; i--) {
// Move forward in the current level
while (current->next[i] != nullptr && current->next[i]->elem < el) {
current = current->next[i];
}
// Store the node before which the new node should be inserted
update[i] = current;
}
// Insert the new node at each level
for (int i = 0; i < newHeight; i++) {
newNode->next[i] = update[i]->next[i];
update[i]->next[i] = newNode;
}
}
}
Find Method:
bool SkipList::find(const ElemType &el) const {
// Start from the top level
Node *current = head[listHeight - 1];
bool found = false;
// Iterate through the levels of the skip list
for (int i = listHeight - 1; i >= 0; i--) {
// Move forward in the current level until reaching the end or finding a larger element
while (current->next[i] != nullptr && current->next[i]->elem < el) {
current = current->next[i];
}
// Check if the current node's next node contains the target element
if (current->next[i] != nullptr && current->next[i]->elem == el) {
found = true; // Element found
}
}
return found; // Element not found in the skip list
}
Main:
int main()
{
ElemType inputs[] = {5, 7, 8, 10, 12, 17, 19, 22, 28, 31, 33, 35, 42, 51, 59};
SkipList list1;
cout << "For list1 (same as in the slide 10 of Skip List1 Lecture Note):\n";
// for (int i=0; i(std::size(inputs)); i++)
{
cout << "add " << inputs[i] << endl;
list1.add(inputs[i]);
cout << "list1:\n"
<< list1 << endl;
}
if (list1.find(33))
cout << "33 is found!\n";
else
cout << "33 is not found!!!!\n";
if (list1.find(70))
cout << "70 is found!\n";
else
cout << "70 is not found!!!!\n";
if (list1.find(10))
cout << "10 is found!\n";
else
cout << "10 is not found!!!!\n";
cout << "\n===================================\n";
cout << "For list2:\n";
ElemType inputs2[] = {19, 8, 17, 59, 12, 7, 5, 22, 28, 35, 33, 31, 42, 51, 10};
SkipList list2;
for (int i = 0; i < static_cast(std::size(inputs2)); i++)
{
cout << "add " << inputs2[i] << endl.
if any additional information is required let me know Work through t.pdf
if any additional information is required let me know Work through the tasks sequentially
(implement and test). Only move on to a task when you are positive that the previous one has
been completed correctly, Remember that the names of classes and methods must exactly match
those in this specification (FUNCTION NAMES, PARAMETER TYPES, RETURNS, PRE
AND POST CONDTTIONS MUST MATCH EXACTLY. Remember, you must thoroughly
document your codellt Task 1: Modify the Character class
operator!= epost : displays Character data in the form: "[name_] is a Level [level]] [race_].
InVitality: [vitality_] InMax Armor: [armor_] In [They are / They are not] an enemy. In" +1
isplay
the tally is zero. Nore: no pre-processing of the input string necessary, only uppercase input will
match. / tatlyRace epost: Outputs a report of the characters currently in the tavern in the form:
level is: [x] In [x] are enemies. \n Note that the average level should be rounded to the
NEAREST integer, and the enemy percentage should be rounded to 2 decimal places. Exanple
output: Humans: 3 Elves: 5 Dwarves: 8 Lizards: 6 Undead: The average level 1s: 7 46.67% are
enemies. *1
ereturn: The average level of all the characters in the Tavern epost: Computes the average level
of the Tavern rounded to the NEAREST integer. 1 calculateAvgLevel ereturn: The integer
enemy count of the Tavern getEnemycount ereturn: The percentage (double) of all the enemy
characters in the Tavern epost: Conputes the eneny percentage of the Tavern rounded up to 2
decinal places. **/ calculateEnemyPercentage eparam: A const reference to a string representing
a character Race with value in ["NONE", "HUMAN", "ELF", "DWARF", "LIZARD",
"UNDEAD"] ereturn: An integer tally of the number of characters in the Tavern of the given
race. If the argument string does not match one of the expected race values, the tally is zero.
NOTE: no pre-processing of the input string necessary. only uppercase input will match.
Task 3: Implement the Tavern class as a subclass of ArrayBag The Tavern is subclass of
ArrayBag that stores Character objects Data Types The Tavern class must have the following
pritate member tariables: - An integer sum of the levels of all the characters currently in the
tavern - An integer count of alt the characters currently in the Tavern that are marked as enemies
The Tavern class must have the following public member fiutctions: Constructor Defaute
constructor. Default-initializes all private members.
Work through the tasks sequentially (implement and test). Only move on to a task when you are
positive that the previous one has been completed correctly, Remember that the names of classes
and methods must exactly match those in this specification (FUNCTION NAMES,
PARAMETER TYPES, RETURNS, PRE AND POST CONDTTIONS MUST MATCH
EXACTLY. Remember, you must thoroughly document your codellt Task 1: Modify the
Character class
Task 3: Implement the Tavern class as a subclass of ArrayBag The Tavern is subclass of
ArrayBag .
I need help with providing a 2 page overview of the case study provi.pdf
I need help with providing a 2 page overview of the case study provided in pictures please!
asked that he come to his office. When Jenkins saw the office, he laughed and said, "Well
DeMur-or shall I say Maslick-I must say you have some admirers. As an American with African
roots, you should have expected some lighthearted ribbing about your conversion to that strange
religion of yours. Even you must admit that they do some weird things." Maalick replied, "No, I
must suy that I did not expect this!" Jenkins recognized that Maalick was angry and upset ower
the incident and promised to handle the situation. Over the next several months, Maalick
received a series of notes left on his desk and car referencing black cats, black magic, requests
for paim readings and notices about the disappearance of MarShawn DeMur. Not wanting to
cause any problems or be labeled as a troublemaker, Maalick ignored these incidents, thinking
that people would tire of the pranks and things would die down. However, on one occasion, he
found on his desk several sheets of what appeared to be chants with a title at the top that read -
Prayers for Black Folk:" Next to the pages was a book titled Myrical Practices from the Negro
Experionce. Maalick immediately took the materials to the HR department and met with Ford.
Ford told Maalick, "I have been out of the office a lot helping with the staffing of the new
Northwestern facility and had no idea you were having these kinds of problems. Do you have
any idea who is responsible for these actions?" "No I don't," said Maalick. "This is not the type
of behavior that is condoned at Treton. Don't worry, I will handle this immediately. I am so sorry
ahout all of this," said Ford. After Maalick left her office, Ford called a meeting of all
department heads and informed them of the situation. Ford immediately sent an c-mail to all
facility employees, reminding them of Treton's policies regarding discrimination and harassment
and the penalties associated with such actions. By the end of the day, all department heads met
with their employees with specitic wamings and orders for the behaviors to cease and desist. The
days following were a bit tense in the office but calm. Maalick was relieved to not find any more
notes or messages. Fond visited with Maalick on several oceasions to ensure that he was not
continuing to experience any problems. Maalick was happy to report that, in his opinion, all was
well. On Ford's last visit, Maalick took the opportunity to ask about two new systems manager
openings. Promotion to a systems manager position would assist Maalick's career goals for
advancenent with 'Treton. Fond sent Maalick the position description and encouraged him to
apply. After reviewing the systems manager job requirements, Maalick believed that he had
more than a good chance at a promotion. He spoke with Jenkins about the job duties and
reyuirements and expressed his interest in the position. Maalick was informed that at that time,
.
I keep getting NullPointerExcepetion, can someone help me with spinL.pdf
I keep getting NullPointerExcepetion, can someone help me with spinList(int numMoves) and
LinkedList altLists(LinkedList list)?
import java.util.NoSuchElementException;
public class LinkedList {
private class Node {
private T data;
private Node next;
private Node prev;
public Node(T data) {
this.data = data;
this.next = null;
this.prev = null;
}
}
private int length;
private Node first;
private Node last;
private Node iterator;
public LinkedList() {
first = null;
last = null;
length = 0;
iterator = null;
}
public LinkedList(T[] array) {
if (array == null) {
return;
}
if (array.length == 0) {
length = 0;
first = null;
last = null;
iterator = null;
} else {
for (T item : array) {
addLast(item);
}
iterator = null;
}
}
public LinkedList(LinkedList original) {
if (original == null) {
return;
}
if (original.length == 0) {
length = 0;
first = null;
last = null;
iterator = null;
} else {
Node temp = original.first;
while (temp != null) {
addLast(temp.data);
temp = temp.next;
}
iterator = null;
}
}
public T getFirst() throws NoSuchElementException {
if(first == null){
throw new NoSuchElementException("getFirst(): List has no element to access");
}
return first.data;
}
public T getLast() throws NoSuchElementException {
if (last == null){
throw new NoSuchElementException("getLast(): List has no element to access");
}
return last.data;
}
public T getIterator() throws NullPointerException {
if (iterator == null){
throw new NullPointerException("getIterator(): There is no iterator to access");
}
return iterator.data;
}
public int getLength() {
return length;
}
public boolean isEmpty() {
return length == 0;
}
public boolean offEnd() {
return iterator == null;
}
public void addFirst(T data) {
if (length == 0){
first = last = new Node(data);
} else {
Node fill = new Node(data);
fill.next = first;
first.prev = fill;
first = fill;
}
length++;
}
public void addLast(T data) {
if (length == 0) {
first = last = new Node(data);
} else {
Node fill = new Node (data);
fill.prev = last;
last.next = fill;
last = fill;
}
length++;
}
public void addIterator(T data) throws NullPointerException{
if(iterator == null) {
throw new NullPointerException("addIterator(): Can't add the node because iterator points
to null");
} else if(iterator == last){
addLast(data);
} else{
Node fill = new Node(data);
iterator.next.prev = fill;
fill.prev = iterator;
fill.next = iterator.next;
iterator.next = fill;
length++;
}
}
public void removeFirst() throws NoSuchElementException {
if (length == 0) {
throw new NoSuchElementException("removeFirst(): Cannot remove from an empty
List");
} else if(length == 1) {
first = last = null;
} else {
first = first.next;
first.prev = null;
}
length--;
}
public void removeLast() throws NoSuchElementException {
if (length == 0){
throw new NoSuchElementException("removeLast(): Cannot remove from an empty
List");
} else if (length == 1){
first = last = null;
}else{
last = last.prev;
last.next = null;
}
length--;
}
public void removeIterator() throws NullPointerE.
I am trying to pass a date to a function in postgres.My function w.pdf
I am trying to pass a date to a function in postgres.
My function was working correctly. But then I had to introduce date as an input parameter. Ever
since I have introduced the date,
the function is giving an empty result set. Here is my code below, with new addition of date
related code highlighted in bold. Am I missing
something? Do I need to declare the date maybe?
CREATE OR REPLACE FUNCTION public.path_optimization(input_date date)
RETURNS TABLE(area_id_ uuid, result_uuids text[])
LANGUAGE plpgsql
AS $function$
DECLARE
r RECORD;
BEGIN
-- Iterate through the records in pma_ranked
FOR r IN SELECT areaid, max_uuid FROM pma_ranked LOOP
--RAISE NOTICE 'Processing areaid: %, max_uuid: %', r.areaid, r.max_uuid;
RETURN QUERY
EXECUTE
'
WITH RECURSIVE
tree AS (
SELECT
g."centerPoint"::GEOMETRY AS vtcs,
NULL::GEOMETRY AS segment,
ARRAY[g.uuid] AS uuids
FROM
potential_missed_areas AS g
WHERE
g."areaID" = $1
AND g.uuid = $2
AND g.status = ''approved''
AND g."createdAt" = $3
UNION ALL
SELECT
ST_Union(t.vtcs, v."centerPoint"),
ST_ShortestLine(t.vtcs, v."centerPoint"),
t.uuids || v.uuid
FROM
tree AS t
CROSS JOIN LATERAL (
SELECT
g.uuid,
g."centerPoint"
FROM
potential_missed_areas AS g
WHERE
g."areaID" = $1
AND g.status = ''approved''
AND g."createdAt" = $3
AND NOT g.uuid = ANY(t.uuids)
ORDER BY
t.vtcs <-> g."centerPoint"
LIMIT
1
) AS v
),
NumberedRows AS (
SELECT
$1,uuids,
ROW_NUMBER() OVER () AS RowNum
FROM tree
WHERE segment IS NOT NULL
)
SELECT
$1,uuids
FROM NumberedRows
WHERE RowNum = (SELECT MAX(RowNum) FROM NumberedRows);
'
USING r.areaid, r.max_uuid,input_date;
END LOOP;
END;
$function$
;
Here is how I am calling the function:
select * from public.path_optimization('2023-10-04'::date).
How can an event such as the terrorist attacks of September 2001 aff.pdf
How can an event such as the terrorist attacks of September 2001 affect consumer and business
confidence and the economy?
10
Respond to 2 classmates
(10 points possible)
How can an event such as the terrorist attacks of September 2001 affect consumer and business
confidence and the economy?
10
Respond to 2 classmates
(10 points possible)0
4 of 1. a thed is being ball 5. morinative +. Tise Cone Dave Ean. 1 bo fone The 5. Sacteriritoe
ably 1. fle miner antal a. a cosonoclen s. a dopentiks. 4. net dor.
8. Jessic, an employee of Kim's Rentarant, believes that ber enployer has violated her rights in
the workplace. Lanoin The tranch of law dealing with the definition and enforterment of all
peivate er public rights in Pars 1 Name: Class Date Evam 1 2. admininerative law. b. civid law.
c. constitusional taw. if foderal law. a. a case docidod by the Finois Supreme Court. b. a nule
creslod by a Hiliness state administrative apeacy. c. a provision in the fllinois constiturion. x. an
equihable remedy. b. an unelococeblic demant. E. a nemody at law. d. beyoed the court's
antherity. 11. The United Sates Supreme Coun does ner have eripinal juridvanen in my case. a.
True b. False 12. Milo files a sait apainst Nick in an Ohio stace court, noceng that Nisk opvrates
a Web sine thoogh which Ohio arives from 2. anythiag an Obio rscident has doee. b. Nikk's Web
site activities. 6. nothing an Otio residen has done. d. something ether than Nick's Web site. 2.
the cave is being heard foet the firat time. b. the coun has a unizue method of dexiding whether
na hear a case. c. the coun has urnetual pescedural niles. 4. tece subjest matoer of the auit is
intertsting and aew. a. has a sudficiem stake in the matter. h. has jurisdicticen. Pave 2 Name
Class Date Evam 1 c. has sefficicus minimum contacts with the partics. A. is a moet coerrenien
locaties to hold the trial.
Name: Class: Date: Exam 1 Indicate whether the statement is true or false. 1. Statutory law does
not include county ordinances. a. True b. False 2. The stability and predictability of the law are
essential to business activities. a. True b. False 3. Statutes are laws enacted by Congress and the
state legislatures and comprise one of the sources of American law. a. True b. False 4. The term
common law refers to law that is common throughout the world. a. True b. False Indicate the
answer choice that best completes the statement or answers the question. 5. In Benny v. City Car
Dealership, a state supreme court held that a minor could cancel a contract for the sale of a car.
Now a trial court in the same state is deciding Dora v. Even Steven Auto Deals, Inc, a case with
similar facts. Under the doctrine of stare decisis, the trial court is likely to a. allow the minor to
cancel the contract. b. disregard the Benny case. c. order the minor to cancel the contract. d.
require the minor to fulfill the contract. 6. Martin Luther King, Jr. played a singular role in the
most significant social movement in the histor.
Hey! Could I possibly get some help with this Its a little confusi.pdf
Hey! Could I possibly get some help with this? It's a little confusing to me about how to write it.
Technical Document
The objective of the technical document is to provide a high-level overview of the chat console
application's design, components, and interactions. It allows developers to understand the
architecture and implement the chat server and client effectively, ensuring smooth
communication between clients.
An outline example of the technical document:
Introduction:
Architecture Overview describing the high-level architecture of the chat server application, and
outlining its components and their interactions.
Components
Class Diagram (if applicable):
Sequence Diagrams:
Error Handling:.
More from arkmuzikllc (18)
Here is selection filepublic class Selection { public static in.pdf
Here is selection filepublic class Selection { public static in.pdf
Help me with these multiple-choice questions. Please dont use chat .pdf
Help me with these multiple-choice questions. Please dont use chat .pdf
Hello I am stuck in my code I know is everything is goid but I think.pdf
Hello I am stuck in my code I know is everything is goid but I think.pdf
HeadWallRam Inc. has expanded its reach globally and needs to re-lay.pdf
HeadWallRam Inc. has expanded its reach globally and needs to re-lay.pdf
HINT For i = 1 , . . . ,n, let S[i] be the max sum ending with A[i].pdf
HINT For i = 1 , . . . ,n, let S[i] be the max sum ending with A[i].pdf
Hi, I need some assistance with this UML use case diagram. I manage .pdf
Hi, I need some assistance with this UML use case diagram. I manage .pdf
Give an NFA that recognizes the language (10 + 110 + 101) and then .pdf
Give an NFA that recognizes the language (10 + 110 + 101) and then .pdf
IN JAVA BJP5 Exercise 6.19 leetSpeak LanguageType Java file pr.pdf
IN JAVA BJP5 Exercise 6.19 leetSpeak LanguageType Java file pr.pdf
Goal Create a hypothetical threat assessment based on vulnerabilities.pdf
Goal Create a hypothetical threat assessment based on vulnerabilities.pdf
import React, { useEffect } from react;import { BrowserRouter as.pdf
import React, { useEffect } from react;import { BrowserRouter as.pdf
im solving tha m-puzzel sliding tail problem where m = n^2 - 1 I ha.pdf
im solving tha m-puzzel sliding tail problem where m = n^2 - 1 I ha.pdf
Im creating a skip list program for my Algorithms and Advanced Data.pdf
Im creating a skip list program for my Algorithms and Advanced Data.pdf
if any additional information is required let me know Work through t.pdf
if any additional information is required let me know Work through t.pdf
I need help with providing a 2 page overview of the case study provi.pdf
I need help with providing a 2 page overview of the case study provi.pdf
I keep getting NullPointerExcepetion, can someone help me with spinL.pdf
I keep getting NullPointerExcepetion, can someone help me with spinL.pdf
I am trying to pass a date to a function in postgres.My function w.pdf
I am trying to pass a date to a function in postgres.My function w.pdf
How can an event such as the terrorist attacks of September 2001 aff.pdf
How can an event such as the terrorist attacks of September 2001 aff.pdf
Hey! Could I possibly get some help with this Its a little confusi.pdf
Hey! Could I possibly get some help with this Its a little confusi.pdf
Recently uploaded
Biological Screening of Herbal Drugs in detailed.
Biological screening of herbal drugs: Introduction and Need for
Phyto-Pharmacological Screening, New Strategies for evaluating
Natural Products, In vitro evaluation techniques for Antioxidants, Antimicrobial and Anticancer drugs. In vivo evaluation techniques
for Anti-inflammatory, Antiulcer, Anticancer, Wound healing, Antidiabetic, Hepatoprotective, Cardio protective, Diuretics and
Antifertility, Toxicity studies as per OECD guidelines
Overview on Edible Vaccine: Pros & Cons with Mechanism
This ppt include the description of the edible vaccine i.e. a new concept over the traditional vaccine administered by injection.
Acetabularia Information For Class 9 .docx
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
Best Digital Marketing Institute In NOIDA
Safalta Digital marketing institute in Noida, provide complete applications that encompass a huge range of virtual advertising and marketing additives, which includes search engine optimization, virtual communication advertising, pay-per-click on marketing, content material advertising, internet analytics, and greater. These university courses are designed for students who possess a comprehensive understanding of virtual marketing strategies and attributes.Safalta Digital Marketing Institute in Noida is a first choice for young individuals or students who are looking to start their careers in the field of digital advertising. The institute gives specialized courses designed and certification.
for beginners, providing thorough training in areas such as SEO, digital communication marketing, and PPC training in Noida. After finishing the program, students receive the certifications recognised by top different universitie, setting a strong foundation for a successful career in digital marketing.
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
Advantages and Disadvantages of CMS from an SEO Perspective
Advantages and Disadvantages of CMS from an SEO Perspective
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance
The Challenger.pdf DNHS Official Publication
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Unit 8 - Information and Communication Technology (Paper I).pdf
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
CACJapan - GROUP Presentation 1- Wk 4.pdf
Macroeconomics- Movie Location
This will be used as part of your Personal Professional Portfolio once graded.
Objective:
Prepare a presentation or a paper using research, basic comparative analysis, data organization and application of economic information. You will make an informed assessment of an economic climate outside of the United States to accomplish an entertainment industry objective.
"Protectable subject matters, Protection in biotechnology, Protection of othe...
Protectable subject matters, Protection in biotechnology, Protection of other biological materials, Ownership and period of protection
MASS MEDIA STUDIES-835-CLASS XI Resource Material.pdf
mass media studies
CBSE
Full Book
for class 11th
Synthetic Fiber Construction in lab .pptx
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Operation Blue Star - Saka Neela Tara
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
1.4 modern child centered education - mahatma gandhi-2.pptx
Child centred education is an educational approach that priorities the interest, needs and abilities of the child in the learning process.
Recently uploaded (20)
Overview on Edible Vaccine: Pros & Cons with Mechanism
Overview on Edible Vaccine: Pros & Cons with Mechanism
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Advantages and Disadvantages of CMS from an SEO Perspective
Advantages and Disadvantages of CMS from an SEO Perspective
A Survey of Techniques for Maximizing LLM Performance.pptx
A Survey of Techniques for Maximizing LLM Performance.pptx
Unit 8 - Information and Communication Technology (Paper I).pdf
Unit 8 - Information and Communication Technology (Paper I).pdf
"Protectable subject matters, Protection in biotechnology, Protection of othe...
"Protectable subject matters, Protection in biotechnology, Protection of othe...
MASS MEDIA STUDIES-835-CLASS XI Resource Material.pdf
MASS MEDIA STUDIES-835-CLASS XI Resource Material.pdf
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
1.4 modern child centered education - mahatma gandhi-2.pptx
1.4 modern child centered education - mahatma gandhi-2.pptx
Pride Month Slides 2024 David Douglas School District
Pride Month Slides 2024 David Douglas School District
I have been tasked to write a code for a Singly Linked list that inc.pdf
- 1. I have been tasked to write a code for a Singly Linked list that includes the following: Implement a singly linked list class with the following methods: - `void insertAtBeginning(int value)`: Inserts a new node with the given value at the beginning of the list. - `void insertAtEnd(int value)`: Inserts a new node with the given value at the end of the list. - `void deleteNode(int value)`: Deletes the first occurrence of a node with the given value. - `void display()`: Displays the elements of the linked list. I have everything EXCEPT for the deleteNode. I have it included, but it is throwing an error....I just need a little extra help to fix that part. My Code: # #include using namespace std; class Node { //user defined type. public: // public class modifier to access the class node. int value; Node* next; }; void display(Node *head) { if(head == NULL){ cout << "NULL" << endl; } else { cout << head->value << endl; display(head->next); } } void insertAtBeginning(Node**head, int newValue){ // Steps to add a Node to the beginning of the linked list //1. Prepare a newNode Node * newNode = new Node(); newNode ->value = newValue; //2. Put it in front of the current head newNode->next = *head; //3. Move head of the list to point to the newNode *head= newNode; } void insertAtEnd(Node**head, int newValue) {
- 2. //1.Prepare a newNode Node* newNode= new Node(); newNode ->value = newValue; newNode->next = NULL; //2. If Linked list is empty, newNode will be a head node if(*head ==NULL){ *head = newNode; return; } //3. Find last node Node* last= *head; while(last->next!=NULL){ last=last->next; } //4. Insert newNode after last node (at the end of List) last->next =newNode; } void deleteNode(Node**before_del){ Node* temp; temp = before_del->next; before_del->next = temp->next; delete temp; } int main() { Node* head=new Node(); Node* second=new Node(); Node* third=new Node(); Node* fourth=new Node(); head->value = 7; head->next = second; second->value = 12; second->next = third; third->value = 15; third->next = fourth;
- 3. fourth->value = 20; fourth->next = NULL; insertAtBeginning(&head, 4); insertAtBeginning(&head, 6); insertAtEnd(&head, 23); del(&head(15)->next); display(head); }