Write a function to merge two doubly linked lists. The input lists ha.pdf
•
0 likes•11 views
Write a function to merge two doubly linked lists. The input lists have their elements in sorted order, from lowest to highest. The output list should also be sorted from lowest to highest. Your algorithm should run in linear time on the length of the output list. Provide an algorithm for your function Implement and show some samples of your running function Solution The algorithm for LinkedList MergeSort is as follows. The trick in this algorithm is to use a local list to store the value which is pointing to the actual list to be returned as a result of the function Step1: START Step2: GET inputs of list1 and list2 Step3: INITIALIZE mergelist STEP4: SET mylist = mergelist Step5: WHILE list1 OR list2 is EMPTY DO IF (list1 AND list2) are NOT EMPTY IF list1.value > list2.value mylist.next = list2 ELSE mylist.next = list1 ELSE IF list1 is EMPTY mylist.next = list2 ELSE mylist.next = list1 Step6: RETURN mergelist Step7: STOP Sample program for the same implemented in C++ //==================================================================== ======== // Name : DoublyLinkedList.cpp // Author : Kaju // Version : 0.1 // Copyright : This is just an example code // Description : MergeSort in C++, Ansi-style //==================================================================== ======== /* * C++ Program to Implement Doubly Linked List */ #include #include #include /* * Node Declaration */ using namespace std; // struct declaration for node which will hold the integer data with links to previous data and next data struct node { int data; struct node *next; struct node *prev; }; /* Class Declaration */ class DoublyLinkedList { private: struct node *start; // collection of all the nodes public: void create(int value); int peek(); int delete_head(); void display(); int count(); void mergeSort(DoublyLinkedList list1, DoublyLinkedList list2); DoublyLinkedList() { start = NULL; } }; /* * Add data into the list */ void DoublyLinkedList::create(int value) { struct node *s, *temp; temp = new(struct node); temp->data = value; temp->next = NULL; if (start == NULL) { temp->prev = NULL; start = temp; } else { s = start; while (s->next != NULL) s = s->next; s->next = temp; temp->prev = s; } } /* * Deletion of the first element from the list * store the first element in a temp node and then remove it from start. */ int DoublyLinkedList::delete_head() { struct node *tmp, *q; int value; tmp = start; if(start->next!=NULL) { start = start->next; start->prev = NULL; } else start = NULL; value = tmp->data; free(tmp); return value; } /* * return the first element of Doubly Link List */ int DoublyLinkedList::peek() { struct node *q; if (start == NULL) { cout<<\"List is empty\"<data; } } /* * Display elements of Doubly Link List */ void DoublyLinkedList::display() { struct node *q; if (start == NULL) { cout<<\"List is empty\"<data; q = q->next; if(q != NULL) { cout<<\", \"; } } cout<<\"]\"<next; cnt++; } return cnt; } /* * MergeSort - takes two input lists and then based on the.
Report
Share
Report
Share
Download to read offline
Recommended
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.
Homework 05 - Linked Lists (C++)(1) Implement the concepts of a un.pdf
Homework 05 - Linked Lists (C++)
(1) Implement the concepts of a union, and difference as defined noted in Chapter 1 questions 6,
and 8 using a linked list. You should not use arrays, dynamic arrays or the STL vector or STL
list classes.
You will be linking a series of nodes together to implement a single linked list class. Define a
Node as a struct that holds a character (like they did in the book) and a pointer to another Node:
struct Node {
char data;
Node* next;
};
Then define a LinkedList class which has (at a minimum) these member functions:
LinkedList();
~LinkedList();
bool insertAtFront();
bool insertBeforePosition(int index);
bool insertAtBack();
bool deleteAtFront();
bool deleteBeforePosition(int index);
bool deleteAtBack();
Implement each of these functions to provide the correct functionality. These functions return
true if successful in inserting or deleting, otherwise they return false (indicating the operation
was not successful).
Finally, create an overloaded + operator to handle the Union of two linked lists and an
overloaded - operator to handle the Difference of two linked lists.
Because we are dealing with pointers you should have both a LinkedList Constructor and
Destructor. Remember that you do not directly call a Constructor or Destructor Function. The
Destructor is automatically called when the variable loses scope or the program ends.
Remember, that we are dealing with not just one dynamically allocated Node (with the new
operator), but many, so you will have to start at the head of the list and go until the Node points
to nullptr. Then keep deleting the previous Node pointer until there are no Nodes left to delete.
(2) To verify your set class, write a main function that takes two lines of characters from the
input file input.txt and store each line of characters into two separate linked lists. Then using
these two lists, perform the Union and set Difference of the characters from the file, and print the
results to the console.
(3) Please also complete an asymptotic (Big O) analysis of your insertAtFront() and
insertAtBack() member functions. Place this in a file called analysis.txt.
Solution
Here is the complete code for your question. Please do rate the aswer if you are happy with
program. Please read comments in the program. Also pay special attention to comments in + and
- operators. You WILL NEED to comment out if condition in + if you want all elements in both
lists irrespective of if they duplicates or no. For now implemented to have true behaviour of no
duplicates in union.
check the functions by creating some lists and playing around different fucntions like its done in
main and commented out.
As far as complexity:
for insertAtFront() its O(1) since it does not depend on the size of the list. It just replaces the start
of the list. Hence it is O(1) and independent of the size of list.
for insertAtBack(), its O(n) since it depends on the number of elements in the list. It should
traverse till end of list and .
Dividing a linked list into two sublists of almost equal sizesa. A.pdf
Dividing a linked list into two sublists of almost equal sizes
a. Add the operation divideMid to the class linkedListType as follows:
Consider the following statements:
unorderedLinkedList myList;
unorderedLinkedList subList;
Suppose myList points to the list with elements 34 65 27 89 12 (in this order). The statement:
myList.divideMid(subList); divides myList into two sublists: myList points to the list with the
elements 34 65 27,
and subList points to the sublist with the elements 89 12.
b. Write the definition of the function template to implement the operation divideMid. Also,
write a program to test your function. The header files linkedList.h and unorderedLinkedList.h
are supplied. Your test program should produce output similar to this:
Turn in:
linkedList.h with modifications
Your test program.
(C++)
Required code is below:
#ifndef H_UnorderedLinkedList
#define H_UnorderedLinkedList
#include \"linkedList.h\"
using namespace std;
template
class unorderedLinkedList: public linkedListType
{
public:
bool search(const Type& searchItem) const;
//Function to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is in the
// list, otherwise the value false is
// returned.
void insertFirst(const Type& newItem);
//Function to insert newItem at the beginning of the list.
//Postcondition: first points to the new list, newItem is
// inserted at the beginning of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void insertLast(const Type& newItem);
//Function to insert newItem at the end of the list.
//Postcondition: first points to the new list, newItem
// is inserted at the end of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void deleteNode(const Type& deleteItem);
//Function to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the list.
// first points to the first node, last
// points to the last node of the updated
// list, and count is decremented by 1.
};
template
bool unorderedLinkedList::
search(const Type& searchItem) const
{
nodeType *current; //pointer to traverse the list
bool found = false;
current = this->first; //set current to point to the first
//node in the list
while (current != NULL && !found) //search the list
if (current->info == searchItem) //searchItem is found
found = true;
else
current = current->link; //make current point to
//the next node
return found;
}//end search
template
void unorderedLinkedList::insertFirst(const Type& newItem)
{
nodeType *newNode; //pointer to create the new node
newNode = new nodeType; //create the new node
newNode->info = newItem; //store the new item in the node
newNode->link = this->first; //insert newNode before first
this->first = newNode; //make first point to the
//actual first node
this->count++; //increment count
if (this->last == NULL) //if the list was empty, newNode is also
//the last node in the list
this->l.
Hi,I have added the methods and main class as per your requirement.pdf
Hi,
I have added the methods and main class as per your requirement. it is working fine now.
Highlighted the code changes.
MyLinkedListTest.java
public class MyLinkedListTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyLinkedList list = new MyLinkedList();
list.addFirst(\"AAAAA\");
list.add(\"1\");
list.add(\"2\");
list.add(\"3\");
list.addLast(\"ZZZZZ\");
System.out.println(\"Linked List Elements : \"+list.toString());
System.out.println(\"First element: \"+list.getFirst());
System.out.println(\"Second element: \"+list.getLast());
System.out.println(\"Removed First Element: \"+list.removeFirst());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed Last Element: \"+list.removeLast());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed all element: \");
list.removeAll();
System.out.println(\"Now Linked List Elements : \"+list.toString());
}
}
MyLinkedList.java
public class MyLinkedList extends MyAbstractList {
private Node head, tail;
/** Create a default list */
public MyLinkedList() {
}
/** Create a list from an array of objects */
public MyLinkedList(E[] objects) {
super(objects);
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return (E)head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return (E)tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node newNode = new Node(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node newNode = new Node(e); // Create a new for element e
if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = tail.next; // tail now points to the last node
}
size++; // Increase size
}
/** Add a new element at the specified index in this list
* The index of the head element is 0 */
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node temp = current.next;
current.next = new Node(e);
(current.next).next = temp;
size++;
}
}
/** Remove the head node and
* return the object that is contained in the removed node. */
public E removeFirst() {
if (size == 0) {
return null;
}
else {
Node temp = head;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return (E)temp.element;
}
}
/** Remove all elements from list */
public void removeAll() {
while(true) {
if (size == 0) {
break;
}
else {
Node temp = head;
head =.
using the single linked list code written in the class or in the lab,.pdf
using the single linked list code written in the class or in the lab, write and test the follow
function: Merge() function that takes two lists, each of which is sorted in increasing order, and
merges the two together into one list which is in increasing order.
Solution
//The main class
class MergeList {
Node head; // head of list
static Node a, b;
//Node class
static class Node {
int element;
Node next;
// Constructor to create a new node
Node(int d) {
element = d;
next = null;
}
}
void printlist(Node node) {
while (node != null) {
System.out.print(node.element + \" \");
node = node.next;
}
}
Node sortMerge(Node node1, Node node2) {
// Here we will check whether both the list are null or not.
if (node1 == null && node2 == null) {
return null;
}
// sortResultant node
Node sortRes = null;
// Now we will compare and merge the elements of both the list.
while (node1 != null && node2 != null) {
// We will compare current element of both lists
if (node1.element >= node2.element) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
} else {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
}
// If second list reached end, but first list has
// nodes. Add remaining nodes of first list at the
// front of sortResult list
while (node1 != null) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
}
// If first list reached end, but second list has
// node. Add remaining nodes of first list at the
// front of sortResult list
while (node2 != null) {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
return sortRes;
}
public static void main(String[] args) {
MergeList list = new MergeList();
Node sortResult = null;
//Create two linked list
list.a = new Node(5);
list.a.next = new Node(10);
list.a.next.next = new Node(15);
list.b = new Node(2);
list.b.next = new Node(3);
list.b.next.next = new Node(20);
System.out.println(\"List a before merge :\");
list.printlist(a);
System.out.println(\"\");
System.out.println(\"List b before merge :\");
list.printlist(b);
// Cal the function to merge the list in increasing order.
sortResult = list.sortedmerge(a, b);
System.out.println(\"\");
System.out.println(\"Merged linked list : \");
list.printlist(sortResult);
}
}.
2.(Sorted list array implementation)This sorted list ADT discussed .pdf
2.(Sorted list: array implementation)This sorted list ADT discussed in class should be extended
by the addition of two new methods:
//Interface: ArrayListADT
//works for int
public interface ArrayListADT {
public boolean isEmpty(); //Method to determine whether the list is empty.
public boolean isFull(); //Method to determine whether the list is full.
public int listSize(); //Method to return the number of elements in the list.
public int maxListSize(); //Method to return the maximum size of the list.
public void print(); //Method to output the elements of the list.
public boolean isItemAtEqual(int location, int item); //Method to determine whether item is
the same as the item in the list at location.
public void insertAt(int location, int insertItem); //Method to insert insertItem in the list at
the position
public void insertEnd(int insertItem); //Method to insert insertItem at the end of the list.
public void removeAt(int location); //Method to remove the item from the list at location.
public int retrieveAt(int location); //Method to retrieve the element from the list at location.
public void replaceAt(int location, int repItem); //Method to replace the element in the list at
location with repItem.
public void clearList(); //Method to remove all the elements from the list.
public int search(int searchItem); //Method to determine whether searchItem is in the list.
public void remove(int removeItem); //Method to remove an item from the list.
}
//Class: ArrayListClass implements
//Interface: ArrayListADT
public abstract class ArrayListClass implements ArrayListADT {
protected int length; //to store the length of the list
protected int maxSize; //to store the maximum size of the list
protected int[] list; //array to hold the list elements
//Default constructor
public ArrayListClass() {
maxSize = 100;
length = 0;
list = new int[maxSize];
}
//Alternate Constructor
public ArrayListClass(int size) {
if(size <= 0) {
System.err.println(\"The array size must be positive. Creating an array of size 100.\");
maxSize = 100;
}
else
maxSize = size;
length = 0;
list = new int[maxSize];
}
public boolean isEmpty() {
return (length == 0);
}
public boolean isFull() {
return (length == maxSize);
}
public int listSize() {
return length;
}
public int maxListSize() {
return maxSize;
}
public void print() {
for (int i = 0; i < length; i++)
System.out.print(list[i] + \" \");
System.out.println();
}
public boolean isItemAtEqual(int location, int item) {
if (location < 0 || location >= length) {
System.err.println(\"The location of the item to be compared is out of range.\");
return false;
}
return list[location]== item;
}
public void clearList() {
for (int i = 0; i < length; i++)
list[i] = 0;
length = 0;
System.gc(); //invoke the Java garbage collector
}
public void removeAt(int location) {
if (location < 0 || location >= length)
System.err.println(\"The location of the item to be removed is out of range.\");
else {
for(int i = location; i < length - 1; i++)
list[i] .
please i need help Im writing a program to test the merge sort alg.pdf
please i need help I\'m writing a program to test the merge sort algorithm for linked lists.
I need to Print the list before being sorted and the list after sorting the elements
here is my code only help in test program the four classes are ok except the test program.
TEST PROGRAM
import java.io.*;
import java.util.*;
public class Ch9_ProgExercise7 {
Scanner input = new Scanner(System.in);
public static void main(String[] args) throws IOException {
OrderedLinkedList list
= new OrderedLinkedList(); //Line 1
IntElement num = new IntElement(); //Line 2
// Prompt the user to enter some integers
System.out.println(\"Enter integers numbers \");
String temp = input.hasnextLine();
String[] split = temp.split(\" \");
for (int i = 0; i < split.length; i++) {
Integer a = Integer.parseInt(split[i]);
// insert the intgers into the list you created above
num.setNum(a);
list.insertNode(num);
}
System.out.println();
// Print the list before being sorted
// call the mergesort method
System.out.println();
// print the list after sorting the elements
}
}
ORDEREDLICKEDLIST CLASS
public class OrderedLinkedList extends LinkedListClass
{
//default constructor
public OrderedLinkedList()
{
super();
}
//copy constructor
public OrderedLinkedList(OrderedLinkedList otherList)
{
super(otherList);
}
public void linkedInsertionSort()
{
LinkedListNode lastInOrder;
LinkedListNode firstOutOfOrder;
LinkedListNode current;
LinkedListNode trailCurrent;
lastInOrder = first;
if(first == null)
System.out.println(\"Cannot sort an empty list\");
else
if(first.link == null)
System.out.println(\"The list is of length 1. \"
+ \"Already in order\");
else
while(lastInOrder.link != null)
{
firstOutOfOrder = lastInOrder.link;
if(firstOutOfOrder.info.compareTo(first.info) < 0)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = first;
first = firstOutOfOrder;
}
else
{
trailCurrent = first;
current = first.link;
while(current.info.compareTo(firstOutOfOrder.info) < 0)
{
trailCurrent = current;
current = current.link;
}
if(current != firstOutOfOrder)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = current;
trailCurrent.link = firstOutOfOrder;
}
else
lastInOrder = lastInOrder.link;
}
}
}//end linkedInsertionSort
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; otherwise, it returns
// false.
public boolean search(DataElement searchItem)
{
LinkedListNode current; //variable to traverse the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while(current != null && !found ) //search the list
if(current.info.compareTo(searchItem) >= 0)
found = true;
else
current = current.link; //make current point to
//the next node
if(found)
found = current.info.equals(searchItem);
return found;
}
//Method to insert insertItem in the list
//Postcondition: first points to the new list,
// newItem is inserted at the proper place
//.
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.
Recommended
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.
Homework 05 - Linked Lists (C++)(1) Implement the concepts of a un.pdf
Homework 05 - Linked Lists (C++)
(1) Implement the concepts of a union, and difference as defined noted in Chapter 1 questions 6,
and 8 using a linked list. You should not use arrays, dynamic arrays or the STL vector or STL
list classes.
You will be linking a series of nodes together to implement a single linked list class. Define a
Node as a struct that holds a character (like they did in the book) and a pointer to another Node:
struct Node {
char data;
Node* next;
};
Then define a LinkedList class which has (at a minimum) these member functions:
LinkedList();
~LinkedList();
bool insertAtFront();
bool insertBeforePosition(int index);
bool insertAtBack();
bool deleteAtFront();
bool deleteBeforePosition(int index);
bool deleteAtBack();
Implement each of these functions to provide the correct functionality. These functions return
true if successful in inserting or deleting, otherwise they return false (indicating the operation
was not successful).
Finally, create an overloaded + operator to handle the Union of two linked lists and an
overloaded - operator to handle the Difference of two linked lists.
Because we are dealing with pointers you should have both a LinkedList Constructor and
Destructor. Remember that you do not directly call a Constructor or Destructor Function. The
Destructor is automatically called when the variable loses scope or the program ends.
Remember, that we are dealing with not just one dynamically allocated Node (with the new
operator), but many, so you will have to start at the head of the list and go until the Node points
to nullptr. Then keep deleting the previous Node pointer until there are no Nodes left to delete.
(2) To verify your set class, write a main function that takes two lines of characters from the
input file input.txt and store each line of characters into two separate linked lists. Then using
these two lists, perform the Union and set Difference of the characters from the file, and print the
results to the console.
(3) Please also complete an asymptotic (Big O) analysis of your insertAtFront() and
insertAtBack() member functions. Place this in a file called analysis.txt.
Solution
Here is the complete code for your question. Please do rate the aswer if you are happy with
program. Please read comments in the program. Also pay special attention to comments in + and
- operators. You WILL NEED to comment out if condition in + if you want all elements in both
lists irrespective of if they duplicates or no. For now implemented to have true behaviour of no
duplicates in union.
check the functions by creating some lists and playing around different fucntions like its done in
main and commented out.
As far as complexity:
for insertAtFront() its O(1) since it does not depend on the size of the list. It just replaces the start
of the list. Hence it is O(1) and independent of the size of list.
for insertAtBack(), its O(n) since it depends on the number of elements in the list. It should
traverse till end of list and .
Dividing a linked list into two sublists of almost equal sizesa. A.pdf
Dividing a linked list into two sublists of almost equal sizes
a. Add the operation divideMid to the class linkedListType as follows:
Consider the following statements:
unorderedLinkedList myList;
unorderedLinkedList subList;
Suppose myList points to the list with elements 34 65 27 89 12 (in this order). The statement:
myList.divideMid(subList); divides myList into two sublists: myList points to the list with the
elements 34 65 27,
and subList points to the sublist with the elements 89 12.
b. Write the definition of the function template to implement the operation divideMid. Also,
write a program to test your function. The header files linkedList.h and unorderedLinkedList.h
are supplied. Your test program should produce output similar to this:
Turn in:
linkedList.h with modifications
Your test program.
(C++)
Required code is below:
#ifndef H_UnorderedLinkedList
#define H_UnorderedLinkedList
#include \"linkedList.h\"
using namespace std;
template
class unorderedLinkedList: public linkedListType
{
public:
bool search(const Type& searchItem) const;
//Function to determine whether searchItem is in the list.
//Postcondition: Returns true if searchItem is in the
// list, otherwise the value false is
// returned.
void insertFirst(const Type& newItem);
//Function to insert newItem at the beginning of the list.
//Postcondition: first points to the new list, newItem is
// inserted at the beginning of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void insertLast(const Type& newItem);
//Function to insert newItem at the end of the list.
//Postcondition: first points to the new list, newItem
// is inserted at the end of the list,
// last points to the last node in the
// list, and count is incremented by 1.
void deleteNode(const Type& deleteItem);
//Function to delete deleteItem from the list.
//Postcondition: If found, the node containing
// deleteItem is deleted from the list.
// first points to the first node, last
// points to the last node of the updated
// list, and count is decremented by 1.
};
template
bool unorderedLinkedList::
search(const Type& searchItem) const
{
nodeType *current; //pointer to traverse the list
bool found = false;
current = this->first; //set current to point to the first
//node in the list
while (current != NULL && !found) //search the list
if (current->info == searchItem) //searchItem is found
found = true;
else
current = current->link; //make current point to
//the next node
return found;
}//end search
template
void unorderedLinkedList::insertFirst(const Type& newItem)
{
nodeType *newNode; //pointer to create the new node
newNode = new nodeType; //create the new node
newNode->info = newItem; //store the new item in the node
newNode->link = this->first; //insert newNode before first
this->first = newNode; //make first point to the
//actual first node
this->count++; //increment count
if (this->last == NULL) //if the list was empty, newNode is also
//the last node in the list
this->l.
Hi,I have added the methods and main class as per your requirement.pdf
Hi,
I have added the methods and main class as per your requirement. it is working fine now.
Highlighted the code changes.
MyLinkedListTest.java
public class MyLinkedListTest {
/**
* @param args
*/
public static void main(String[] args) {
// TODO Auto-generated method stub
MyLinkedList list = new MyLinkedList();
list.addFirst(\"AAAAA\");
list.add(\"1\");
list.add(\"2\");
list.add(\"3\");
list.addLast(\"ZZZZZ\");
System.out.println(\"Linked List Elements : \"+list.toString());
System.out.println(\"First element: \"+list.getFirst());
System.out.println(\"Second element: \"+list.getLast());
System.out.println(\"Removed First Element: \"+list.removeFirst());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed Last Element: \"+list.removeLast());
System.out.println(\"Now Linked List Elements : \"+list.toString());
System.out.println(\"Removed all element: \");
list.removeAll();
System.out.println(\"Now Linked List Elements : \"+list.toString());
}
}
MyLinkedList.java
public class MyLinkedList extends MyAbstractList {
private Node head, tail;
/** Create a default list */
public MyLinkedList() {
}
/** Create a list from an array of objects */
public MyLinkedList(E[] objects) {
super(objects);
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return (E)head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return (E)tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node newNode = new Node(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node newNode = new Node(e); // Create a new for element e
if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = tail.next; // tail now points to the last node
}
size++; // Increase size
}
/** Add a new element at the specified index in this list
* The index of the head element is 0 */
public void add(int index, E e) {
if (index == 0) {
addFirst(e);
}
else if (index >= size) {
addLast(e);
}
else {
Node current = head;
for (int i = 1; i < index; i++) {
current = current.next;
}
Node temp = current.next;
current.next = new Node(e);
(current.next).next = temp;
size++;
}
}
/** Remove the head node and
* return the object that is contained in the removed node. */
public E removeFirst() {
if (size == 0) {
return null;
}
else {
Node temp = head;
head = head.next;
size--;
if (head == null) {
tail = null;
}
return (E)temp.element;
}
}
/** Remove all elements from list */
public void removeAll() {
while(true) {
if (size == 0) {
break;
}
else {
Node temp = head;
head =.
using the single linked list code written in the class or in the lab,.pdf
using the single linked list code written in the class or in the lab, write and test the follow
function: Merge() function that takes two lists, each of which is sorted in increasing order, and
merges the two together into one list which is in increasing order.
Solution
//The main class
class MergeList {
Node head; // head of list
static Node a, b;
//Node class
static class Node {
int element;
Node next;
// Constructor to create a new node
Node(int d) {
element = d;
next = null;
}
}
void printlist(Node node) {
while (node != null) {
System.out.print(node.element + \" \");
node = node.next;
}
}
Node sortMerge(Node node1, Node node2) {
// Here we will check whether both the list are null or not.
if (node1 == null && node2 == null) {
return null;
}
// sortResultant node
Node sortRes = null;
// Now we will compare and merge the elements of both the list.
while (node1 != null && node2 != null) {
// We will compare current element of both lists
if (node1.element >= node2.element) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
} else {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
}
// If second list reached end, but first list has
// nodes. Add remaining nodes of first list at the
// front of sortResult list
while (node1 != null) {
Node temp = node1.next;
node1.next = sortRes;
sortRes = node1;
node1 = temp;
}
// If first list reached end, but second list has
// node. Add remaining nodes of first list at the
// front of sortResult list
while (node2 != null) {
Node temp = node2.next;
node2.next = sortRes;
sortRes = node2;
node2 = temp;
}
return sortRes;
}
public static void main(String[] args) {
MergeList list = new MergeList();
Node sortResult = null;
//Create two linked list
list.a = new Node(5);
list.a.next = new Node(10);
list.a.next.next = new Node(15);
list.b = new Node(2);
list.b.next = new Node(3);
list.b.next.next = new Node(20);
System.out.println(\"List a before merge :\");
list.printlist(a);
System.out.println(\"\");
System.out.println(\"List b before merge :\");
list.printlist(b);
// Cal the function to merge the list in increasing order.
sortResult = list.sortedmerge(a, b);
System.out.println(\"\");
System.out.println(\"Merged linked list : \");
list.printlist(sortResult);
}
}.
2.(Sorted list array implementation)This sorted list ADT discussed .pdf
2.(Sorted list: array implementation)This sorted list ADT discussed in class should be extended
by the addition of two new methods:
//Interface: ArrayListADT
//works for int
public interface ArrayListADT {
public boolean isEmpty(); //Method to determine whether the list is empty.
public boolean isFull(); //Method to determine whether the list is full.
public int listSize(); //Method to return the number of elements in the list.
public int maxListSize(); //Method to return the maximum size of the list.
public void print(); //Method to output the elements of the list.
public boolean isItemAtEqual(int location, int item); //Method to determine whether item is
the same as the item in the list at location.
public void insertAt(int location, int insertItem); //Method to insert insertItem in the list at
the position
public void insertEnd(int insertItem); //Method to insert insertItem at the end of the list.
public void removeAt(int location); //Method to remove the item from the list at location.
public int retrieveAt(int location); //Method to retrieve the element from the list at location.
public void replaceAt(int location, int repItem); //Method to replace the element in the list at
location with repItem.
public void clearList(); //Method to remove all the elements from the list.
public int search(int searchItem); //Method to determine whether searchItem is in the list.
public void remove(int removeItem); //Method to remove an item from the list.
}
//Class: ArrayListClass implements
//Interface: ArrayListADT
public abstract class ArrayListClass implements ArrayListADT {
protected int length; //to store the length of the list
protected int maxSize; //to store the maximum size of the list
protected int[] list; //array to hold the list elements
//Default constructor
public ArrayListClass() {
maxSize = 100;
length = 0;
list = new int[maxSize];
}
//Alternate Constructor
public ArrayListClass(int size) {
if(size <= 0) {
System.err.println(\"The array size must be positive. Creating an array of size 100.\");
maxSize = 100;
}
else
maxSize = size;
length = 0;
list = new int[maxSize];
}
public boolean isEmpty() {
return (length == 0);
}
public boolean isFull() {
return (length == maxSize);
}
public int listSize() {
return length;
}
public int maxListSize() {
return maxSize;
}
public void print() {
for (int i = 0; i < length; i++)
System.out.print(list[i] + \" \");
System.out.println();
}
public boolean isItemAtEqual(int location, int item) {
if (location < 0 || location >= length) {
System.err.println(\"The location of the item to be compared is out of range.\");
return false;
}
return list[location]== item;
}
public void clearList() {
for (int i = 0; i < length; i++)
list[i] = 0;
length = 0;
System.gc(); //invoke the Java garbage collector
}
public void removeAt(int location) {
if (location < 0 || location >= length)
System.err.println(\"The location of the item to be removed is out of range.\");
else {
for(int i = location; i < length - 1; i++)
list[i] .
please i need help Im writing a program to test the merge sort alg.pdf
please i need help I\'m writing a program to test the merge sort algorithm for linked lists.
I need to Print the list before being sorted and the list after sorting the elements
here is my code only help in test program the four classes are ok except the test program.
TEST PROGRAM
import java.io.*;
import java.util.*;
public class Ch9_ProgExercise7 {
Scanner input = new Scanner(System.in);
public static void main(String[] args) throws IOException {
OrderedLinkedList list
= new OrderedLinkedList(); //Line 1
IntElement num = new IntElement(); //Line 2
// Prompt the user to enter some integers
System.out.println(\"Enter integers numbers \");
String temp = input.hasnextLine();
String[] split = temp.split(\" \");
for (int i = 0; i < split.length; i++) {
Integer a = Integer.parseInt(split[i]);
// insert the intgers into the list you created above
num.setNum(a);
list.insertNode(num);
}
System.out.println();
// Print the list before being sorted
// call the mergesort method
System.out.println();
// print the list after sorting the elements
}
}
ORDEREDLICKEDLIST CLASS
public class OrderedLinkedList extends LinkedListClass
{
//default constructor
public OrderedLinkedList()
{
super();
}
//copy constructor
public OrderedLinkedList(OrderedLinkedList otherList)
{
super(otherList);
}
public void linkedInsertionSort()
{
LinkedListNode lastInOrder;
LinkedListNode firstOutOfOrder;
LinkedListNode current;
LinkedListNode trailCurrent;
lastInOrder = first;
if(first == null)
System.out.println(\"Cannot sort an empty list\");
else
if(first.link == null)
System.out.println(\"The list is of length 1. \"
+ \"Already in order\");
else
while(lastInOrder.link != null)
{
firstOutOfOrder = lastInOrder.link;
if(firstOutOfOrder.info.compareTo(first.info) < 0)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = first;
first = firstOutOfOrder;
}
else
{
trailCurrent = first;
current = first.link;
while(current.info.compareTo(firstOutOfOrder.info) < 0)
{
trailCurrent = current;
current = current.link;
}
if(current != firstOutOfOrder)
{
lastInOrder.link = firstOutOfOrder.link;
firstOutOfOrder.link = current;
trailCurrent.link = firstOutOfOrder;
}
else
lastInOrder = lastInOrder.link;
}
}
}//end linkedInsertionSort
//Method to determine whether searchItem is in
//the list.
//Postcondition: Returns true if searchItem is found
// in the list; otherwise, it returns
// false.
public boolean search(DataElement searchItem)
{
LinkedListNode current; //variable to traverse the list
boolean found;
current = first; //set current to point to the first
//node in the list
found = false; //set found to false
while(current != null && !found ) //search the list
if(current.info.compareTo(searchItem) >= 0)
found = true;
else
current = current.link; //make current point to
//the next node
if(found)
found = current.info.equals(searchItem);
return found;
}
//Method to insert insertItem in the list
//Postcondition: first points to the new list,
// newItem is inserted at the proper place
//.
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.
STAGE 2 The Methods 65 points Implement all the methods t.pdf
STAGE 2: The Methods (65 points) Implement all the methods that are marked as Left as
Exercise. The Driver program only works when you have done all the methods. I have added the
template of all the methods with a placeholder value as return types of the methods. For example,
return 0 if method returns an int value.
List of the methods left as exercise are as follows: /** Create a list from an array of objects */
@SuppressWarnings("unchecked") public MyLinkedList(E[] objects) /** Add a new element at the
specified index in this list in ascending order */ public void addInOrder(E e) /** Check to see if this
list contains element e */ public boolean contains(E e) /** Remove all the occurrences of the
element e * from this list. Return true if the element is * removed. */ public boolean removeAll(E e)
/** Remove the first occurrence of the element e * from this list. Return true if the element is *
removed. */ public boolean remove(E e) /** Return the element at the specified index */ public E
get(int index) /** Return the index of the head matching element in * this list. Return -1 if no match.
*/ public int indexOf(Object e) /** Return the index of the last matching element in * this list. Return
-1 if no match. */ public int lastIndexOf(E e) /** Replace the element at the specified position * in
this list with the specified element. */ public E set(int index, E e) /** Print this list using recursion */
public void printList() /** Returns an array containing all of the elements * in this collection; * the
runtime type of the returned array is that of * the specified array. */ public <E> E[] toArray(E[]
array) /** Split the original list in half. The original * list will continue to reference the * front half of
the original list and the method * returns a reference to a new list that stores the * back half of the
original list.
public class MyLinkedList<E extends Comparable<E>> {
private Node<E> head, tail;
private int size = 0; // Number of elements in the list
public MyLinkedList() {
head=tail=null;
size=0;
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node<E> newNode = new Node<>(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node<E> newNode = new Node<>(e); // Create a new for element e
if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = newNode; // tail now points to the last node
}
size++; // Incr.
The LinkedList1 class implements a Linked list. class.pdf
/**
The LinkedList1 class implements a Linked list.
*/
class LinkedList1
{
/**
The Node class stores a list element
and a reference to the next node.
*/
private class Node
{
String value;
Node next;
/**
Constructor.
@param val The element to store in the node.
@param n The reference to the successor node.
*/
Node(String val, Node n)
{
value = val;
next = n;
}
/**
Constructor.
@param val The element to store in the node.
*/
Node(String val)
{
// Call the other (sister) constructor.
this(val, null);
}
}
private Node first; // list head
private Node last; // last element in list
/**
Constructor.
*/
public LinkedList1()
{
first = null;
last = null;
}
/**
The isEmpty method checks to see
if the list is empty.
@return true if list is empty,
false otherwise.
*/
public boolean isEmpty()
{
return first == null;
}
/**
The size method returns the length of the list.
@return The number of elements in the list.
*/
public int size()
{
int count = 0;
Node p = first;
while (p != null)
{
// There is an element at p
count ++;
p = p.next;
}
return count;
}
/**
The add method adds an element to
the end of the list.
@param e The value to add to the
end of the list.
*/
public void add(String e)
{
if (isEmpty())
{
first = new Node(e);
last = first;
}
else
{
// Add to end of existing list
last.next = new Node(e);
last = last.next;
}
}
/**
The add method adds an element at a position.
@param e The element to add to the list.
@param index The position at which to add
the element.
@exception IndexOutOfBoundsException When
index is out of bounds.
*/
public void add(int index, String e)
{
if (index < 0 || index > size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
// Index is at least 0
if (index == 0)
{
// New element goes at beginning
first = new Node(e, first);
if (last == null)
last = first;
return;
}
// Set a reference pred to point to the node that
// will be the predecessor of the new node
Node pred = first;
for (int k = 1; k <= index - 1; k++)
{
pred = pred.next;
}
// Splice in a node containing the new element
pred.next = new Node(e, pred.next);
// Is there a new last element ?
if (pred.next.next == null)
last = pred.next;
}
/**
The toString method computes the string
representation of the list.
@return The string form of the list.
*/
public String toString()
{
StringBuilder strBuilder = new StringBuilder();
// Use p to walk down the linked list
Node p = first;
while (p != null)
{
strBuilder.append(p.value + \"\ \");
p = p.next;
}
return strBuilder.toString();
}
/**
The remove method removes the element at an index.
@param index The index of the element to remove.
@return The element removed.
@exception IndexOutOfBoundsException When index is
out of bounds.
*/
public String remove(int index)
{
if (index < 0 || index >= size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
String element; // The element to return
if (index == 0)
{
// Removal of first item in the list
element.
C++ problemPart 1 Recursive Print (40 pts)Please write the recu.pdf
C++ problem
Part 1: Recursive Print (40 pts)
Please write the recursive List reverse print function, whose iterative version we wrote in class.
Below are the function signatures for the functions you are going to need:
public:
/**Additional Operations*/
void print_reverse();
//Wrapper function that calls the reverse helper function to print a list in reverse
//prints nothing if the List is empty
private:
void reverse(Nodeptr node);
//Helper function for the public printReverse() function.
//Recursively prints the data in a List in reverse.
Why do we need the private helper function here?
Since we are going to be reversing our list node by node, in a recursive fashion, we want to pass
a one node at a time to our reverse function.
However, since our nodes are private, we cannot access them if we call the function inside of
main.
Add these function signatures to your List.h file along with your other function prototypes inside
the class definition.
Make sure that you place the reverse function inside the private portion of your List class
definition and the print_reverse function prototype to the public portion of your List class
definition.
Now, implement these two functions inside of List.h, under your section for additional
operations.
Important: Test each function carefully inside of your ListTest.cpp to make sure that it is
working properly.
Part 2: Adding an Index to Your List Nodes (20 pts)
Next, you will add the following functions to your List.h
/**Accessor Functions*/
int get_index();
//Indicates the index of the Node where the iterator is currently pointing
//Nodes are numbered from 1 to length of the list
//Pre: length != 0
//Pre: !off_end()
...
int List::get_index()
{
//Implement the function here
}
/**Manipulation Procedures*/
void scroll_to_index(int index);
//Moves the iterator to the node whose index is specified by the user
//Pre: length != 0
...
void scroll_to_index(int index)
{
//Implement function here
}
Part 3: Implementing Search as Part of Your List (40 pts)
Now, we are going to add two search functions to our List so that we can search for elements in
our List.
The first of these functions is going to be a simple linear search function.
You will need to add the following function prototype and function definition to your List.h:
/**Additional Operations*/
int linear_search(listitem item);
//Searchs the list, element by element, from the start of the List to the end of the List
//Returns the index of the element, if it is found in the List
//Returns -1 if the element is not in the List
//Pre: length != 0
...
int List::linear_search(listitem item)
{
//Implement the function here
}
You are also going to add a function to perform recursive binary search on your List.
You will need to add the following function prototype and function definition to your List.h:
int binary_search(int low, int high, listitem item);
//Recursively searchs the list by dividing the search space in half
//Returns the index of the element, if it is fo.
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class Diagram:
In the Assignment #10, you are given three files Assignment10.java, LinkedList.java, and
ListIterator.java. You will need to add additional methods in the LinkedList class in the
LinkedList.java file. The LinkedList will be tested using strings only.
Specifically, the following methods must be implemented in the LinkedList class:
(You should utilize listIterator() method already defined in the LinkedList class to obtain its
LinkedListIterator object, and use the methods in the LinkedListIterator class to traverse from
the first element to the last element of the linked list to define the following methods.)
1.
public String toString()
The toString method should concatenate strings in the linked list, and return a string of the
following format:
{ Apple Banana Melon Orange }
Thus it starts with \"{\" and ends with \"}\", and there is a space between strings and \"{\" or
\"}\". If the list is empty, it returns \"{ }\" with a space in between.
2.
public boolean isEmpty()
The isEmpty method returns true of the linked list is empty, false otherwise.
3.
public void addElement(Object element)
The addElement adds the parameter element at the parameter in the linked list in alphabetical
order. For instance, if the linked list contains {Apple, Banana, Grape}, and a user tries to add
\"Carrot\", then it should be added as:
{Apple, Banana, Carrot, Grape}.
4.
public Object removeElement(int index)
The removeElement removes the string (Object) at the parameter index and returns it. Note that
this index starts with 0 just like array indices. For instance, if the linked list contains {Apple,
Banana, Carrot, Grape} and the parameter index is 3, then \"Grape\" should be remove. If the
parameter index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
5.
public Object getElement(int index)
The getElement searches the string (Object) at the parameter index and returns it. Note that this
index starts with 0 just like array indices. For instance, if the linked list contains {Apple, Banana,
Carrot, Grape} and the parameter index is 3, then \"Grape\" will be returned. If the parameter
index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
6.
public void searchAndReplace(Object oldString, Object newString)
The searchAndReplace method searches all occurrences of the first parameter string (object) in
the list, and replaces them with the second parameter string (object). If the parameter string does
not exist in the linked list, then the linked list content will not change.
7.
public int indexOfLast(Object searchString)
The indexOfLast searches the parameter string (object) with the largest index, and returns its
index. If the parameter string does not exist in the linked list, then it should return -1.
For i.
File LinkedList.java Defines a doubly-l.pdf
File: LinkedList.java
/**
* Defines a doubly-linked list class
*/
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;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
/**
* Returns the value stored in the first node
* @precondition
* @return the value stored at node first
* @throws NoSuchElementException
*/
public T getFirst() throws NoSuchElementException {
return null;
}
/**
* Returns the value stored in the last node
* @precondition
* @return the value stored in the node last
* @throws NoSuchElementException
*/
public T getLast() throws NoSuchElementException {
return null;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
return null;
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return -1;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return false;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return false;
}
/**** MUTATORS ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition
*/
public void addFirst(T data) {
return;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition
*/
public void addLast(T data) {
return;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
return;
}
/**
* removes the element at the front of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeFirst() throws NoSuchElementException {
return;
}
/**
* removes the element at the end of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeLast() throws NoSuchElementException {
return;
}
/**
* removes the element referenced by the iterator
* @precondition
* @pos.
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
Please help solve this in C++ So the program is working fin.pdf
Please help solve this in C++. So the program is working fine but when submitting it, it gives me a
code -11, and I believe the problem is that after inserting the numbers it removes them one by one
until the last in the list, and when it tries to remove the last number in the list that is when it
counters the problem. Below is the full code but you just need to change something in the
SortedNumberList.h file under the bool remove function.
4.18 LAB: Sorted number list implementation with linked lists Step 1: Inspect the Node.h file
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 2347.2586, 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: 2335.547.2586Step 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 77154263.5 then output is: List after inserting 77 : 77 List after
inserting 15 : 1577 List after inserting -42 : -421577 List after inserting 63.5: -421563.577 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove(0 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
841972841961 then output is: List after inserting 84: 84 List after inserting 72 : 7284 List after
inserting 19: 1972 84 List after inserting 61: 1961 : 72 8 List after removing 19: 6172 84 List after
removing 84: 6172Current file: main.cpp - // Insert each value and show the sorted List's contents
after each insertion sortedNumberList list; for (auto term : terms) { doubl.
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.
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.
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.
import java.util.LinkedList; import java.util.Random; import jav.pdf
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
/**
* author
*
*/
public class LinkedListTest {
/**
* param args
*/
public static void main(String[] args) {
int M, N, Lower, Upper;
Scanner scanner = null;
try {
LinkedList list1 = new LinkedList();
LinkedList list2 = new LinkedList();
LinkedList list3 = new LinkedList();
Random random = new Random();
scanner = new Scanner(System.in);
System.out.print(\"Enter the Lower and Upper bounds:\");
Lower = scanner.nextInt();
Upper = scanner.nextInt();
System.out.print(\"Enter the N value to Insert list1:\");
N = scanner.nextInt();
System.out.print(\"Enter the M value to Insert list2:\");
M = scanner.nextInt();
for (int i = 1; i <= N; i++) {
list1.add(random.nextInt((Upper - Lower) + 1) + Lower);
}
for (int i = 1; i <= M; i++) {
list2.add(random.nextInt((Upper - Lower) + 1) + Lower);
}
System.out.println(\"list1: \" + list1);
System.out.println(\"list2: \" + list2);
System.out.println(\"Minimum elelment in list1 :\" + getMin(list1));
System.out.println(\"Minimum elelment in list2 :\" + getMin(list2));
System.out
.println(\"Count Divisibles by 3 and 5 elelment in list1 :\"
+ countDivisibles(list1));
System.out
.println(\"Count Divisibles by 3 and 5 elelment in list2 :\"
+ countDivisibles(list2));
System.out.println(\"Common Elements From list1 and list2:\"
+ getCommonList(list1, list2));
} catch (Exception e) {
// TODO: handle exception
}
}
/**
* param list
* return
*/
public static int getMin(LinkedList list) {
int min = list.get(0);
for (Integer integer : list) {
if (min > integer) {
min = integer;
}
}
return min;
}
/**
* param list
* return
*/
public static int countDivisibles(LinkedList list) {
int count = 0;
for (Integer integer : list) {
if (integer % 3 == 0 && integer % 5 == 0) {
count++;
}
}
return count;
}
/**
* param list1
* param list2
* return
*/
public static LinkedList getCommonList(LinkedList list1,
LinkedList list2) {
LinkedList list = new LinkedList();
LinkedList listCommon = new LinkedList();
list = (list1.size() > list2.size()) ? list1 : list2;
for (int i = 0; i < list.size(); i++) {
Integer number = list.get(i);
if (list2.contains(number) && list1.contains(number)) {
listCommon.add(number);
}
}
return listCommon;
}
}
OUTPUT:
Enter the Lower and Upper bounds:1 10
Enter the N value to Insert list1:10
Enter the M value to Insert list2:20
list1: [1, 4, 4, 6, 9, 4, 9, 5, 8, 5]
list2: [5, 10, 10, 2, 1, 10, 8, 8, 8, 2, 6, 10, 6, 2, 5, 9, 6, 9, 6, 2]
Minimum elelment in list1 :1
Minimum elelment in list2 :1
Count Divisibles by 3 and 5 elelment in list1 :0
Count Divisibles by 3 and 5 elelment in list2 :0
Common Elements From list1 and list2:[5, 1, 8, 8, 8, 6, 6, 5, 9, 6, 9, 6]
Solution
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
/**
* author
*
*/
public class LinkedListTest {
/**
* param args
*/
public static void main(String[] args) {
int M, N, Lower, Upper;
Scanner scanner = null;
try {
LinkedList list1 = new LinkedList();
L.
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.
Select three methods in the ObjectList class to work through algori.pdf
Select three methods in the ObjectList class to work through algorithmically. Describe any
special cases or boundary conditions that might exist for each of the three methods selected. Be
sure to draw pictures as you work through the methods. Remember that you cannot work on
linked lists without drawing pictures. The homework will not be accepted without submitting the
pictures! Write a Java method with the signature: public objectList intersect (objectList list1,
objectList list2) that accepts two unordered linear linked lists and returns a third linear linked list
whose nodes contains the intersection of the two original linear linked lists. Note that the
intersection of two lists is a new list containing the elements that the two lists have in common,
without modifying the two original lists. Describe any boundary conditions that might exist.
Solution
Node.java
//Defines each node of a linked list
public class Node{
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
ObjectList.java
public class ObjectList{
public Node head;
/* Utility function to print list */
public void printList()
{
Node temp = head;
while(temp != null)
{
System.out.print(temp.data+\" \");
temp = temp.next;
}
System.out.println();
}
/* Inserts a node at start of linked list */
public void push(int new_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
Node new_node = new Node(new_data);
/* 3. Make next of new Node as head */
new_node.next = head;
/* 4. Move the head to point to new Node */
head = new_node;
}
/* A utilty function that returns true if data is present
in linked list else return false */
public boolean isPresent (int data){
Node t = this.head;
while (t != null)
{
if (t.data == data)
return true;
t = t.next;
}
return false;
}
}
Intersection.java
//Implements the intersection method.
class Intersection{
static public ObjectList intersect(ObjectList list1, ObjectList list2){
ObjectList result = new ObjectList();
//Node t1 = head1;
Node t1 = list1.head;
Node t2 = list2.head;
// Traverse list1 and search each element of it in list2.
// If the element is present in list 2, then insert the
// element to result
while (t1 != null){
if (list2.isPresent(t1.data))
result.push(t1.data);
t1 = t1.next;
}
return result;
}
/* Driver program to test above functions */
public static void main(String args[]){
ObjectList llist1 = new ObjectList();
ObjectList llist2 = new ObjectList();
ObjectList unin = new ObjectList();
ObjectList intersecn = new ObjectList();
/*create a linked lits 10->15->5->20 */
llist1.push(20);
llist1.push(4);
llist1.push(15);
llist1.push(10);
/*create a linked lits 8->4->2->10 */
llist2.push(10);
llist2.push(2);
llist2.push(4);
llist2.push(8);
intersecn = intersect(llist1, llist2);
intersecn.printList();
}
}.
Many biologists will talk about the group known as Ungulates, or hoo.pdf
Many biologists will talk about the group known as Ungulates, or hoofed mammals. This group
includes species as diverse as pigs (Sus), elk (Cervus), cows (Bos), hippos (Hippopotamus),
extinct species (e.g., Elomeryx and Archaeotherium), and even rhinos and horses (Equus). Based
upon the tree above and assuming this tree is correct, is this group (Ungulates) monophyletic?A.
Yes, because all of these species share the synapomorphy of hooves
Solution
b. Yes, because all of these species share a most recent common ancestor
All the members of the group of interest are more closely related to each other than they are to
the outgroup. Hence, the outgroup stems from the base of the tree. An outgroup can give you a
sense of where on the bigger tree of life the main group of organisms falls. It is also useful when
constructing evolutionary trees..
Match the function with the appropriate organelle in the column at ri.pdf
Match the function with the appropriate organelle in the column at right. Endoplasmic
reticulum Smooth endoplasmic reticulum Rough endoplasmic reticulum Golgi complex
Transport vesicles Secretory granules Endosome Lysosome Mitochondrion Chloroplast
Plasma membrane Nucleus Location of most of the cell\'s DNA site of fuel oxidation
Separates the inside of the cell from the outside Carries important biochemical into the cell
Membrane with ribosomes attached Site of photosynthesis Contains digestive enzymes
Destined for fusion with the plasma membrane 9 Common form of cytoplasmic membrane Site
of carbohydrate addition to proteins Processes exogenous chemicals Facilitates communication
between the rough endoplasmic reticulum and the Golgi complex
Solution
Please find the correct matches with reasons in parenthesis:
a. Endoplasmic reticulum : 9 (the endoplasmic reticulum is normally found concentrated near the
nucleus and is considered as a physical extension of nuclear membrane only)
b. smooth endoplasmic reticulum: 10 (smooth ER represents the site for protein modification by
glycosylation)
c. rough endoplasmic reticulum: 5 (this is the site for protein synthesis)
d. golgi complex: 12 (the proteins released for rough ER are transported to smooth ER for post
translational modification such as glycosylation via the golgi complex only)
e. transport vesicles: 4 (the transport vesciles pinch off the golgi complex for tranversing the
material from one part of cell to the other)
f. Secretory granules: 8 (secretory granules are released from one cell for extracellular transport
which ultimately fuse with plasma membrane of other cell for inlet of the materials)
g. endosomes:11(endosome is the first vesicle which ingest any foreign material and processes it)
h. lysosomes: 7 (this contains hydrolyzing enzymes which help in digestion)
i. mitochondria: 2 (known as energy house of the cell by oxidative phosphorylation)
j. chloroplast: 6 (found only in green plants and lower organisms, chloroplast is the site of
photosynthesis)
k. plasma membrane: 3 (it represents the boundary of the periphery of a cell for discrimination
between inside and outside)
l. nucleus: 1 (this contains the genetic material i.e. DNA of the cell).
More Related Content
Similar to Write a function to merge two doubly linked lists. The input lists ha.pdf
STAGE 2 The Methods 65 points Implement all the methods t.pdf
STAGE 2: The Methods (65 points) Implement all the methods that are marked as Left as
Exercise. The Driver program only works when you have done all the methods. I have added the
template of all the methods with a placeholder value as return types of the methods. For example,
return 0 if method returns an int value.
List of the methods left as exercise are as follows: /** Create a list from an array of objects */
@SuppressWarnings("unchecked") public MyLinkedList(E[] objects) /** Add a new element at the
specified index in this list in ascending order */ public void addInOrder(E e) /** Check to see if this
list contains element e */ public boolean contains(E e) /** Remove all the occurrences of the
element e * from this list. Return true if the element is * removed. */ public boolean removeAll(E e)
/** Remove the first occurrence of the element e * from this list. Return true if the element is *
removed. */ public boolean remove(E e) /** Return the element at the specified index */ public E
get(int index) /** Return the index of the head matching element in * this list. Return -1 if no match.
*/ public int indexOf(Object e) /** Return the index of the last matching element in * this list. Return
-1 if no match. */ public int lastIndexOf(E e) /** Replace the element at the specified position * in
this list with the specified element. */ public E set(int index, E e) /** Print this list using recursion */
public void printList() /** Returns an array containing all of the elements * in this collection; * the
runtime type of the returned array is that of * the specified array. */ public <E> E[] toArray(E[]
array) /** Split the original list in half. The original * list will continue to reference the * front half of
the original list and the method * returns a reference to a new list that stores the * back half of the
original list.
public class MyLinkedList<E extends Comparable<E>> {
private Node<E> head, tail;
private int size = 0; // Number of elements in the list
public MyLinkedList() {
head=tail=null;
size=0;
}
/** Return the head element in the list */
public E getFirst() {
if (size == 0) {
return null;
}
else {
return head.element;
}
}
/** Return the last element in the list */
public E getLast() {
if (size == 0) {
return null;
}
else {
return tail.element;
}
}
/** Add an element to the beginning of the list */
public void addFirst(E e) {
Node<E> newNode = new Node<>(e); // Create a new node
newNode.next = head; // link the new node with the head
head = newNode; // head points to the new node
size++; // Increase list size
if (tail == null) // the new node is the only node in list
tail = head;
}
/** Add an element to the end of the list */
public void addLast(E e) {
Node<E> newNode = new Node<>(e); // Create a new for element e
if (tail == null) {
head = tail = newNode; // The new node is the only node in list
}
else {
tail.next = newNode; // Link the new with the last node
tail = newNode; // tail now points to the last node
}
size++; // Incr.
The LinkedList1 class implements a Linked list. class.pdf
/**
The LinkedList1 class implements a Linked list.
*/
class LinkedList1
{
/**
The Node class stores a list element
and a reference to the next node.
*/
private class Node
{
String value;
Node next;
/**
Constructor.
@param val The element to store in the node.
@param n The reference to the successor node.
*/
Node(String val, Node n)
{
value = val;
next = n;
}
/**
Constructor.
@param val The element to store in the node.
*/
Node(String val)
{
// Call the other (sister) constructor.
this(val, null);
}
}
private Node first; // list head
private Node last; // last element in list
/**
Constructor.
*/
public LinkedList1()
{
first = null;
last = null;
}
/**
The isEmpty method checks to see
if the list is empty.
@return true if list is empty,
false otherwise.
*/
public boolean isEmpty()
{
return first == null;
}
/**
The size method returns the length of the list.
@return The number of elements in the list.
*/
public int size()
{
int count = 0;
Node p = first;
while (p != null)
{
// There is an element at p
count ++;
p = p.next;
}
return count;
}
/**
The add method adds an element to
the end of the list.
@param e The value to add to the
end of the list.
*/
public void add(String e)
{
if (isEmpty())
{
first = new Node(e);
last = first;
}
else
{
// Add to end of existing list
last.next = new Node(e);
last = last.next;
}
}
/**
The add method adds an element at a position.
@param e The element to add to the list.
@param index The position at which to add
the element.
@exception IndexOutOfBoundsException When
index is out of bounds.
*/
public void add(int index, String e)
{
if (index < 0 || index > size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
// Index is at least 0
if (index == 0)
{
// New element goes at beginning
first = new Node(e, first);
if (last == null)
last = first;
return;
}
// Set a reference pred to point to the node that
// will be the predecessor of the new node
Node pred = first;
for (int k = 1; k <= index - 1; k++)
{
pred = pred.next;
}
// Splice in a node containing the new element
pred.next = new Node(e, pred.next);
// Is there a new last element ?
if (pred.next.next == null)
last = pred.next;
}
/**
The toString method computes the string
representation of the list.
@return The string form of the list.
*/
public String toString()
{
StringBuilder strBuilder = new StringBuilder();
// Use p to walk down the linked list
Node p = first;
while (p != null)
{
strBuilder.append(p.value + \"\ \");
p = p.next;
}
return strBuilder.toString();
}
/**
The remove method removes the element at an index.
@param index The index of the element to remove.
@return The element removed.
@exception IndexOutOfBoundsException When index is
out of bounds.
*/
public String remove(int index)
{
if (index < 0 || index >= size())
{
String message = String.valueOf(index);
throw new IndexOutOfBoundsException(message);
}
String element; // The element to return
if (index == 0)
{
// Removal of first item in the list
element.
C++ problemPart 1 Recursive Print (40 pts)Please write the recu.pdf
C++ problem
Part 1: Recursive Print (40 pts)
Please write the recursive List reverse print function, whose iterative version we wrote in class.
Below are the function signatures for the functions you are going to need:
public:
/**Additional Operations*/
void print_reverse();
//Wrapper function that calls the reverse helper function to print a list in reverse
//prints nothing if the List is empty
private:
void reverse(Nodeptr node);
//Helper function for the public printReverse() function.
//Recursively prints the data in a List in reverse.
Why do we need the private helper function here?
Since we are going to be reversing our list node by node, in a recursive fashion, we want to pass
a one node at a time to our reverse function.
However, since our nodes are private, we cannot access them if we call the function inside of
main.
Add these function signatures to your List.h file along with your other function prototypes inside
the class definition.
Make sure that you place the reverse function inside the private portion of your List class
definition and the print_reverse function prototype to the public portion of your List class
definition.
Now, implement these two functions inside of List.h, under your section for additional
operations.
Important: Test each function carefully inside of your ListTest.cpp to make sure that it is
working properly.
Part 2: Adding an Index to Your List Nodes (20 pts)
Next, you will add the following functions to your List.h
/**Accessor Functions*/
int get_index();
//Indicates the index of the Node where the iterator is currently pointing
//Nodes are numbered from 1 to length of the list
//Pre: length != 0
//Pre: !off_end()
...
int List::get_index()
{
//Implement the function here
}
/**Manipulation Procedures*/
void scroll_to_index(int index);
//Moves the iterator to the node whose index is specified by the user
//Pre: length != 0
...
void scroll_to_index(int index)
{
//Implement function here
}
Part 3: Implementing Search as Part of Your List (40 pts)
Now, we are going to add two search functions to our List so that we can search for elements in
our List.
The first of these functions is going to be a simple linear search function.
You will need to add the following function prototype and function definition to your List.h:
/**Additional Operations*/
int linear_search(listitem item);
//Searchs the list, element by element, from the start of the List to the end of the List
//Returns the index of the element, if it is found in the List
//Returns -1 if the element is not in the List
//Pre: length != 0
...
int List::linear_search(listitem item)
{
//Implement the function here
}
You are also going to add a function to perform recursive binary search on your List.
You will need to add the following function prototype and function definition to your List.h:
int binary_search(int low, int high, listitem item);
//Recursively searchs the list by dividing the search space in half
//Returns the index of the element, if it is fo.
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class Diagram:
In the Assignment #10, you are given three files Assignment10.java, LinkedList.java, and
ListIterator.java. You will need to add additional methods in the LinkedList class in the
LinkedList.java file. The LinkedList will be tested using strings only.
Specifically, the following methods must be implemented in the LinkedList class:
(You should utilize listIterator() method already defined in the LinkedList class to obtain its
LinkedListIterator object, and use the methods in the LinkedListIterator class to traverse from
the first element to the last element of the linked list to define the following methods.)
1.
public String toString()
The toString method should concatenate strings in the linked list, and return a string of the
following format:
{ Apple Banana Melon Orange }
Thus it starts with \"{\" and ends with \"}\", and there is a space between strings and \"{\" or
\"}\". If the list is empty, it returns \"{ }\" with a space in between.
2.
public boolean isEmpty()
The isEmpty method returns true of the linked list is empty, false otherwise.
3.
public void addElement(Object element)
The addElement adds the parameter element at the parameter in the linked list in alphabetical
order. For instance, if the linked list contains {Apple, Banana, Grape}, and a user tries to add
\"Carrot\", then it should be added as:
{Apple, Banana, Carrot, Grape}.
4.
public Object removeElement(int index)
The removeElement removes the string (Object) at the parameter index and returns it. Note that
this index starts with 0 just like array indices. For instance, if the linked list contains {Apple,
Banana, Carrot, Grape} and the parameter index is 3, then \"Grape\" should be remove. If the
parameter index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
5.
public Object getElement(int index)
The getElement searches the string (Object) at the parameter index and returns it. Note that this
index starts with 0 just like array indices. For instance, if the linked list contains {Apple, Banana,
Carrot, Grape} and the parameter index is 3, then \"Grape\" will be returned. If the parameter
index is larger or smaller than the existing indices, it should throw an object of the
IndexOutOfBoundsException class (and the content of the linked list should remain unchanged).
6.
public void searchAndReplace(Object oldString, Object newString)
The searchAndReplace method searches all occurrences of the first parameter string (object) in
the list, and replaces them with the second parameter string (object). If the parameter string does
not exist in the linked list, then the linked list content will not change.
7.
public int indexOfLast(Object searchString)
The indexOfLast searches the parameter string (object) with the largest index, and returns its
index. If the parameter string does not exist in the linked list, then it should return -1.
For i.
File LinkedList.java Defines a doubly-l.pdf
File: LinkedList.java
/**
* Defines a doubly-linked list class
*/
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;
/**** CONSTRUCTORS ****/
/**
* Instantiates a new LinkedList with default values
* @postcondition
*/
public LinkedList() {
}
/**
* Converts the given array into a LinkedList
* @param array the array of values to insert into this LinkedList
* @postcondition
*/
public LinkedList(T[] array) {
}
/**
* Instantiates a new LinkedList by copying another List
* @param original the LinkedList to copy
* @postcondition a new List object, which is an identical,
* but separate, copy of the LinkedList original
*/
public LinkedList(LinkedList original) {
}
/**** ACCESSORS ****/
/**
* Returns the value stored in the first node
* @precondition
* @return the value stored at node first
* @throws NoSuchElementException
*/
public T getFirst() throws NoSuchElementException {
return null;
}
/**
* Returns the value stored in the last node
* @precondition
* @return the value stored in the node last
* @throws NoSuchElementException
*/
public T getLast() throws NoSuchElementException {
return null;
}
/**
* Returns the data stored in the iterator node
* @precondition
* @return the data stored in the iterator node
* @throw NullPointerException
*/
public T getIterator() throws NullPointerException {
return null;
}
/**
* Returns the current length of the LinkedList
* @return the length of the LinkedList from 0 to n
*/
public int getLength() {
return -1;
}
/**
* Returns whether the LinkedList is currently empty
* @return whether the LinkedList is empty
*/
public boolean isEmpty() {
return false;
}
/**
* Returns whether the iterator is offEnd, i.e. null
* @return whether the iterator is null
*/
public boolean offEnd() {
return false;
}
/**** MUTATORS ****/
/**
* Creates a new first element
* @param data the data to insert at the front of the LinkedList
* @postcondition
*/
public void addFirst(T data) {
return;
}
/**
* Creates a new last element
* @param data the data to insert at the end of the LinkedList
* @postcondition
*/
public void addLast(T data) {
return;
}
/**
* Inserts a new element after the iterator
* @param data the data to insert
* @precondition
* @throws NullPointerException
*/
public void addIterator(T data) throws NullPointerException{
return;
}
/**
* removes the element at the front of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeFirst() throws NoSuchElementException {
return;
}
/**
* removes the element at the end of the LinkedList
* @precondition
* @postcondition
* @throws NoSuchElementException
*/
public void removeLast() throws NoSuchElementException {
return;
}
/**
* removes the element referenced by the iterator
* @precondition
* @pos.
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
Please help solve this in C++ So the program is working fin.pdf
Please help solve this in C++. So the program is working fine but when submitting it, it gives me a
code -11, and I believe the problem is that after inserting the numbers it removes them one by one
until the last in the list, and when it tries to remove the last number in the list that is when it
counters the problem. Below is the full code but you just need to change something in the
SortedNumberList.h file under the bool remove function.
4.18 LAB: Sorted number list implementation with linked lists Step 1: Inspect the Node.h file
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 2347.2586, 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: 2335.547.2586Step 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 77154263.5 then output is: List after inserting 77 : 77 List after
inserting 15 : 1577 List after inserting -42 : -421577 List after inserting 63.5: -421563.577 Try
various program inputs, ensuring that each outputs a sorted list. Step 4: Implement the Remove()
member function Implement the SortedNumberList class's Remove(0 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
841972841961 then output is: List after inserting 84: 84 List after inserting 72 : 7284 List after
inserting 19: 1972 84 List after inserting 61: 1961 : 72 8 List after removing 19: 6172 84 List after
removing 84: 6172Current file: main.cpp - // Insert each value and show the sorted List's contents
after each insertion sortedNumberList list; for (auto term : terms) { doubl.
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.
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.
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.
import java.util.LinkedList; import java.util.Random; import jav.pdf
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
/**
* author
*
*/
public class LinkedListTest {
/**
* param args
*/
public static void main(String[] args) {
int M, N, Lower, Upper;
Scanner scanner = null;
try {
LinkedList list1 = new LinkedList();
LinkedList list2 = new LinkedList();
LinkedList list3 = new LinkedList();
Random random = new Random();
scanner = new Scanner(System.in);
System.out.print(\"Enter the Lower and Upper bounds:\");
Lower = scanner.nextInt();
Upper = scanner.nextInt();
System.out.print(\"Enter the N value to Insert list1:\");
N = scanner.nextInt();
System.out.print(\"Enter the M value to Insert list2:\");
M = scanner.nextInt();
for (int i = 1; i <= N; i++) {
list1.add(random.nextInt((Upper - Lower) + 1) + Lower);
}
for (int i = 1; i <= M; i++) {
list2.add(random.nextInt((Upper - Lower) + 1) + Lower);
}
System.out.println(\"list1: \" + list1);
System.out.println(\"list2: \" + list2);
System.out.println(\"Minimum elelment in list1 :\" + getMin(list1));
System.out.println(\"Minimum elelment in list2 :\" + getMin(list2));
System.out
.println(\"Count Divisibles by 3 and 5 elelment in list1 :\"
+ countDivisibles(list1));
System.out
.println(\"Count Divisibles by 3 and 5 elelment in list2 :\"
+ countDivisibles(list2));
System.out.println(\"Common Elements From list1 and list2:\"
+ getCommonList(list1, list2));
} catch (Exception e) {
// TODO: handle exception
}
}
/**
* param list
* return
*/
public static int getMin(LinkedList list) {
int min = list.get(0);
for (Integer integer : list) {
if (min > integer) {
min = integer;
}
}
return min;
}
/**
* param list
* return
*/
public static int countDivisibles(LinkedList list) {
int count = 0;
for (Integer integer : list) {
if (integer % 3 == 0 && integer % 5 == 0) {
count++;
}
}
return count;
}
/**
* param list1
* param list2
* return
*/
public static LinkedList getCommonList(LinkedList list1,
LinkedList list2) {
LinkedList list = new LinkedList();
LinkedList listCommon = new LinkedList();
list = (list1.size() > list2.size()) ? list1 : list2;
for (int i = 0; i < list.size(); i++) {
Integer number = list.get(i);
if (list2.contains(number) && list1.contains(number)) {
listCommon.add(number);
}
}
return listCommon;
}
}
OUTPUT:
Enter the Lower and Upper bounds:1 10
Enter the N value to Insert list1:10
Enter the M value to Insert list2:20
list1: [1, 4, 4, 6, 9, 4, 9, 5, 8, 5]
list2: [5, 10, 10, 2, 1, 10, 8, 8, 8, 2, 6, 10, 6, 2, 5, 9, 6, 9, 6, 2]
Minimum elelment in list1 :1
Minimum elelment in list2 :1
Count Divisibles by 3 and 5 elelment in list1 :0
Count Divisibles by 3 and 5 elelment in list2 :0
Common Elements From list1 and list2:[5, 1, 8, 8, 8, 6, 6, 5, 9, 6, 9, 6]
Solution
import java.util.LinkedList;
import java.util.Random;
import java.util.Scanner;
/**
* author
*
*/
public class LinkedListTest {
/**
* param args
*/
public static void main(String[] args) {
int M, N, Lower, Upper;
Scanner scanner = null;
try {
LinkedList list1 = new LinkedList();
L.
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.
Select three methods in the ObjectList class to work through algori.pdf
Select three methods in the ObjectList class to work through algorithmically. Describe any
special cases or boundary conditions that might exist for each of the three methods selected. Be
sure to draw pictures as you work through the methods. Remember that you cannot work on
linked lists without drawing pictures. The homework will not be accepted without submitting the
pictures! Write a Java method with the signature: public objectList intersect (objectList list1,
objectList list2) that accepts two unordered linear linked lists and returns a third linear linked list
whose nodes contains the intersection of the two original linear linked lists. Note that the
intersection of two lists is a new list containing the elements that the two lists have in common,
without modifying the two original lists. Describe any boundary conditions that might exist.
Solution
Node.java
//Defines each node of a linked list
public class Node{
int data;
Node next;
Node(int d)
{
data = d;
next = null;
}
}
ObjectList.java
public class ObjectList{
public Node head;
/* Utility function to print list */
public void printList()
{
Node temp = head;
while(temp != null)
{
System.out.print(temp.data+\" \");
temp = temp.next;
}
System.out.println();
}
/* Inserts a node at start of linked list */
public void push(int new_data)
{
/* 1 & 2: Allocate the Node &
Put in the data*/
Node new_node = new Node(new_data);
/* 3. Make next of new Node as head */
new_node.next = head;
/* 4. Move the head to point to new Node */
head = new_node;
}
/* A utilty function that returns true if data is present
in linked list else return false */
public boolean isPresent (int data){
Node t = this.head;
while (t != null)
{
if (t.data == data)
return true;
t = t.next;
}
return false;
}
}
Intersection.java
//Implements the intersection method.
class Intersection{
static public ObjectList intersect(ObjectList list1, ObjectList list2){
ObjectList result = new ObjectList();
//Node t1 = head1;
Node t1 = list1.head;
Node t2 = list2.head;
// Traverse list1 and search each element of it in list2.
// If the element is present in list 2, then insert the
// element to result
while (t1 != null){
if (list2.isPresent(t1.data))
result.push(t1.data);
t1 = t1.next;
}
return result;
}
/* Driver program to test above functions */
public static void main(String args[]){
ObjectList llist1 = new ObjectList();
ObjectList llist2 = new ObjectList();
ObjectList unin = new ObjectList();
ObjectList intersecn = new ObjectList();
/*create a linked lits 10->15->5->20 */
llist1.push(20);
llist1.push(4);
llist1.push(15);
llist1.push(10);
/*create a linked lits 8->4->2->10 */
llist2.push(10);
llist2.push(2);
llist2.push(4);
llist2.push(8);
intersecn = intersect(llist1, llist2);
intersecn.printList();
}
}.
Similar to Write a function to merge two doubly linked lists. The input lists ha.pdf (20)
STAGE 2 The Methods 65 points Implement all the methods t.pdf
STAGE 2 The Methods 65 points Implement all the methods t.pdf
The LinkedList1 class implements a Linked list. class.pdf
The LinkedList1 class implements a Linked list. class.pdf
C++ problemPart 1 Recursive Print (40 pts)Please write the recu.pdf
C++ problemPart 1 Recursive Print (40 pts)Please write the recu.pdf
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
Class DiagramIn the Assignment #10, you are given three files Ass.pdf
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop Because I believe that it is making a.pdf
Please help solve this in C++ So the program is working fin.pdf
Please help solve this in C++ So the program is working fin.pdf
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.pdf
C++ Doubly-Linked ListsThe goal of the exercise is to implement a.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
import java.util.LinkedList; import java.util.Random; import jav.pdf
import java.util.LinkedList; import java.util.Random; import jav.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
Select three methods in the ObjectList class to work through algori.pdf
Select three methods in the ObjectList class to work through algori.pdf
More from info706022
Many biologists will talk about the group known as Ungulates, or hoo.pdf
Many biologists will talk about the group known as Ungulates, or hoofed mammals. This group
includes species as diverse as pigs (Sus), elk (Cervus), cows (Bos), hippos (Hippopotamus),
extinct species (e.g., Elomeryx and Archaeotherium), and even rhinos and horses (Equus). Based
upon the tree above and assuming this tree is correct, is this group (Ungulates) monophyletic?A.
Yes, because all of these species share the synapomorphy of hooves
Solution
b. Yes, because all of these species share a most recent common ancestor
All the members of the group of interest are more closely related to each other than they are to
the outgroup. Hence, the outgroup stems from the base of the tree. An outgroup can give you a
sense of where on the bigger tree of life the main group of organisms falls. It is also useful when
constructing evolutionary trees..
Match the function with the appropriate organelle in the column at ri.pdf
Match the function with the appropriate organelle in the column at right. Endoplasmic
reticulum Smooth endoplasmic reticulum Rough endoplasmic reticulum Golgi complex
Transport vesicles Secretory granules Endosome Lysosome Mitochondrion Chloroplast
Plasma membrane Nucleus Location of most of the cell\'s DNA site of fuel oxidation
Separates the inside of the cell from the outside Carries important biochemical into the cell
Membrane with ribosomes attached Site of photosynthesis Contains digestive enzymes
Destined for fusion with the plasma membrane 9 Common form of cytoplasmic membrane Site
of carbohydrate addition to proteins Processes exogenous chemicals Facilitates communication
between the rough endoplasmic reticulum and the Golgi complex
Solution
Please find the correct matches with reasons in parenthesis:
a. Endoplasmic reticulum : 9 (the endoplasmic reticulum is normally found concentrated near the
nucleus and is considered as a physical extension of nuclear membrane only)
b. smooth endoplasmic reticulum: 10 (smooth ER represents the site for protein modification by
glycosylation)
c. rough endoplasmic reticulum: 5 (this is the site for protein synthesis)
d. golgi complex: 12 (the proteins released for rough ER are transported to smooth ER for post
translational modification such as glycosylation via the golgi complex only)
e. transport vesicles: 4 (the transport vesciles pinch off the golgi complex for tranversing the
material from one part of cell to the other)
f. Secretory granules: 8 (secretory granules are released from one cell for extracellular transport
which ultimately fuse with plasma membrane of other cell for inlet of the materials)
g. endosomes:11(endosome is the first vesicle which ingest any foreign material and processes it)
h. lysosomes: 7 (this contains hydrolyzing enzymes which help in digestion)
i. mitochondria: 2 (known as energy house of the cell by oxidative phosphorylation)
j. chloroplast: 6 (found only in green plants and lower organisms, chloroplast is the site of
photosynthesis)
k. plasma membrane: 3 (it represents the boundary of the periphery of a cell for discrimination
between inside and outside)
l. nucleus: 1 (this contains the genetic material i.e. DNA of the cell).
It costs $16 to travel in a specific zone in paris. Now suppose thei.pdf
It costs $16 to travel in a specific zone in paris. Now suppose their is an $8 fee applied to enter
the zone to travel in it (no fee to leave it). It normally takes 40 minutes to travel in the zone, but
the time falls to 30 minutes. what is now the total cost for travel in the zone with these changes?
1) $5
2) $8
3) $10
4) $12
5) $20
Solution
2) $8
New entry fee..
Let X and Y be two random variables whose joint probability density .pdf
Let X and Y be two random variables whose joint probability density function is given by
f(x,y)=1/2, x>0, y>0, x+y<2. and o elsewhere.
Let U=y-x (note that U could be positive or negative).
a) find the distibution function of U.
b) using the result in (a), or otherwise, find the probability density function of U.
Solution.
Identify whether the Fed should continue its current pace of securit.pdf
Identify whether the Fed should continue its current pace of security purchases, and indicate
what “forward guidance” the Fed should issue now and why? Be specific in answering the
question. Forward guidance is the specific language the Fed uses to indicate the direction and
extent of their future policy action. (Give Citations)
Solution
It is a tool by which one keep promise to maintain the interest rate low by central bank by its
monetary power. In the supply of liberalization era supply is the sole determinator. Hence,
monetary policy is useful. LM curve to some extent is not exogenous now. It has been replaced
by Taylor\'s curve. Hence, it is good to raise investment. But how much this parity goes with FDI
it depends. If it is only the matter of domestic investment then, it is a proper tool..
If 2 and z are incompletely dominant, how many different phenotypes a.pdf
If 2 and z are incompletely dominant, how many different phenotypes are predicted in the
following if two heterozygous parents are crossed? Select one: a. 3 b. 4 c. 1 d. 2
Solution
Answer: a. 3
Explanation:
Due ot incomplete dominance, three phenotypes are produced that are represented by three
genotypes.
Zz x Zz
ZZ- Phenotype
Zz-Phenotype
zz-phenotypeZzZZZZzzZzzz.
How are criminals maximizing their total utilitySolutionThe o.pdf
How are criminals maximizing their total utility?
Solution
The optimization function of criminals is like this:
Maximize Utility = U(Wealth accumulated from crimes), Subject to
\"Freedom\" Constraint = Minimum conviction
That is, they maximize utility by accumulating as much wealth they can from committing crimes,
subject to the constraint that they need to spend as less time in prisons (by avoiding being caught,
convicted and sentenced), since the more time they spend in prisons, the less they get time to
commit further crimes and gather wealth from such activities..
How do I change this javascript code so that the new page opens up b.pdf
How do I change this javascript code so that the new page opens up blue?
function showWin() {
myWindow = window.open(\"\",\"width=2000,height=2000\"); //can\'t get this page to open up
blue
myWindow.document.write(page);
}
Solution
If we have a HTML like below:
// showWin() is used to open a new window on click of the button \"Show\"
So the javascript function goes like:.
Help with my biostats Homework. Please show all work!! Mendel develo.pdf
Help with my biostats Homework. Please show all work!! Mendel developed his theory of
genetics by observing large numbers of offspring from particular parents during plant breeding
experiments. However, appropriate statistical methods for a rigorous analysis of such genetic
data were only invented about 50 years later, so Mendel basically said \"The data seem to agree
with Illy theory.\" Today, we can analyze Mendel\'s data statistically to see if he was right.
According to Mendel\'s theory, if pea plants heterozygous for the two traits of seed color and
seed texture are crossed, offspring will be produced with phenotypes in the following
proportions: Here are the actual data Mendel collected from an experiment crossing two such
parents: Use an appropriate statistical analysis to determine whether these data agree with
Mendel\'s theory. State the conclusion of your analysis clearly.
Solution
We use Goodness of Fit Test to do it.
The test hypothesis:
Ho: these data agree with Mendel\'s theory (i.e. null hypothesis)
Ha: these data do not agree with Mendel\'s theory (i.e. alternative hypothesis)observedexpectedO
- E(O - E).
genetics q If the offspring of a dihydric testcross are roughly 50 .pdf
genetics q If the offspring of a dihydric testcross are roughly 50% parental type and 50%
recombinant, we can conclude that... these genes are likely on different chromosomes. these
genes are linked. these genes are likely on the same chromosome.
Solution
In a dihybrid test cross offspring will be 50% recombinant and 50% parental type , which
indicates that these genes are likely on different chromosomes ..
for fiscal year 2006, the national debt of a country was approximate.pdf
for fiscal year 2006, the national debt of a country was approximately
(8.502 × 1018)
dollars. At that time, the number of citizens between the ages of 18 and 65 was known to be
(1.5 × 1012).
If the national debt of this country were divided evenly among these citizens, about how much
debt would be assigned to each individual? (Enter your answer in standard form, rounded to two
decimal places.)
$ per person
Solution
national debt of country=8.502*1018
number of citizens between age 18 and 65=1.5*1012
debt assigned to each individual = national debt of country/number of citizens between age 18
and 65
=(8.502*1018)/(1.5*1012) =5.702 dollars/person.
Explain why Linux makes system performance monitoring available to t.pdf
Explain why Linux makes system performance monitoring available to the user. Describe how
users can use this information to their advantage.
Solution
It’s really very tough job for every System or Network administrator to monitor and debug Linux
System Performance problems every day. After being a Linux Administrator for 5 years in IT
industry, I came to know that how hard is to monitor and keep systems up and running. For this
reason, we’ve compiled the list of Top 20 frequently used command line monitoring tools that
might be useful for every Linux/Unix System Administrator. These commands are available
under all flavors of Linux and can be useful to monitor and find the actual causes of performance
problem. This list of commands shown here are very enough for you to pick the one that is
suitable for your monitoring scenario.
There are several advantages to continuously monitoring system performance.
Continuous system performance monitoring can do the following:
Successful monitoring involves the following:.
Discuss the relationships between competitive avantage, istinctive c.pdf
Discuss the relationships between competitive avantage, istinctive compentencies, resources,an
capabilities.
Solution
Resources
The activities and processes of the organization utilize certain assets. These assets are called
resources. These resources can be created within the organization. They form the internal
resources. Such generated resources are organization-specific. Otherwise they could be obtained
externally from the suppliers available in the resource markets. They form the external resources.
The externally obtained resources are organization-addressable. In addition resources can be
categorised as specific or non-specific. Those resources which can only be used for extremely
specialized intentions and are significant to the organization in adding value to goods and
services are called specific resources.
Resources
Resources of the firm can include all assets, capabilities, organizational processes, firm
attributes, information and knowledge. In short resources can be considered as inputs that
facilitate the organization to perform its activities.
All resources that an organization has may not have strategic relevance. Only certain resources
are capable of being an input to a value creating strategy which put the organization in a position
of competitive advantage. An organization’s resource should have four attributes to provide the
potential for competitive advantage. These form the VRIN characteristics.
The VRIN characteristics
The important features for a resource to be strategically important are as below
The VRIN characteristics mentioned above are individually necessary for the resources to be
valuable.
Non-specific resources are less specific and are less significant in adding value. Also resources
can be broadly classified as tangible and intangible. The physical assets that an organization
possesses are called tangible resources. The physical resources, human resources and final
resources come under this category.
The intellectual resources, technological resources and the organizational reputation together
form the intangible resources. The patents and copyrights of the organization are typical
examples of intellectual resources. The innovation capacity and innovation speed are examples
of technological resources. Reputation is basically good-will that the organization has acquired
among the customers. It is a critical resource of an organization.
Competencies
An organization should posses some characteristics in order to have the ability to compete with
other organizations in the market place. These characteristics form the competencies of the
organization. For any organization to survive in an industry competencies are must. At the same
time competencies cannot be useful to an organization when they stand alone. It is when they
combine together in the right combination that they help the organization to attain competitive
advantage. For instance consider an information technology organization. For this to compete in
t.
Determine the intervals of the domain over which each function is.pdf
Determine the intervals of the domain over which each function is continuous. See
Solution
we would see for any breaks in the graph
11. contious over the entire domain ( -inf , inf)
12 contious over the entire domain ( -inf , inf)
13 continous over the domain [3, inf)
14 continous over the domain (-inf , -1]
15 discontinous at x = 3
So, continous over the interval ( -inf , 3) U( 3, inf)
16 discontinous at x = 1
So, continous over the interval ( -inf , 1) U( 1, inf).
A storage reservoir contains 200 kg of a liquid that has a specific .pdf
A storage reservoir contains 200 kg of a liquid that has a specific gravity of 1.5. What is the
volume of the storage reservoir?
Solution
>> As, Specific density =1.5 = Density of Substance/Density of Water = Density/1000
=> Density of Substance = 1500 Kg/m3
>> As, m = mass of liquid = 200 kg
As, Mass = Volume*Density
=> Volume = 200/1500 = 0.1333 m3
=> Volume of Storage Reservoir= 0.1333 m3. ...... ANSWER......
4. Define modal split model transportation demand . central vision .pdf
4. Define: modal split model transportation demand . central vision
Solution
a) It is used to determine the number of trips on different modes between different pairs of nodes.
b) It is the demand for one good or service in one stream occurring as a result of demand from
another.
c) When our eye focussing the straight path, and the vision is clear and sharp where we can drive
comfortably. Such a vision is called central vision..
Comparison of dysplasia and hyperplasiaSolutionDysplasia Dys.pdf
Comparison of dysplasia and hyperplasia?
Solution
Dysplasia: Dysplasia is a pre cancer, it is a term used in pathology to refer to an abnormality in
maturation of cells within a tissue, refers to an abnormal and potentially reversible process where
there is disordered growth and maturation of cells and the tissues and organs which they make
up.. This generally consists of an expansion of immature cells, with a corresponding decrease in
the number and location of mature cells. Dysplasia is often indicative of an early neoplastic
process. The term dysplasia is typically used when the cellular abnormality is restricted to the
originating tissue, as. For example, Myelodysplastic syndrome, or dysplasia of blood-forming
cells, show increased numbers of immature cells in the bone marrow, and a decrease in mature,
functional cells in the blood. Dysplasia can still be reversed if the factors that are responsible for
causing it are eliminated.
Hyperplasia: refer to the proliferation of cells within an organ or tissue beyond that which is
ordinarily seen. Hyperplasia may result in the gross enlargement of an organ, the formation of a
benign tumor, or may be visible only under a microscope, it is a general term for an increase in
the number of the cells of an organ or tissue causing it to increase in size. It may be due to any
number of causes such as increased demand, chronic inflammatory response, hormonal
dysfunctions, or neoplasia. Hyperplasia is considered to be a physiological response to a specific
stimulus, and the cells of a hyperplastic growth remain subject to normal regulatory control
mechanisms..
“Web 2.0 is simply a new label for a range of web technologies and c.pdf
“Web 2.0 is simply a new label for a range of web technologies and consumer behaviours that
have existed since the 1990s. They don’t represent a ‘paradigm shift.’” Is this statement true or
false? Be sure to support your answer.
Solution
Web 2.0 is simply a new label for a range of web technologies and consumer behaviours that
have existed since the 1990s. They don’t represent a ‘paradigm shift - FALSE.
Explanation :-
Web 2.0 is an evolution of technologies and communications approaches which have grown in
Importance since 2004-2005..
You are required, but not limited, to turn in the following source f.pdf
You are required, but not limited, to turn in the following source files:
Assignment8.java(More code need to be added)
Athlete.java(given by the instructor, it needs to be modified for this assignment)
AthleteNameComparator.java
MedalCountComparator.java
Sorts.java
AthleteManagement.java
Class Diagram:
Athlete
The Athlete class implements the \"Serializable\" interface so that its object can be stored. (The
Serializable interface is defined in the \"java.io\" package.)
AthleteNameComparator
The AthleteNameComparator class implements the \"Comparator\" interface (The Comparator
interface is in \"java.util\" package.). It needs to define the following method that was an
inherited abstract method from Comparator interface:
public int compare(Object first, Object second)
(Note that you can also define:
public int compare(Athlete first, Athlete second)
instead by making the class implements Comparator.
If the first argument object has a last name lexicographically less than that of the second
argument, an int less than zero is returned. If the first argument object has a last name
lexicographically larger than that of the second argument, an int greater than zero is returned. If
their last names are same, then their first names should be compared. If they have same first and
last names, then 0 should be returned.
MedalCountComparator
The MedalCountComparator class implements the \"Comparator\" interface (The Comparator
interface is in \"java.util\" package.). It needs to define the following method that was an
inherited abstract method from Comparator interface:
public int compare(Object first, Object second)
(Note that you can also define:
public int compare(Athlete first, Athlete second)
instead by making the class implements Comparator.
If the first argument object has a larger gold medal count than that of the second argument, an int
less than zero is returned. If the first argument object has a smaller gold medal count than that of
the second argument, an int greater than zero is returned. If both gold medal counts are same,
then their silver medal counts should be compared. If both gold medal counts are same and also
silver medal counts are same, then their bronze counts should be compared. If all of gold, silver,
and bronze medal counts are same, then 0 should be returned.
Sorts
The Sorts class is a utility class that will be used to sort a list of Athlete objects. Sorting
algorithms are described in the algorithm note posted under Notes section of the course web site.
These algorithms sort numbers stored in an array. It is your job to modify it to sort objects stored
in an array list (or a vector).
The Sorts class object will never be instantiated. It must have the following methods:
public static void sort(ArrayList objects, Comparator)
Your sort method utilizes the compare method of the parameter Comparator object to sort. You
can use one of Selection sort or Insertion Sort.
AthleteManagement
The AthleteManagement class has a list of Ath.
Why just one sperm can enter the secondary oocyteWhy just one s.pdf
Why just one sperm can enter the secondary oocyte?
Why just one sperm can enter the secondary oocyte?
Solution
Sperm fuses with the egg and fertilizes it. Normally only one sperm fuses with an egg and if
more than one sperm fuses this is called polyspermy.Development of the zygote usually stops if
polyspermy occurs and in most cases, the egg cell blocks polyspermy.
In polyspermy,multipolar or extra miotic spindles are formed which stop the fertilized egg
development by causing faulty segregation of chromosomes during cell division. The egg plasma
prevent polyspermy by depolarising the egg plasma membranes after the first sperm cell fuses
with the egg cell. Thus preventing further sperm from fusing, this is the primary block to
polyspermy.
The secondary block to polyspermy is by the cortical reaction within the egg cell . the fusion of
the sperm with an egg plasma membrane causes an increase in cytosolic calcium within the egg.
The calcium activates the egg to begin development, which initiates a cortical reaction that
releases various enzymes that change the structure of the outside layer of the egg. This hardens
the zona pellucida which prevents another sperm from binding to it..
More from info706022 (20)
Many biologists will talk about the group known as Ungulates, or hoo.pdf
Many biologists will talk about the group known as Ungulates, or hoo.pdf
Match the function with the appropriate organelle in the column at ri.pdf
Match the function with the appropriate organelle in the column at ri.pdf
It costs $16 to travel in a specific zone in paris. Now suppose thei.pdf
It costs $16 to travel in a specific zone in paris. Now suppose thei.pdf
Let X and Y be two random variables whose joint probability density .pdf
Let X and Y be two random variables whose joint probability density .pdf
Identify whether the Fed should continue its current pace of securit.pdf
Identify whether the Fed should continue its current pace of securit.pdf
If 2 and z are incompletely dominant, how many different phenotypes a.pdf
If 2 and z are incompletely dominant, how many different phenotypes a.pdf
How are criminals maximizing their total utilitySolutionThe o.pdf
How are criminals maximizing their total utilitySolutionThe o.pdf
How do I change this javascript code so that the new page opens up b.pdf
How do I change this javascript code so that the new page opens up b.pdf
Help with my biostats Homework. Please show all work!! Mendel develo.pdf
Help with my biostats Homework. Please show all work!! Mendel develo.pdf
genetics q If the offspring of a dihydric testcross are roughly 50 .pdf
genetics q If the offspring of a dihydric testcross are roughly 50 .pdf
for fiscal year 2006, the national debt of a country was approximate.pdf
for fiscal year 2006, the national debt of a country was approximate.pdf
Explain why Linux makes system performance monitoring available to t.pdf
Explain why Linux makes system performance monitoring available to t.pdf
Discuss the relationships between competitive avantage, istinctive c.pdf
Discuss the relationships between competitive avantage, istinctive c.pdf
Determine the intervals of the domain over which each function is.pdf
Determine the intervals of the domain over which each function is.pdf
A storage reservoir contains 200 kg of a liquid that has a specific .pdf
A storage reservoir contains 200 kg of a liquid that has a specific .pdf
4. Define modal split model transportation demand . central vision .pdf
4. Define modal split model transportation demand . central vision .pdf
Comparison of dysplasia and hyperplasiaSolutionDysplasia Dys.pdf
Comparison of dysplasia and hyperplasiaSolutionDysplasia Dys.pdf
“Web 2.0 is simply a new label for a range of web technologies and c.pdf
“Web 2.0 is simply a new label for a range of web technologies and c.pdf
You are required, but not limited, to turn in the following source f.pdf
You are required, but not limited, to turn in the following source f.pdf
Why just one sperm can enter the secondary oocyteWhy just one s.pdf
Why just one sperm can enter the secondary oocyteWhy just one s.pdf
Recently uploaded
GIÁO ÁN DẠY THÊM (KẾ HOẠCH BÀI BUỔI 2) - TIẾNG ANH 8 GLOBAL SUCCESS (2 CỘT) N...
GIÁO ÁN DẠY THÊM (KẾ HOẠCH BÀI BUỔI 2) - TIẾNG ANH 8 GLOBAL SUCCESS (2 CỘT) N...Nguyen Thanh Tu Collection
https://app.box.com/s/4hfk1xwgxnova7f4dm37birdzflj806wTESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH ANSWERS.
special B.ed 2nd year old paper_20240531.pdf
Instagram:-
https://instagram.com/special_education_needs_01?igshid=YmMyMTA2M2Y=
WhatsApp:-
https://chat.whatsapp.com/JVakNIYlSV94x7bwunO3Dc
YouTube:-
https://youtube.com/@special_education_needs
Teligram :- https://t.me/special_education_needs
Slide Shere :-
https://www.slideshare.net/shabnambano20?utm_campaign=profiletracking&utm_medium=sssite&utm_source=ssslideview
ESC Beyond Borders _From EU to You_ InfoPack general.pdf
ESC Beyond Borders _From EU to You_ InfoPack general.pdfFundacja Rozwoju Społeczeństwa Przedsiębiorczego
Wolontariat grupowyCLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
Class 11 CBSE Business Studies Project ( AIDS TO TRADE - INSURANCE)
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.
Ethnobotany and Ethnopharmacology ......
Ethnobotany and Ethnopharmacology:
Ethnobotany in herbal drug evaluation,
Impact of Ethnobotany in traditional medicine,
New development in herbals,
Bio-prospecting tools for drug discovery,
Role of Ethnopharmacology in drug evaluation,
Reverse Pharmacology.
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
for studentd in cabridge board
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.
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
Introduction to Quality Improvement Essentials
This is a presentation by Dada Robert in a Your Skill Boost masterclass organised by the Excellence Foundation for South Sudan (EFSS) on Saturday, the 25th and Sunday, the 26th of May 2024.
He discussed the concept of quality improvement, emphasizing its applicability to various aspects of life, including personal, project, and program improvements. He defined quality as doing the right thing at the right time in the right way to achieve the best possible results and discussed the concept of the "gap" between what we know and what we do, and how this gap represents the areas we need to improve. He explained the scientific approach to quality improvement, which involves systematic performance analysis, testing and learning, and implementing change ideas. He also highlighted the importance of client focus and a team approach to quality improvement.
2024.06.01 Introducing a competency framework for languag learning materials ...
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
How to Break the cycle of negative Thoughts
We all have good and bad thoughts from time to time and situation to situation. We are bombarded daily with spiraling thoughts(both negative and positive) creating all-consuming feel , making us difficult to manage with associated suffering. Good thoughts are like our Mob Signal (Positive thought) amidst noise(negative thought) in the atmosphere. Negative thoughts like noise outweigh positive thoughts. These thoughts often create unwanted confusion, trouble, stress and frustration in our mind as well as chaos in our physical world. Negative thoughts are also known as “distorted thinking”.
The Roman Empire A Historical Colossus.pdf
The Roman Empire, a vast and enduring power, stands as one of history's most remarkable civilizations, leaving an indelible imprint on the world. It emerged from the Roman Republic, transitioning into an imperial powerhouse under the leadership of Augustus Caesar in 27 BCE. This transformation marked the beginning of an era defined by unprecedented territorial expansion, architectural marvels, and profound cultural influence.
The empire's roots lie in the city of Rome, founded, according to legend, by Romulus in 753 BCE. Over centuries, Rome evolved from a small settlement to a formidable republic, characterized by a complex political system with elected officials and checks on power. However, internal strife, class conflicts, and military ambitions paved the way for the end of the Republic. Julius Caesar’s dictatorship and subsequent assassination in 44 BCE created a power vacuum, leading to a civil war. Octavian, later Augustus, emerged victorious, heralding the Roman Empire’s birth.
Under Augustus, the empire experienced the Pax Romana, a 200-year period of relative peace and stability. Augustus reformed the military, established efficient administrative systems, and initiated grand construction projects. The empire's borders expanded, encompassing territories from Britain to Egypt and from Spain to the Euphrates. Roman legions, renowned for their discipline and engineering prowess, secured and maintained these vast territories, building roads, fortifications, and cities that facilitated control and integration.
The Roman Empire’s society was hierarchical, with a rigid class system. At the top were the patricians, wealthy elites who held significant political power. Below them were the plebeians, free citizens with limited political influence, and the vast numbers of slaves who formed the backbone of the economy. The family unit was central, governed by the paterfamilias, the male head who held absolute authority.
Culturally, the Romans were eclectic, absorbing and adapting elements from the civilizations they encountered, particularly the Greeks. Roman art, literature, and philosophy reflected this synthesis, creating a rich cultural tapestry. Latin, the Roman language, became the lingua franca of the Western world, influencing numerous modern languages.
Roman architecture and engineering achievements were monumental. They perfected the arch, vault, and dome, constructing enduring structures like the Colosseum, Pantheon, and aqueducts. These engineering marvels not only showcased Roman ingenuity but also served practical purposes, from public entertainment to water supply.
Recently uploaded (20)
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
GIÁO ÁN DẠY THÊM (KẾ HOẠCH BÀI BUỔI 2) - TIẾNG ANH 8 GLOBAL SUCCESS (2 CỘT) N...
GIÁO ÁN DẠY THÊM (KẾ HOẠCH BÀI BUỔI 2) - TIẾNG ANH 8 GLOBAL SUCCESS (2 CỘT) N...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
ESC Beyond Borders _From EU to You_ InfoPack general.pdf
ESC Beyond Borders _From EU to You_ InfoPack general.pdf
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
CLASS 11 CBSE B.St Project AIDS TO TRADE - INSURANCE
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
1.4 modern child centered education - mahatma gandhi-2.pptx
1.4 modern child centered education - mahatma gandhi-2.pptx
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
2024.06.01 Introducing a competency framework for languag learning materials ...
2024.06.01 Introducing a competency framework for languag learning materials ...
Write a function to merge two doubly linked lists. The input lists ha.pdf
- 1. Write a function to merge two doubly linked lists. The input lists have their elements in sorted order, from lowest to highest. The output list should also be sorted from lowest to highest. Your algorithm should run in linear time on the length of the output list. Provide an algorithm for your function Implement and show some samples of your running function Solution The algorithm for LinkedList MergeSort is as follows. The trick in this algorithm is to use a local list to store the value which is pointing to the actual list to be returned as a result of the function Step1: START Step2: GET inputs of list1 and list2 Step3: INITIALIZE mergelist STEP4: SET mylist = mergelist Step5: WHILE list1 OR list2 is EMPTY DO IF (list1 AND list2) are NOT EMPTY IF list1.value > list2.value mylist.next = list2 ELSE mylist.next = list1 ELSE IF list1 is EMPTY mylist.next = list2 ELSE mylist.next = list1 Step6: RETURN mergelist Step7: STOP Sample program for the same implemented in C++ //==================================================================== ======== // Name : DoublyLinkedList.cpp // Author : Kaju // Version : 0.1 // Copyright : This is just an example code // Description : MergeSort in C++, Ansi-style
- 2. //==================================================================== ======== /* * C++ Program to Implement Doubly Linked List */ #include #include #include /* * Node Declaration */ using namespace std; // struct declaration for node which will hold the integer data with links to previous data and next data struct node { int data; struct node *next; struct node *prev; }; /* Class Declaration */ class DoublyLinkedList { private: struct node *start; // collection of all the nodes public: void create(int value); int peek(); int delete_head(); void display(); int count(); void mergeSort(DoublyLinkedList list1, DoublyLinkedList list2); DoublyLinkedList() {
- 3. start = NULL; } }; /* * Add data into the list */ void DoublyLinkedList::create(int value) { struct node *s, *temp; temp = new(struct node); temp->data = value; temp->next = NULL; if (start == NULL) { temp->prev = NULL; start = temp; } else { s = start; while (s->next != NULL) s = s->next; s->next = temp; temp->prev = s; } } /* * Deletion of the first element from the list * store the first element in a temp node and then remove it from start. */ int DoublyLinkedList::delete_head() { struct node *tmp, *q; int value; tmp = start; if(start->next!=NULL)
- 4. { start = start->next; start->prev = NULL; } else start = NULL; value = tmp->data; free(tmp); return value; } /* * return the first element of Doubly Link List */ int DoublyLinkedList::peek() { struct node *q; if (start == NULL) { cout<<"List is empty"<data; } } /* * Display elements of Doubly Link List */ void DoublyLinkedList::display() { struct node *q; if (start == NULL) { cout<<"List is empty"<data; q = q->next; if(q != NULL) { cout<<", "; } }
- 5. cout<<"]"<next; cnt++; } return cnt; } /* * MergeSort - takes two input lists and then based on the integer data value sorts them in ascending order. * Adds each data removed from the input lists into the new list. */ void DoublyLinkedList::mergeSort(DoublyLinkedList list1, DoublyLinkedList list2) { while(list1.count() > 0 || list2.count() > 0) // Checks whether any of the list is empty { if(list1.count() > 0 && list2.count() > 0) // checks if both the lists have data { if(list1.peek() > list2.peek()) // compares the first element of both the lists create(list2.delete_head()); // if the second list has greater value then it is removed from the second list and added to the new list else create(list1.delete_head());// if the first list has greater value then it is removed from the first list and added to the new list } else if(list1.count() == 0) // incase where list one is empty and only list two has value { create(list2.delete_head()); // if the second list has value then it is removed from the second list and added to the new list } else { create(list1.delete_head()); // if the first list has value then it is removed from the first list and added to the new list } } } int main()
- 6. { DoublyLinkedList firstList; firstList.create(4); firstList.create(10); firstList.create(45); firstList.create(53); firstList.create(250); firstList.create(1020); cout<<"List 1: "; firstList.display(); DoublyLinkedList secondList; secondList.create(1); secondList.create(36); secondList.create(68); secondList.create(73); secondList.create(1019); cout<<"List 2: "; secondList.display(); DoublyLinkedList mergedList; mergedList.mergeSort(firstList, secondList); cout<<"Merged List: "; mergedList.display(); return 0; } OUTPUT: List 1: [4, 10, 45, 53, 250, 1020] List 2: [1, 36, 78, 673, 1019] Merged List: [1, 4, 10, 36, 45, 53, 78, 250, 673, 1019, 1020]