Data Structures in C++I am really new to C++, so links are really .pdf
•
0 likes•4 views
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.
Report
Share
Report
Share
Download to read offline
![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.](https://image.slidesharecdn.com/datastructuresinciamreallynewtocsolinksarereally-230710065744-36a29b31/85/Data-Structures-in-C-I-am-really-new-to-C-so-links-are-really-pdf-1-320.jpg)
Recommended
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
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.
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.
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
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.
Recommended
Program to insert in a sorted list #includestdio.h#include.pdf
* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* A utility function to create a new node */
struct node *newNode(int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
new_node->next = NULL;
return new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node = newNode(5);
sortedInsert(&head, new_node);
new_node = newNode(10);
sortedInsert(&head, new_node);
new_node = newNode(7);
sortedInsert(&head, new_node);
new_node = newNode(3);
sortedInsert(&head, new_node);
new_node = newNode(1);
sortedInsert(&head, new_node);
new_node = newNode(9);
sortedInsert(&head, new_node);
printf(\"\ Created Linked List\ \");
printList(head);
return 0;
}
public class Listnode {
//*** fields ***
private Object data;
private Listnode next;
//*** methods ***
// 2 constructors
public Listnode(Object d) {
this(d, null);
}
public Listnode(Object d, Listnode n) {
data = d;
next = n;
}
// access to fields
public Object getData() {
return data;
}
public Listnode getNext() {
return next;
}
// modify fields
public void setData(Object ob) {
data = ob;
}
public void setNext(Listnode n) {
next = n;
}
}
Thsi below program print out all the varibles in SLL
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Given a reference (pointer to pointer) to the head
of a list and an int, push a new node on the front
of the list. */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Takes head pointer of the linked list and index
as arguments and return data at index*/
int GetNth(struct node* head, int index)
{
struct node* current = head;
int .
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.
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.
in Java (ignore the last line thats hidden) Create a doubly linked l.pdf
in Java (ignore the last line thats hidden) Create a doubly linked list whose nodes contain Strings.
Your list should include the following methods: Insert a node in the list in alphabetical order
Find a node that matches a String Traverse the list forwards and print Traverse the list backwards
and print Delete a node from the list Delete/destroy the list In addition to creating the class(es)
for your linked list, you\'ll need to create a main method that thoroughly tests each function you
build to show that it works. You should do these things in
Solution
/ Java program to create , insert , traverse and delete a node from doubly linked list
class LinkedList {
static Node head = null;
class Node {
int data;
Node next, prev;
Node(int d) {
data = d;
next = prev = null;
}
}
/* Let us create the doubly linked list 10<->8<->4<->2 */
list.push(head, 2);
list.push(head, 4);
list.push(head, 8);
list.push(head, 10);
System.out.println(\"Original Linked list \");
list.printList(head);
/*Function to delete a node in a Doubly Linked List.
head_ref --> pointer to head node pointer.
del --> pointer to node to be deleted. */
void deleteNode(Node head_ref, Node del) {
/* base case */
if (head == null || del == null) {
return;
}
/* If node to be deleted is head node */
if (head == del) {
head = del.next;
}
/* Change next only if node to be deleted is NOT the last node */
if (del.next != null) {
del.next.prev = del.prev;
}
/* Change prev only if node to be deleted is NOT the first node */
if (del.prev != null) {
del.prev.next = del.next;
}
/* Finally, free the memory occupied by del*/
return;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginning of the Doubly Linked List */
void push(Node head_ref, int new_data) {
/* allocate node */
Node new_node = new Node(new_data);
/* since we are adding at the begining,
prev is always NULL */
new_node.prev = null;
/* link the old list off the new node */
new_node.next = (head);
/* change prev of head node to new node */
if ((head) != null) {
(head).prev = new_node;
}
/* move the head to point to the new node */
(head) = new_node;
}
/*Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(Node node) {
while (node != null) {
System.out.print(node.data + \" \");
node = node.next;
}
}
public static void main(String[] args) {
LinkedList list = new LinkedList();
/* delete nodes from the doubly linked list */
list.deleteNode(head, head); /*delete first node*/
list.deleteNode(head, head.next); /*delete middle node*/
list.deleteNode(head, head.next); /*delete last node*/
System.out.println(\"\");
/* Modified linked list will be NULL<-8->NULL */
System.out.println(\"Modified Linked List\");
list.printList(head);
}
}.
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 Homework Help
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
C++Write a method Node Nodereverse() which reverses a list..pdf
C++
Write a method Node *Node::reverse() which reverses a list.
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf(\"Given linked list\ \");
printList(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
getchar();
}.
Below is a depiction of a doubly-linked list implementation of the bag.docx
Below is a depiction of a doubly-linked list implementation of the bag ADT with two sentinels -one at the head and one at the tail. Strict DLink { TYPE value; strict DLink * next; struct DLink * prev;}; strict linked List { int size; struct DLink *frontSentinel; struct DLink *backSentinel;}; Write a function that at first reverses the list and then prints the values of the links in the list from front to back. Don\'t redirect to any other function. You must use assertions if necessary.
Solution
/* Program to reverse a doubly linked list */
#include <stdio.h>
#include <stdlib.h>
/* a node of the doubly linked list */
struct node
{
int data;
struct node *n;
struct node *pr;
};
/* Function to reverse a Doubly Linked List */
void reverse(struct node **head_r)
{
struct node *t = NULL;
struct node *cur = *head_r;
/* swap next and prev for all nodes of
doubly linked list */
while (cur != NULL)
{
t = cur->pr;
cur->pr = cur->n;
cur->n = t;
cur = cur->pr;
}
/* Before changing head, check for the cases like empty
list and list with only one node */
if(t != NULL )
*head_r = t->pr;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging of the Doubly Linked List */
void push(struct node** head_r, int new_data)
{
/* allocate node */
struct node* n_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
n_node->data = n_data;
/* since we are adding at the begining,
prev is always NULL */
n_node->pr = NULL;
/* link the old list off the new node */
n_node->n = (*head_r);
/* change prev of head node to new node */
if((*head_r) != NULL)
(*head_r)->pr = n_node ;
/* move the head to point to the new node */
(*head_r) = n_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Let us create a sorted linked list to test the functions
Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);
printf(\"\ Original Linked list \");
printList(head);
/* Reverse doubly linked list */
reverse(&head);
printf(\"\ Reversed Linked list \");
printList(head);
getchar();
}
.
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem: Describe an algorithm for concatenating two singly linked lists L and M, into a single
list L that contains all the nodes of L followed by all the nodes of M. Modify the
SinglyLinkedList class to contain the method:
public void concatenate(SinglyLinkedList other) { ... }
PLEASE PLEASE USE THE CODE BELOW..... THANK YOU
public class SinglyLinkedList<E> implements Cloneable {
//---------------- nested Node class ----------------
/**
* Node of a singly linked list, which stores a reference to its
* element and to the subsequent node in the list (or null if this
* is the last node).
*/
private static class Node<E> {
/** The element stored at this node */
private E element; // reference to the element stored at this node
/** A reference to the subsequent node in the list */
private Node<E> next; // reference to the subsequent node in the list
/**
* Creates a node with the given element and next node.
*
* @param e the element to be stored
* @param n reference to a node that should follow the new node
*/
public Node(E e, Node<E> n) {
element = e;
next = n;
}
// Accessor methods
/**
* Returns the element stored at the node.
* @return the element stored at the node
*/
public E getElement() { return element; }
/**
* Returns the node that follows this one (or null if no such node).
* @return the following node
*/
public Node<E> getNext() { return next; }
// Modifier methods
/**
* Sets the node's next reference to point to Node n.
* @param n the node that should follow this one
*/
public void setNext(Node<E> n) { next = n; }
} //----------- end of nested Node class -----------
// instance variables of the SinglyLinkedList
/** The head node of the list */
private Node<E> head = null; // head node of the list (or null if empty)
/** The last node of the list */
private Node<E> tail = null; // last node of the list (or null if empty)
/** Number of nodes in the list */
private int size = 0; // number of nodes in the list
/** Constructs an initially empty list. */
public SinglyLinkedList() { } // constructs an initially empty list
// access methods
/**
* Returns the number of elements in the linked list.
* @return number of elements in the linked list
*/
public int size() { return size; }
/**
* Tests whether the linked list is empty.
* @return true if the linked list is empty, false otherwise
*/
public boolean isEmpty() { return size == 0; }
/**
* Returns (but does not remove) the first element of the list
* @return element at the front of the list (or null if empty)
*/
public E first() { // returns (but does not remove) the first element
if (isEmpty()) return null;
return head.getElement();
}
/**
* Returns (but does not remove) the last element of the list.
* @return element at the end of the list (or null if empty)
*/
public E last() { // returns (but does not remove) the last element
if (isEmpty()) return null;
return tail.getElement();
}
// update methods
/**
* Adds an element to the front of the list.
* @param e the new element to add
*/
public vo.
C Exam Help
I am Gabriel C. I am a C Exam Expert at programmingexamhelp.com. I hold a PhD. in Business analyst of Information Technology, Montreal College of Information Technology, Canada. I have been helping students with their exams for the past 8 years. You can hire me to take your exam in C.
Visit programmingexamhelp.com or email support@programmingexamhelp.com. You can also call on +1 678 648 4277 for any assistance with the C Exam.
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.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
Use C++ Write a function to merge two doubly linked lists. The input.pdf
Use C++ 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
/* This is a C++ program to merge two sorted linked lists and produce a list in a
Sorted order */
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* This function is used to pull off the front node of the source and put it in destnation */
void letusMoveNode(struct node** destRef, struct node** sourceRef);
/* This is a function used for performing merging of two linked lists.It takes two lists sorted in
increasing order, and splices
their nodes together to make one big sorted list which
is returned. */
struct node* letssortlists(struct node* a, struct node* b)
{
/* Let us first have dummyone first node to hang the result on */
struct node dummyone;
/*next the tail points to the last result node */
struct node* tail = &dummyone;
/* As a result, tail->next is the place to add new nodes
to the result. */
dummyone.next = NULL;
while (1)
{
if (a == NULL)
{
/*we will check that if either list runs out, use the
other list */
tail->next = b;
break;
}
else if (b == NULL)
{
tail->next = a;
break;
}
if (a->data <= b->data)
letusMoveNode(&(tail->next), &a);
else
letusMoveNode(&(tail->next), &b);
tail = tail->next;
}
return(dummyone.next);
}
/* letusMoveNode() function is a function which takes the node from the front of the
source, and move it to the front of the dest.
Before calling letusMoveNode():
source == {1, 2, 3}
dest == {1, 2, 3}
Affter calling letusMoveNode():
source == {3, 4}
dest == {1, 2, 3, 4} */
void letusMoveNode(struct node** destReference, struct node** sourceReference)
{
/*This is the front source node */
struct node* newNode = *sourceReference;
assert(newNode != NULL);
/* now we will advance the source pointer */
*sourceReference = newNode->next;
/*next we will link the old dest off the new node */
newNode->next = *destReference;
/* Fineally we will move dest to point to the new node */
*destReference = newNode;
}
/* This IS A function which is used to insert a node at the beginning of the linked list */
void insertpush(struct node** head_reference, int new_data)
{
/* This is used to allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* now we will put in the data */
new_node->data = new_data;
/* The next step is to link the old list off the new node */
new_node->next = (*head_reference);
/*Finally we will move the head to point to the new node */
(*head_reference) = new_node;
}
/* This is a function to print nodes in a given linked list */
void printList(struct node *node)
{
while (node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/*This is the driver program to test ab.
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.
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.
Write a program that accepts an arithmetic expression of unsigned in.pdf
Write a program that accepts an arithmetic expression of unsigned integers in postfix notation
and builds the arithmetic expression tree that represents that expression. From that tree, the
corresponding fully parenthesized infix expression should be displayed and a file should be
generated that contains the three address format instructions. This topic is discussed in the week
4 reading in module 2, section II-B. The main class should create the GUI shown below:
Pressing the Construct Tree button should cause the tree to be constructed and using that tree, the
corresponding infix expression should be displayed and the three address instruction file should
be generated. The postfix expression input should not be required to have spaces between every
token. Note in the above example that 9+- are not separated by spaces. The above example
should produce the following output file containing the three address instructions:
Add R0 5 9
Sub R1 3
R0 Mul R2 2 3
Div R3 R1 R2
Inheritance should be used to define the arithmetic expression tree. At a minimum, it should
involve three classes: an abstract class for the tree nodes and two derived classes, one for
operand nodes and another for operator nodes. Other classes should be included as needed to
accomplish good object-oriented design. All instance data must be declared as private.
You may assume that the expression is syntactically correct with regard to the order of operators
and operands, but you should check for invalid tokens, such as characters that are not valid
operators or operands such as 2a, which are not valid integers. If an invalid token is detected a
RuntimeException should be thrown and caught by the main class and an appropriate error
message should be displayed. Three Adddress Generator Enter Postfix Expression 359 2 3
Construct Tree Infix Expression ((3-(5 9))/ (2* 3
Solution
#include
#include
#include
#include
#include
struct TREE //Structure to represent a tree
{
char data;
struct TREE *right,*left,*root;
};
typedef TREE tree; /* Stack Using Linked List */
struct Stack //Structure to represent Stack
{
struct TREE *data;
struct Stack *next,*head,*top; //Pointers to next node,head and top
};
typedef struct Stack node;
node *Nw; //Global Variable to represent node
void initialize(node *&n)
{
n = new node;
n -> next = n -> head = n -> top = NULL;
}
void create(node *n)
{
Nw = new node; //Create a new node
Nw -> next = NULL; //Initialize next pointer field
if(n -> head == NULL) //if first node
{
n -> head = Nw; //Initialize head
n -> top = Nw; //Update top
}
}
void push(node *n,tree *ITEM)
{
node *temp = n -> head;
if(n -> head == NULL) //if First Item is Pushed to Stack
{
create(n); //Create a Node
n -> head -> data = ITEM; //Insert Item to head of List
n -> head = Nw;
return; //Exit from Function
}
create(n); //Create a new Node
Nw -> data = ITEM; //Insert Item
while(temp -> next != NULL)
temp = temp -> next; //Go to Last Node
temp -> next = Nw; //Point New node
n -> top = Nw; //Upda.
Consider a double-linked linked list implementation with the followin.pdf
Consider a double-linked linked list implementation with the following node: struct Node {int
data; Node *prev; Node *next;} Write a copyList method that is not a member of any class.
The method should take a head pointer and return another pointer. Do not modify the input.
Solution
struct Node {
Node *prev; // previous node
Node *next; // next node
int data; // stored value
};
#include
#include \"List.h\" // std: #include
using namespace std;
typedef DataList ; // std: typedef list Data;
int main() {
Data k;
// back stuff
k.push_back(5);
k.push_back(6);
cout << k.back() << endl;
k.pop_back();
// front stuff
k.push_front(4);
k.push_front(3);
cout << k.front() << endl;
k.pop_front();
// forward iterator
Data::iterator pos;
for (pos = k.begin(); pos != k.end(); ++pos)
cout << *pos << endl;
// output and delete list
while (!k.empty()) {
cout << k.front() << endl;
k.pop_front();
}
k.push_front(5);
k.push_front(6);
// remove and erase
k.remove(5);
pos = k.begin();
k.erase(pos);
k.push_front(5);
k.push_front(6);
// copy constructor
Data l = k;
// assignment operator
Data m;
m = k;
return 0;
}
// List.h
struct Node;
classIterator List;
class List {
public:
typedef ListIterator iterator;
// constructor
List();
// destructor
virtual ~List();
// copy constructor
List(const List& k);
// assignment operator
List& operator=(const List& k);
// insert value in front of list
void push_front(double data);
// insert value in back of list
void push_back(double data);
// delete value from front of list
void pop_front();
// delete value from back of list
void pop_back();
// return value on front of list
double front() const;
// return value on back of list
double back() const;
// delete value specified by iterator
void erase(const iterator& i);
// delete all nodes with specified value
void remove(double data);
// return true if list is empty
bool empty() const;
// return reference to first element in list
iterator begin() const;
// return reference to one past last element in list
iterator end() const;
private:
Node *head; // head of list
};
class ListIterator {
public:
// default constructor
ListIterator() {
i = 0;
}
// construct iterator for given pointer (used for begin/end)
ListIterator(Node *p) {
i = p;
}
// convert iterator to Node*
operator Node*() const {
return i;
}
// test two iterators for not equal
bool operator!=(const ListIterator& k) const {
return i != k.i;
}
// preincrement operator
ListIterator& operator++() {
i = i->next;
return *this;
}
// return value associated with iterator
double& operator*() const {
return i->data;
}
private:
Node *i; // current value of iterator
};
list.cpp
// delete list
static void deleteList(Node *head) {
Node *p = head->next;
while (p != head) {
Node *next = p->next;
delete p;
p = next;
}
delete head;
}
// copy list
static void copyList(const Node *from, Node *&to) {
// create dummy header
to = new Node;
to->next = to->prev = to;
// copy nodes
for (Node *p = from->next; p != from; p = p->next) {
Node *t = new Node;
t.
Below are the transactions and adjustments that occurred during the .pdf
Below are the transactions and adjustments that occurred during the first year of operations at
Kissick Co
a. Issued 190,000 shares of $5-par-value common stock for $950,000 in cash.
b. Borrowed $500,000 from Oglesby National Bank and signed a 10% note due in three years.
c. Incurred and paid $380,000 in salaries for the year.
d. Purchased $730,000 of merchandise inventory on account during the year.
e. Sold inventory costing $590,000 for a total of $910,000, all on credit.
f. Paid rent of $220,000 on the sales facilities during the first 11 months of the year.
g. Purchased $180,000 of store equipment, paying $55,000 in cash and agreeing to pay the
difference within 90 days.
h. Paid the entire $125,000 owed for store equipment and $620,000 of the amount due to
suppliers for credit purchases previously recorded.
i. Incurred and paid utilities expense of $35,000 during the year.
j. Collected $825,000 in cash from customers during the year for credit sales previously
recorded.
k. At year-end, accrued $50,000 of interest on the note due to Oglesby National Bank.
l. At year-end, accrued $20,000 of past-due December rent on the sales facilities. Required a.
Prepare an income statement (ignoring income taxes) for Kissick Co.\'s first year of operations
and a balance sheet as of the end of the year. account affected by the transactions.) KISSICK CO
Income Statement
Solution
Answers
ASSETS
LIABILITIES
STOCKHOLDER EQUITY
INCOME STATEMENT (Retained earnings)
Transaction
Cash
Accounts receivables
Merchandise Inventory
Equipment
Notes Payable
Accounts Payable
Common Stock
Net Income
Revenue
Expenses
a
$ 950,000.00
$ 950,000.00
$ -
b
$ 500,000.00
$ 500,000.00
$ -
c
$ (380,000.00)
$ (380,000.00)
$ 380,000.00
d
$ 730,000.00
$ 730,000.00
$ -
e
$ 910,000.00
$ 910,000.00
$ 910,000.00
$ (590,000.00)
$ (590,000.00)
$ 590,000.00
f
$ (220,000.00)
$ (220,000.00)
$ 220,000.00
g
$ (55,000.00)
$ 55,000.00
$ -
$ 125,000.00
$ 125,000.00
$ -
h
$ (745,000.00)
$ (745,000.00)
$ -
i
$ (41,000.00)
$ (41,000.00)
$ 41,000.00
j
$ 825,000.00
$ (825,000.00)
$ -
k
$ 50,000.00
$ (50,000.00)
$ 50,000.00
l
$ 20,000.00
$ (20,000.00)
$ 20,000.00
Total
$ 834,000.00
$ 85,000.00
$ 140,000.00
$ 180,000.00
$ 550,000.00
$ 130,000.00
$ 950,000.00
$ (391,000.00)
$ 910,000.00
$ 1,301,000.00
Transaction no.
e
Sales Revenues
$ 910,000.00
e
Cost of Goods Sold
$ 590,000.00
Gross Profits
$ 320,000.00
Operating Expenses:
c
Salaries expense
$ 380,000.00
f + l
Rent Expenses
$ 240,000.00
i
Utilities expense
$ 41,000.00
Total operating expenses
$ 661,000.00
Operating Income
$ (341,000.00)
Other revenues & expenses
j
Interest expense
$ 50,000.00
Net Income (Loss)
$ (391,000.00)
ASSETS
Current Assets:
Cash
$ 834,000.00
Accounts receivables
$ 85,000.00
Merchandise Inventory
$ 140,000.00
Total current assets
$ 1,059,000.00
Equipment
$ 180,000.00
Total Assets
$ 1,239,000.00
LIABILITIES
Accounts Payable
$ 110,000.00
Interest Payable
$ 50,000.00
Rent (Expense) Payable
$ 20,000.00
Total current Liabilities
$ 180,0.
Help Please. Results not given Explain how your results for the pe.pdf
Help Please. Results not given Explain how your results for the percent of water in the hydrate
and the formula of the hydrate would be changed if water from the air were absorbed by the hot
dry sample as it cools. Be specific and justifty your answer.
Solution
For example take calcium sulphate anhydrous form which is black in color upon cooling changes
to blue which is calcium sulphate penta hydrate . The percent of water content increases and also
5 H2O is added in the empirical formula..
More Related Content
Similar to Data Structures in C++I am really new to C++, so links are really .pdf
C Homework Help
I am Andrew O. I am a C Homework Expert at programminghomeworkhelp.com. I hold a master’s in Programming from, the University of Southampton, UK. I have been helping students with their homework for the past 10 years. I solve homework related to C.
Visit programminghomeworkhelp.com or email support@programminghomeworkhelp.com.
You can also call on +1 678 648 4277 for any assistance with C Homework.
C++Write a method Node Nodereverse() which reverses a list..pdf
C++
Write a method Node *Node::reverse() which reverses a list.
Solution
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* Function to reverse the linked list */
static void reverse(struct node** head_ref)
{
struct node* prev = NULL;
struct node* current = *head_ref;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head_ref = prev;
}
/* Function to push a node */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Driver program to test above function*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
push(&head, 20);
push(&head, 4);
push(&head, 15);
push(&head, 85);
printf(\"Given linked list\ \");
printList(head);
reverse(&head);
printf(\"\ Reversed Linked list \ \");
printList(head);
getchar();
}.
Below is a depiction of a doubly-linked list implementation of the bag.docx
Below is a depiction of a doubly-linked list implementation of the bag ADT with two sentinels -one at the head and one at the tail. Strict DLink { TYPE value; strict DLink * next; struct DLink * prev;}; strict linked List { int size; struct DLink *frontSentinel; struct DLink *backSentinel;}; Write a function that at first reverses the list and then prints the values of the links in the list from front to back. Don\'t redirect to any other function. You must use assertions if necessary.
Solution
/* Program to reverse a doubly linked list */
#include <stdio.h>
#include <stdlib.h>
/* a node of the doubly linked list */
struct node
{
int data;
struct node *n;
struct node *pr;
};
/* Function to reverse a Doubly Linked List */
void reverse(struct node **head_r)
{
struct node *t = NULL;
struct node *cur = *head_r;
/* swap next and prev for all nodes of
doubly linked list */
while (cur != NULL)
{
t = cur->pr;
cur->pr = cur->n;
cur->n = t;
cur = cur->pr;
}
/* Before changing head, check for the cases like empty
list and list with only one node */
if(t != NULL )
*head_r = t->pr;
}
/* UTILITY FUNCTIONS */
/* Function to insert a node at the beginging of the Doubly Linked List */
void push(struct node** head_r, int new_data)
{
/* allocate node */
struct node* n_node =
(struct node*) malloc(sizeof(struct node));
/* put in the data */
n_node->data = n_data;
/* since we are adding at the begining,
prev is always NULL */
n_node->pr = NULL;
/* link the old list off the new node */
n_node->n = (*head_r);
/* change prev of head node to new node */
if((*head_r) != NULL)
(*head_r)->pr = n_node ;
/* move the head to point to the new node */
(*head_r) = n_node;
}
/* Function to print nodes in a given doubly linked list
This function is same as printList() of singly linked lsit */
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/* Drier program to test above functions*/
int main()
{
/* Start with the empty list */
struct node* head = NULL;
/* Let us create a sorted linked list to test the functions
Created linked list will be 10->8->4->2 */
push(&head, 2);
push(&head, 4);
push(&head, 8);
push(&head, 10);
printf(\"\ Original Linked list \");
printList(head);
/* Reverse doubly linked list */
reverse(&head);
printf(\"\ Reversed Linked list \");
printList(head);
getchar();
}
.
Problem- Describe an algorithm for concatenating two singly linked lis.pdf
Problem: Describe an algorithm for concatenating two singly linked lists L and M, into a single
list L that contains all the nodes of L followed by all the nodes of M. Modify the
SinglyLinkedList class to contain the method:
public void concatenate(SinglyLinkedList other) { ... }
PLEASE PLEASE USE THE CODE BELOW..... THANK YOU
public class SinglyLinkedList<E> implements Cloneable {
//---------------- nested Node class ----------------
/**
* Node of a singly linked list, which stores a reference to its
* element and to the subsequent node in the list (or null if this
* is the last node).
*/
private static class Node<E> {
/** The element stored at this node */
private E element; // reference to the element stored at this node
/** A reference to the subsequent node in the list */
private Node<E> next; // reference to the subsequent node in the list
/**
* Creates a node with the given element and next node.
*
* @param e the element to be stored
* @param n reference to a node that should follow the new node
*/
public Node(E e, Node<E> n) {
element = e;
next = n;
}
// Accessor methods
/**
* Returns the element stored at the node.
* @return the element stored at the node
*/
public E getElement() { return element; }
/**
* Returns the node that follows this one (or null if no such node).
* @return the following node
*/
public Node<E> getNext() { return next; }
// Modifier methods
/**
* Sets the node's next reference to point to Node n.
* @param n the node that should follow this one
*/
public void setNext(Node<E> n) { next = n; }
} //----------- end of nested Node class -----------
// instance variables of the SinglyLinkedList
/** The head node of the list */
private Node<E> head = null; // head node of the list (or null if empty)
/** The last node of the list */
private Node<E> tail = null; // last node of the list (or null if empty)
/** Number of nodes in the list */
private int size = 0; // number of nodes in the list
/** Constructs an initially empty list. */
public SinglyLinkedList() { } // constructs an initially empty list
// access methods
/**
* Returns the number of elements in the linked list.
* @return number of elements in the linked list
*/
public int size() { return size; }
/**
* Tests whether the linked list is empty.
* @return true if the linked list is empty, false otherwise
*/
public boolean isEmpty() { return size == 0; }
/**
* Returns (but does not remove) the first element of the list
* @return element at the front of the list (or null if empty)
*/
public E first() { // returns (but does not remove) the first element
if (isEmpty()) return null;
return head.getElement();
}
/**
* Returns (but does not remove) the last element of the list.
* @return element at the end of the list (or null if empty)
*/
public E last() { // returns (but does not remove) the last element
if (isEmpty()) return null;
return tail.getElement();
}
// update methods
/**
* Adds an element to the front of the list.
* @param e the new element to add
*/
public vo.
C Exam Help
I am Gabriel C. I am a C Exam Expert at programmingexamhelp.com. I hold a PhD. in Business analyst of Information Technology, Montreal College of Information Technology, Canada. I have been helping students with their exams for the past 8 years. You can hire me to take your exam in C.
Visit programmingexamhelp.com or email support@programmingexamhelp.com. You can also call on +1 678 648 4277 for any assistance with the C Exam.
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.
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED
HELP FIXING THIS CODE?
THIS IS THE PROBLEM
Write a program that allows the user to enter two positive integers and outputs their sum. Sounds
simple? Here\'s the catch: The numbers may be any size! They may be way too large to store in a
single variable. You may not assume any particular maximum number of digits.
HERE IS THE CODE
#include
#include
struct node /* Linked list node*/
{
int data;
struct node* next;
};
struct node *newNode(int data) /* Function to create a new node with giving the data*/
{
struct node *new_node = (struct node *) malloc(sizeof(struct node));
new_node->data = data;
new_node->next = NULL;
return new_node;
}
void push(struct node** head_ref, int new_data) /* Function to insert a node at the beginning of
the Doubly Linked List*/
{
struct node* new_node = newNode(new_data); /*allocate a node*/
new_node->next = (*head_ref); /* link the old list off to the new node*/
(*head_ref) = new_node; /*move the head to point to the new node*/
}
/* Adding the contents of two linked lists and return the head node of resultant list*/
struct node* addTwoLists (struct node* first, struct node* second)
{
struct node* res = NULL; /* res is head node of the resultant list*/
struct node *temp, *prev = NULL;
int carry = 0, sum;
while (first != NULL || second != NULL) /*while both the lists exists*/
{
/* Calculate value of next digit in resultant list.
// The next digit is sum of following things
// (i) Carry
// (ii) Next digit of first list (if there is a next digit)
// (ii) Next digit of second list (if there is a next digit)*/
sum = carry + (first? first->data: 0) + (second? second->data: 0);
carry = (sum >= 10)? 1 : 0; /* update carry for next calulation*/
sum = sum % 10; /*update sum if it is greater than 10*/
temp = newNode(sum); /*Create a new node with sum as data*/
if(res == NULL) /*if this is the first node then set it as head of the resultant list*/
res = temp;
else /* If this is not the first node then connect it to the rest.*/
prev->next = temp;
prev = temp; /* Set prev for next insertion*/
if (first) first = first->next; /* Move first pointers to next node*/
if (second) second = second->next; /*Move second pointer to the next node*/
}
if (carry > 0)
temp->next = newNode(carry);
return res; /* return head of the resultant list*/
}
void printList(struct node *node) /* function to print a linked list*/
{
while(node != NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
printf(\"\ \");
}
int main(void) /* program to test above function*/
{
struct node* res = NULL;
struct node* first = NULL;
struct node* second = NULL;
printf(\"Enter first positive integer: \");
scanf(\"%d\",&first);
printList(first);
printf(\"Enter second positive integer: \");
scanf(\"%d\",&second);
printList(second);
/*Add the two lists and see result*/
res = addTwoLists(first, second);
printf(\"Sum is: %d\");
printList(res);
return 0;
}
Solution
#include
#include
typedef struct Node
{
int da.
Use C++ Write a function to merge two doubly linked lists. The input.pdf
Use C++ 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
/* This is a C++ program to merge two sorted linked lists and produce a list in a
Sorted order */
#include
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
/* This function is used to pull off the front node of the source and put it in destnation */
void letusMoveNode(struct node** destRef, struct node** sourceRef);
/* This is a function used for performing merging of two linked lists.It takes two lists sorted in
increasing order, and splices
their nodes together to make one big sorted list which
is returned. */
struct node* letssortlists(struct node* a, struct node* b)
{
/* Let us first have dummyone first node to hang the result on */
struct node dummyone;
/*next the tail points to the last result node */
struct node* tail = &dummyone;
/* As a result, tail->next is the place to add new nodes
to the result. */
dummyone.next = NULL;
while (1)
{
if (a == NULL)
{
/*we will check that if either list runs out, use the
other list */
tail->next = b;
break;
}
else if (b == NULL)
{
tail->next = a;
break;
}
if (a->data <= b->data)
letusMoveNode(&(tail->next), &a);
else
letusMoveNode(&(tail->next), &b);
tail = tail->next;
}
return(dummyone.next);
}
/* letusMoveNode() function is a function which takes the node from the front of the
source, and move it to the front of the dest.
Before calling letusMoveNode():
source == {1, 2, 3}
dest == {1, 2, 3}
Affter calling letusMoveNode():
source == {3, 4}
dest == {1, 2, 3, 4} */
void letusMoveNode(struct node** destReference, struct node** sourceReference)
{
/*This is the front source node */
struct node* newNode = *sourceReference;
assert(newNode != NULL);
/* now we will advance the source pointer */
*sourceReference = newNode->next;
/*next we will link the old dest off the new node */
newNode->next = *destReference;
/* Fineally we will move dest to point to the new node */
*destReference = newNode;
}
/* This IS A function which is used to insert a node at the beginning of the linked list */
void insertpush(struct node** head_reference, int new_data)
{
/* This is used to allocate node */
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
/* now we will put in the data */
new_node->data = new_data;
/* The next step is to link the old list off the new node */
new_node->next = (*head_reference);
/*Finally we will move the head to point to the new node */
(*head_reference) = new_node;
}
/* This is a function to print nodes in a given linked list */
void printList(struct node *node)
{
while (node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
/*This is the driver program to test ab.
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.
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.
Write a program that accepts an arithmetic expression of unsigned in.pdf
Write a program that accepts an arithmetic expression of unsigned integers in postfix notation
and builds the arithmetic expression tree that represents that expression. From that tree, the
corresponding fully parenthesized infix expression should be displayed and a file should be
generated that contains the three address format instructions. This topic is discussed in the week
4 reading in module 2, section II-B. The main class should create the GUI shown below:
Pressing the Construct Tree button should cause the tree to be constructed and using that tree, the
corresponding infix expression should be displayed and the three address instruction file should
be generated. The postfix expression input should not be required to have spaces between every
token. Note in the above example that 9+- are not separated by spaces. The above example
should produce the following output file containing the three address instructions:
Add R0 5 9
Sub R1 3
R0 Mul R2 2 3
Div R3 R1 R2
Inheritance should be used to define the arithmetic expression tree. At a minimum, it should
involve three classes: an abstract class for the tree nodes and two derived classes, one for
operand nodes and another for operator nodes. Other classes should be included as needed to
accomplish good object-oriented design. All instance data must be declared as private.
You may assume that the expression is syntactically correct with regard to the order of operators
and operands, but you should check for invalid tokens, such as characters that are not valid
operators or operands such as 2a, which are not valid integers. If an invalid token is detected a
RuntimeException should be thrown and caught by the main class and an appropriate error
message should be displayed. Three Adddress Generator Enter Postfix Expression 359 2 3
Construct Tree Infix Expression ((3-(5 9))/ (2* 3
Solution
#include
#include
#include
#include
#include
struct TREE //Structure to represent a tree
{
char data;
struct TREE *right,*left,*root;
};
typedef TREE tree; /* Stack Using Linked List */
struct Stack //Structure to represent Stack
{
struct TREE *data;
struct Stack *next,*head,*top; //Pointers to next node,head and top
};
typedef struct Stack node;
node *Nw; //Global Variable to represent node
void initialize(node *&n)
{
n = new node;
n -> next = n -> head = n -> top = NULL;
}
void create(node *n)
{
Nw = new node; //Create a new node
Nw -> next = NULL; //Initialize next pointer field
if(n -> head == NULL) //if first node
{
n -> head = Nw; //Initialize head
n -> top = Nw; //Update top
}
}
void push(node *n,tree *ITEM)
{
node *temp = n -> head;
if(n -> head == NULL) //if First Item is Pushed to Stack
{
create(n); //Create a Node
n -> head -> data = ITEM; //Insert Item to head of List
n -> head = Nw;
return; //Exit from Function
}
create(n); //Create a new Node
Nw -> data = ITEM; //Insert Item
while(temp -> next != NULL)
temp = temp -> next; //Go to Last Node
temp -> next = Nw; //Point New node
n -> top = Nw; //Upda.
Consider a double-linked linked list implementation with the followin.pdf
Consider a double-linked linked list implementation with the following node: struct Node {int
data; Node *prev; Node *next;} Write a copyList method that is not a member of any class.
The method should take a head pointer and return another pointer. Do not modify the input.
Solution
struct Node {
Node *prev; // previous node
Node *next; // next node
int data; // stored value
};
#include
#include \"List.h\" // std: #include
using namespace std;
typedef DataList ; // std: typedef list Data;
int main() {
Data k;
// back stuff
k.push_back(5);
k.push_back(6);
cout << k.back() << endl;
k.pop_back();
// front stuff
k.push_front(4);
k.push_front(3);
cout << k.front() << endl;
k.pop_front();
// forward iterator
Data::iterator pos;
for (pos = k.begin(); pos != k.end(); ++pos)
cout << *pos << endl;
// output and delete list
while (!k.empty()) {
cout << k.front() << endl;
k.pop_front();
}
k.push_front(5);
k.push_front(6);
// remove and erase
k.remove(5);
pos = k.begin();
k.erase(pos);
k.push_front(5);
k.push_front(6);
// copy constructor
Data l = k;
// assignment operator
Data m;
m = k;
return 0;
}
// List.h
struct Node;
classIterator List;
class List {
public:
typedef ListIterator iterator;
// constructor
List();
// destructor
virtual ~List();
// copy constructor
List(const List& k);
// assignment operator
List& operator=(const List& k);
// insert value in front of list
void push_front(double data);
// insert value in back of list
void push_back(double data);
// delete value from front of list
void pop_front();
// delete value from back of list
void pop_back();
// return value on front of list
double front() const;
// return value on back of list
double back() const;
// delete value specified by iterator
void erase(const iterator& i);
// delete all nodes with specified value
void remove(double data);
// return true if list is empty
bool empty() const;
// return reference to first element in list
iterator begin() const;
// return reference to one past last element in list
iterator end() const;
private:
Node *head; // head of list
};
class ListIterator {
public:
// default constructor
ListIterator() {
i = 0;
}
// construct iterator for given pointer (used for begin/end)
ListIterator(Node *p) {
i = p;
}
// convert iterator to Node*
operator Node*() const {
return i;
}
// test two iterators for not equal
bool operator!=(const ListIterator& k) const {
return i != k.i;
}
// preincrement operator
ListIterator& operator++() {
i = i->next;
return *this;
}
// return value associated with iterator
double& operator*() const {
return i->data;
}
private:
Node *i; // current value of iterator
};
list.cpp
// delete list
static void deleteList(Node *head) {
Node *p = head->next;
while (p != head) {
Node *next = p->next;
delete p;
p = next;
}
delete head;
}
// copy list
static void copyList(const Node *from, Node *&to) {
// create dummy header
to = new Node;
to->next = to->prev = to;
// copy nodes
for (Node *p = from->next; p != from; p = p->next) {
Node *t = new Node;
t.
Similar to Data Structures in C++I am really new to C++, so links are really .pdf (20)
C++Write a method Node Nodereverse() which reverses a list..pdf
C++Write a method Node Nodereverse() which reverses a list..pdf
Below is a depiction of a doubly-linked list implementation of the bag.docx
Below is a depiction of a doubly-linked list implementation of the bag.docx
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
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
THE CODE HAS A SEGMENTATION FAULT BUT I CANNOT FIND OUT WHERE. NEED .pdf
Use C++ Write a function to merge two doubly linked lists. The input.pdf
Use C++ Write a function to merge two doubly linked lists. The input.pdf
Unit II Data Structure 2hr topic - List - Operations.pptx
Unit II Data Structure 2hr topic - List - Operations.pptx
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
Describe an algorithm for concatenating two singly linked lists L and.pdf
Describe an algorithm for concatenating two singly linked lists L and.pdf
Write a program that accepts an arithmetic expression of unsigned in.pdf
Write a program that accepts an arithmetic expression of unsigned in.pdf
Consider a double-linked linked list implementation with the followin.pdf
Consider a double-linked linked list implementation with the followin.pdf
More from rohit219406
Below are the transactions and adjustments that occurred during the .pdf
Below are the transactions and adjustments that occurred during the first year of operations at
Kissick Co
a. Issued 190,000 shares of $5-par-value common stock for $950,000 in cash.
b. Borrowed $500,000 from Oglesby National Bank and signed a 10% note due in three years.
c. Incurred and paid $380,000 in salaries for the year.
d. Purchased $730,000 of merchandise inventory on account during the year.
e. Sold inventory costing $590,000 for a total of $910,000, all on credit.
f. Paid rent of $220,000 on the sales facilities during the first 11 months of the year.
g. Purchased $180,000 of store equipment, paying $55,000 in cash and agreeing to pay the
difference within 90 days.
h. Paid the entire $125,000 owed for store equipment and $620,000 of the amount due to
suppliers for credit purchases previously recorded.
i. Incurred and paid utilities expense of $35,000 during the year.
j. Collected $825,000 in cash from customers during the year for credit sales previously
recorded.
k. At year-end, accrued $50,000 of interest on the note due to Oglesby National Bank.
l. At year-end, accrued $20,000 of past-due December rent on the sales facilities. Required a.
Prepare an income statement (ignoring income taxes) for Kissick Co.\'s first year of operations
and a balance sheet as of the end of the year. account affected by the transactions.) KISSICK CO
Income Statement
Solution
Answers
ASSETS
LIABILITIES
STOCKHOLDER EQUITY
INCOME STATEMENT (Retained earnings)
Transaction
Cash
Accounts receivables
Merchandise Inventory
Equipment
Notes Payable
Accounts Payable
Common Stock
Net Income
Revenue
Expenses
a
$ 950,000.00
$ 950,000.00
$ -
b
$ 500,000.00
$ 500,000.00
$ -
c
$ (380,000.00)
$ (380,000.00)
$ 380,000.00
d
$ 730,000.00
$ 730,000.00
$ -
e
$ 910,000.00
$ 910,000.00
$ 910,000.00
$ (590,000.00)
$ (590,000.00)
$ 590,000.00
f
$ (220,000.00)
$ (220,000.00)
$ 220,000.00
g
$ (55,000.00)
$ 55,000.00
$ -
$ 125,000.00
$ 125,000.00
$ -
h
$ (745,000.00)
$ (745,000.00)
$ -
i
$ (41,000.00)
$ (41,000.00)
$ 41,000.00
j
$ 825,000.00
$ (825,000.00)
$ -
k
$ 50,000.00
$ (50,000.00)
$ 50,000.00
l
$ 20,000.00
$ (20,000.00)
$ 20,000.00
Total
$ 834,000.00
$ 85,000.00
$ 140,000.00
$ 180,000.00
$ 550,000.00
$ 130,000.00
$ 950,000.00
$ (391,000.00)
$ 910,000.00
$ 1,301,000.00
Transaction no.
e
Sales Revenues
$ 910,000.00
e
Cost of Goods Sold
$ 590,000.00
Gross Profits
$ 320,000.00
Operating Expenses:
c
Salaries expense
$ 380,000.00
f + l
Rent Expenses
$ 240,000.00
i
Utilities expense
$ 41,000.00
Total operating expenses
$ 661,000.00
Operating Income
$ (341,000.00)
Other revenues & expenses
j
Interest expense
$ 50,000.00
Net Income (Loss)
$ (391,000.00)
ASSETS
Current Assets:
Cash
$ 834,000.00
Accounts receivables
$ 85,000.00
Merchandise Inventory
$ 140,000.00
Total current assets
$ 1,059,000.00
Equipment
$ 180,000.00
Total Assets
$ 1,239,000.00
LIABILITIES
Accounts Payable
$ 110,000.00
Interest Payable
$ 50,000.00
Rent (Expense) Payable
$ 20,000.00
Total current Liabilities
$ 180,0.
Help Please. Results not given Explain how your results for the pe.pdf
Help Please. Results not given Explain how your results for the percent of water in the hydrate
and the formula of the hydrate would be changed if water from the air were absorbed by the hot
dry sample as it cools. Be specific and justifty your answer.
Solution
For example take calcium sulphate anhydrous form which is black in color upon cooling changes
to blue which is calcium sulphate penta hydrate . The percent of water content increases and also
5 H2O is added in the empirical formula..
As a software developer you have been delegated with the assignment .pdf
As a software developer you have been delegated with the assignment of developing a software
“Library Management System” for an educational institute to manage their books. Elaborate the
different tasks you will undertake at each step of the software development lifecycle to develop
an efficient software
Solution
There are basically three phases in developing this LIbrary Management System .They are:
1)Project Initiation
2)Project execution
3)Release and usage (deploying)
1) PROJECT INITIATION : This is the Starting pahse of the project.Here the requirements are
gathered and the scope and cost of executing the project are known.This is known for deciding
whether the project should be developed or not.
2)PROJECT EXECUTION
In this phase the development or execution of the project takes place. Here we will try to build
up the project.
In this we have three sub-phases they are:
A. system analysis
• Initial study: The details about the project are known.
• Information gathering:The components or tools required to build up the project are
gathered.EX:Programming languages.
B. System design
• Design standard
• High level design & design tools
• Database design
• Logical design
• Construction
3. System implementation
• Integration & testing : Here all the individual build up phases are combined and are developed
into a totally functional system and are thouroughly tested.
• Post implementation :This is generally the BEta testing or USer Acceptence testing phase,This
is done after the entire project is implemented.
3)PROJECT DEPLOYMENT
In this phase the project is ready for work.It is deployed and is used.
After all these phases MAINTENANCE phase takes place.In MAINTENANCE phase any faults
which are found in the system will be solved..
What scientist is credited with proposing the equivalency of mass and.pdf
What scientist is credited with proposing the equivalency of mass and energy? What is the
famous equation that he proposed?
Solution
Here ,
the scientist proposing the equivalency of mass and energy was Albert Einstein.
the equation proposed by him was.
E = m * c^2
where E is energy
m is mass
c is the speed of light.
Why do countries with high GNI and GDP are attractive for foreign in.pdf
Why do countries with high GNI and GDP are attractive for foreign investment?
Solution
Let us first understand what is a GNI and GDP
The gross national income (GNI) is the total domestic and foreign output claimed by residents of
a country, consisting of gross domestic product (GDP) plus factor incomes earned by foreign
residents, minus income earned in the domestic economy by nonresidents
Gross Domestic Product (GDP) is the broadest quantitative measure of a nation\'s total economic
activity. More specifically, GDP represents the monetary value of all goods and services
produced within a nation\'s geographic borders over a specified period of time.
The gross domestic product (GDP) is one of the primary indicators used to gauge the health of a
country\'s economy. It represents the total dollar value of all goods and services produced over a
specific time period; you can think of it as the size of the economy. Usually, GDP is expressed as
a comparison to the previous quarter or year. For example, if the year-to-year GDP is up 3%, this
is thought to mean that the economy has grown by 3% over the last year.
Measuring GDP is complicated (which is why we leave it to the economists), but at its most
basic, the calculation can be done in one of two ways: either by adding up what everyone earned
in a year (income approach), or by adding up what everyone spent (expenditure method).
Logically, both measures should arrive at roughly the same total.
Both the factors reflects the following ; and are most important in attracting foreign investments
In other words ,it determine the health of the any given economy ,and therefore is an important
yardstick to assess and measure and invest.
Which of the following is NOT true about the ESCBA.It acts as an.pdf
Which of the following is NOT true about the? ESCB?
A.It acts as an independent monetary authority.
B.It is an abbreviation for the European System of Central Banks.
C.Any one country can exert veto power over monetary policy.
D.It includes European Central Bank
Solution
A) It acts as an independent monetary authority. This is not true for ESCB as it consists of ECB
and 28 state national central banks. So the ESCB is not a monetary authority and also many EU
states having national banks have not joined euro..
What is 4 -4 + infinity - infinity As x approaches 3 from th.pdf
What is 4 -4 + infinity - infinity As x approaches 3 from the right (i.e. 3) the values are just
bigger that 3. So the denominator is positive and approaching 0. Hence the limit is going to +
infinity. Had the denominator been (3 - x) then the answer would have been - infinity.
Solution
c) +infinity if x approaches from 3+ then it will always be less than 3 ,suppose
x=3.00001 then the difference = 3-3.00001 = -.00001 hence when denominator is 3-x it will
always tend to (-infinity).
Use what you have learned so far to bring variety in your writing. U.pdf
Use what you have learned so far to bring variety in your writing. Use the following lines or your
own sheet of paper to write six sentences that practice each basic sentence pattern. When you
have finished, label each part of the sentence (S, V, LV, N, Adj, Adv, DO, IO).
1. ________________________________________________________________
2. ________________________________________________________________
3. ________________________________________________________________
4. ________________________________________________________________
5. ________________________________________________________________
6. ________________________________________________________________
Solution
The sentences you have encountered so far have been independent clauses. As you look more
closely at your past writing assignments, you may notice that some of your sentences are not
complete. A sentence that is missing a subject or a verb is called a fragment. A fragment may
include a description or may express part of an idea, but it does not express a complete thought.
Fragment: Children helping in the kitchen.
Complete sentence: Children helping in the kitchen often make a mess.
You can easily fix a fragment by adding the missing subject or verb. In the example, the sentence
was missing a verb. Adding often make a mess creates an S-V-N sentence structure. Figure 3.1
illustrates how you can edit a fragment to become a complete sentence.
Editing Fragments That Are Missing a Subject or a Verb
Fragment: Told her about the broken vase.
Complete sentence: I told her about the broken vase.
Complete sentence: The store down on Main Street sells music.
Common Sentence Errors
Fragments often occur because of some common errors, such as starting a sentence with a
preposition, a dependent word, an infinitive, or a gerund. If you use the six basic sentence
patterns when you write, you should be able to avoid these errors and thus avoid writing
fragments.
When you see a preposition, check to see that it is part of a sentence containing a subject and a
verb. If it is not connected to a complete sentence, it is a fragment, and you will need to fix this
type of fragment by combining it with another sentence. You can add the prepositional phrase to
the end of the sentence. If you add it to the beginning of the other sentence, insert a comma after
the prepositional phrase. Look at the examples. Figure 3.2 illustrates how you can edit a
fragment that begins with a preposition.
Example A:
[Incorrect: After walking over two miles. John remembered his wallet. Correct: After walking
over two miles, John remembered his wallet. Correct: John remembered his wallet after walking
over two miles.]
Example B:
[Incorrect: The dog growled at the vacuum cleaner. When it was switched on. Correct: When the
vacuum cleaner was switched on, the dog growled. Correct: The dog growled at the vacuum
cleaner when it was switched on.]
Clauses that start with a dependent word—such as since, because, without.
Use C programmingMake sure everything works only uploadSol.pdf
Use C programming
Make sure everything works only upload
Solution
C program
#include
int isPrime(int number);// function prototype
int main()
{
int No,i;// variable decleration
printf(\"Input a number greater than 2: \");// asking user to enter a number
scanf(\"%d\",&No);// scaning the number form user
if(No <= 2)// checking no is lessthan or equ to 2
{ // if yes print message
printf(\"No prime number is smaller than %d.\ \",No);
return 0;// and stop computation
}
// else print the prime numbers
printf(\"Prime numbers smaller than %d:\",No);
for (i = 2;i.
Thoroughly describe the molecular underpinnings of ONE and only one.pdf
Thoroughly describe the molecular underpinnings of ONE and only one of these processes.
Transcription initiation and elongation
Solution
Transcription is the biochemical process involves transferring of information from DNA to
RNA, assisted with RNA polymerase. The RNA produced in this process will be converted to
protein in the process of translation. RNA polymerase read the DNA template and synthesize
with help of other important proteins to carried out the process. The process of transcription
comprises of series of events leading to Initiation, elongation, and termination. In the initiation
process, RNA polymerase with other adapter proteins binds to the upstream of DNA in the
initiation point.
RNA polymerase complexed with unwound DNA which bind to the promoter sequence, and
results in the initiation of the process. Promoter region contains an initiation site where process
begins. RNA polymerase synthesize new strand RNA, which is complementary to the DNA
strand.
In elongation phase, DNA polymerase lengthened the RNA, used as a DNA triplet code in the
template strand. polymerse read the template until the signal is percieved. RNA polymerase
functions by adding nucleotids to 3\' end of the strand and synthesized in 5\' to 3\' direction..
The Blackbeard Company Ltd provided the following information in reg.pdf
The Blackbeard Company Ltd provided the following information in regard to its operations for
the year ended 30 June 2014:
Cash Book Summary
Opening balance
$20,000
Accounts Payable
$40,000
Accounts receivable
100,000
Bills Payable (suppliers)
20,000
Bills Receivable (suppliers)
20,000
Interest paid
60,000
Debenture Issue
400,000
Operating expenses
180,000
Dividends received
20,000
Salaries & wages
200,000
Interest received
40,000
Current tax payable
80,000
Motor vehicles
60,000
Plant & machinery
100,000
Share capital
200,000
Dividend paid
120,000
Balance c/d
60,000
860,000
860,000
Balance b/d
60,000
Required:
(a) Net cash used in operating activities; (b) Net cash used in investing activities; (c) Net cash
from financing activities;
(d) Net increase/(decrease) in cash and cash equivalents.
Please use the following format
Statement of Cash Flows for Blackbeard Company
For the Financial Year Ended 30 June 2014
( i ) Cash flows from Operating Activities
Inflows/
Inflows/
(Outflows)
(Outflows)
Net cash used in operating activities
( ii ) Cash flows from Investing Activities
Net cash used in Investing Activities
( iii ) Cash flows from Financing Activities
Cash Book Summary
Opening balance
$20,000
Accounts Payable
$40,000
Accounts receivable
100,000
Bills Payable (suppliers)
20,000
Bills Receivable (suppliers)
20,000
Interest paid
60,000
Debenture Issue
400,000
Operating expenses
180,000
Dividends received
20,000
Salaries & wages
200,000
Interest received
40,000
Current tax payable
80,000
Motor vehicles
60,000
Plant & machinery
100,000
Share capital
200,000
Dividend paid
120,000
Balance c/d
60,000
860,000
860,000
Balance b/d
60,000
Solution
Statement of Cash flows for Blackbeard Company For the Financial Year Ended 30
June 2014 (i) Cash flow from Operating Activities Inflows/(outflows)
Inflows/(outflows) Accounts Receivable $ 1,00,000 Bills Receivable (suppliers)
$ 20,000 Accounts Payable $ -40,000 Bills Payable(suppliers) $ -
20,000 Operating expense $ -1,80,000 Salaries and wages $ -2,00,000
Current Tax Payable $ -80,000 Dividend received $ 20,000 Interest
received $ 40,000 Net Cash used in Operating Activties $ -3,40,000
(ii) Cash flow from Investing Activities Sales of Motor Vehicle
$ 60,000 Purchase of Plant and Machinery $ -1,00,000 Net Cash
from Investing Actiivties $ -40,000 (iii) Cash flow from Financing activities
Debenture issue $ 4,00,000 Share capital $ 2,00,000 Interest
paid $ -60,000 Dividend paid $ -1,20,000 Net Cash from
financing actiivties $ 4,20,000 Net Increase /(decrease) in cash and cash
equivalent $ 40,000 Cash at the Beginning of the period $ 20,000 Cash at the
end of the period $ 60,000.
Thank you 1. What is responsible for anteriorposterior axis formati.pdf
Thank you 1. What is responsible for anterior:posterior axis formation in the chicken? How is
dorsal ventral patterning accomplished? 2. What is the role of the Posterior Marginal zone in
early chicken development? 3. What is the primitive streak and why is it important in chicken
development? 4. What is the function of Henson\'s Node? To what is it analogous in amphibian
development?
Solution
1.The primitive streak defines the axes of the embryo. It extends from posterior to anterior;
migrating cells enter through its dorsal side and move to its ventral side; and it separates the left
portion of the embryo from the right. Those elements close to the streak will be the medial
(central) structures, while those farther from it will be the distal (lateral) structures
2.Primitive streak is induced by the posterior marginal zone (PMZ) of Koller\'s sickle, which can
also induce Hensen\'s node. If cell movement in the PMZ is blocked, primitive streak does not
form.Thus, the PMZ acts as an organizer.Cells in marginal zones of the embryo, like the PMZ,
are key to development and cell fate determination in chick embryos.
3.The primitive streak is a structure that forms in the blastula during the early stages of avian,
reptilian and mammalian embryonic development. It forms on the dorsal (back) face of the
developing embryo, toward the caudal or posterior end.The presence of the primitive streak will
establish bilateral symmetry, determine the site of gastrulation and initiate germ layer formation.
To form the streak, reptiles, birds and mammals arrange mesenchymal cells along the
prospective midline, establishing the second embryonic axis, as well as the place where cells will
ingress and migrate during the process of gastrulation and germ layer formation.The primitive
streak extends through this midline and creates the left–right and cranial–caudal body axes,and
marks the beginning of gastrulation.This process involves the ingression of mesoderm
progenitors and their migration to their ultimate position,where they will differentiate into the
mesoderm germ layer that, together with endoderm and ectoderm germ layers, will give rise to
all the tissues of the adult organism.
4.
The primitive knot (or primitive node) is the organizer for gastrulation in the vertebrate embryo.
Diversity
In birds, it is known as \"Hensen\'s node\", and is named after its discoverer Victor Hensen.
In amphibians, it is known as \"Spemann\'s organizer\", and is named after Hans Spemann
In chick development, the primitive knot starts as a regional knot of cells that forms on the
blastodisc immediately anterior to where the outer layer of cells will begin to migrate inwards -
an area known as the primitive streak, which is involved with Koller\'s sickle. Posterior to the
node is the primitive pit, where the cells of the epiblast (the upper layer of embryonic cells)
initially begin to invaginate. This invagination expands posteriorly into the primitive groove as
the cells layers c.
Take the basic Hardy-Weinberg Equilibrium equation, where there are a.pdf
Take the basic Hardy-Weinberg Equilibrium equation, where there are alleles A and B. If the
frequency of the two alleles are represented by p and q, then the expected genotypic frequencies
are p2 2pq q2. Please review your comfort with calculating observed and expected allele and
genotype frequencies. Try adding subscripts to the equation for relative fitness (use w) to predict
change in allele frequency due to selection. Both inbreeding and genetic drift can cause problems
for rare species with declining population size due to reducing genetic diversity. Please contrast
(say how they are different these two forces in terms of number of alleles at a locus (some loci
have more than two alleles) and in terms of average heterozygosity at a locus. In most organisms
most mating is local. If populations of an organism are scattered across a landscape, with gaps
between population, how will that affect inbreeding and expected Hardy Weinberg equilibrium?
Solution
Both inbreeding and genetic drift can cause problems for rare species with declining population
size due to reducing genetic diversity. Please contrast (say how they are different) these two
forces in terms of number of alleles at a locus (some loci have more than two alleles) and in
terms of average heterozygosity at a locus. In most organisms most mating is local. If
populations of an organism are scattered across a landscape, with gaps between population, how
will that affect inbreeding and expected Hardy-Weinberg equilibrium? If migration among
populations increases how will it affect inbreeding and expected hardy-Weinberg equilibrium?
P^2 = homozygous dominant
2pq =heterozygotes
Q^2= homozygous recessive
According to hardy Weinberg
P^2 +2pq + Q^2 =1
p = p2 + ½ (2pq) = p2 + pq
q = q2 + ½ (2pq) = q2 + pq
p + q = 1
(p + q)2 = 1
p2 + 2pq + q2 = 1 (the Hardy-Weinberg Principle)
Inbreeding can be referred as the mating between closely related organisms.
Inbreeding favors homozygosity, and increase q^2 (recessive homozygotes) and decreases
dominant phenotypes
It will increases the chances of offspring being affected by recessive or lethal traits.
Genetic bottlenecks and founder effects occurs in the population
Leads to
Hence population will be deviated from hardy-Weinberg equilibrium.
Systems analysis project 10 can you answer the 4 questions at the t.pdf
Systems analysis project 10: can you answer the 4 questions at the task section, thank you.
Personal Trainer, Inc. owns and operates fitness centers in a dozen Midwestern cities. The
centers have done well, and the company is planning an international expansion by opening a
new “supercenter” in the Toronto area. Personal Trainer’s president, Cassia Umi, hired an IT
consultant, Susan Park, to help develop an information system for the new facility. During the
project, Susan will work closely with Gray Lewis, who will manage the new operation.
Background
Susan and Gray finished their work on user interface, input, and output design. They developed
a user-centered design that would be flexible and easy to learn. Now Susan turned her attention
to the architecture for the new system. Susan wanted to consider their own organization and
culture, enterprise resource planning, total cost of ownership, scalability, Web integration, legacy
systems, processing methods, security issues, and corporate portal. She also needed to select a
network plan, or topology, that would dictate the physical cabling and network connections, or
consider a wireless network. When all these tasks were completed, she would submit a system
design specification for approval.
Tasks:
1. What would be the advantages of selecting an Internet-based architecture for the Personal
Trainer’s system?
2. If Personal Trainer wants to increase its Internet marketing efforts, what advice could you
offer? Perform research to find out more about the topic of Web-based marketing before you
answer Gray.
3. What software and hardware infrastructure will be necessary to ensure Personal Trainer can
process point of sale transactions?
4. Prepare an outline for a system design specification and describe the contents of each section
Solution
1)
The Internet has had a colossal effect on system architecture modeling. The Internet has turn out
to be more than a communication channel — numerous IT onlookers see it as a in a far-reaching
way distinctive environment for system development. In a customary client/server system, the
client handles the user interface and the server (or servers in a multi-level framework) handles
the information and application rationale. As it were, a piece of the framework keeps running on
the customer, part on the server.
Interestingly, in an Internet-based architecture, notwithstanding information and application
rationale, the whole user interface is given by the Web server as HTML coded documents that
are deciphered and showed by the client\'s browser. Moving the obligation regarding the
interface from the client to the server improves the procedure of information transmission and
results in lower hardware’s expenses and complexities. The pattern toward Internet-based e-
business is reshaping the IT scene as additional firms utilize the Web to manufacture proficient,
solid, and practical arrangements. At the point when arranging new systems, experts can utilize
accessible.
Step 1. Read critically and analyze the following scenarioGeraldi.pdf
Step 1. Read critically and analyze the following scenario:
Geraldine Barney Garrett, the granddaughter of Wilford Barney took over the reins of the R&D
department of Biotech Health and Life Products (Biotech) in 1965. She had trained at the hands
of her grandmother Wilford’s mother, Maria. Geraldine was a strong manager and developed the
Research and Development (R&D) lab from the advanced kitchen of her grandmother to the
scientific lab of her peers. Geraldine’s management philosophy evolved over the years but she
had several basic ideas that kept her grounded. Geraldine knew she had to answer to the family
in every decision she made. Her grandmother stressed this point and she eventually came to
agree. Therefore, decisions were made by her. She also realized that her employees had good
ideas and talent but they did not bear the responsibility she did. So, although she consulted with
the employees often, she never gave them the power to make important decisions.
Geraldine was charismatic in a motherly way and employees saw her as someone to learn from
but career growth was unlikely so in five or six years employees moved on to another company.
The unambitious stayed on and eventually Geraldine collected a small group of people she
trusted and who became her team. Now, several of the team members are retiring like Geraldine
leaving few left to the company.
When it comes to leading the entire R&D Division, Geraldine is very controlled in defining
goals, setting tasks, and is outstanding at dividing the work among the employees, organizing the
product materials and coordinating and communicating activities between the different
departments. Decisions that Geraldine makes are always dependent on the circumstances and
context of the decision. You often hear her instructing the young employees stating, “Always ask
yourself, which method will work best here? Remember, you are always looking to find the
simplest and most cost-effective solution.” When it comes to developing new products and
innovating, Geraldine is much more open to other people’s input and ideas relying heavily on her
team of experienced but older people. Still, the final decision remains in her hands.
Geraldine could see the need for changes in the lab, the most important of which was retaining
younger employees. Since she was retiring at the end of the year, Geraldine knew the new
department head would have to deal with the problem. Her immediate concern was who the new
department head should be. Her own granddaughter, Melanie Malone, was now working in the
company and she knew Melanie was expecting the job.
Melanie was qualified for the job. She was a Phi Beta Kappa graduate of the University of
Maryland College Park with a double major in Botany and Food Science. She minored in
Business Management. She had worked in the plant in Chicago every summer since High School
and had reproduced and revised all her grandmother’s and great-great grandmother’s recipes.
Starting full-time .
Question 3 2 pts In response to the Great Recession, the Federal Rese.pdf
Question 3 2 pts In response to the Great Recession, the Federal Reserve engaged in quantitative
easing. As a consequence, the monetary base rose by nearly 400%, causing some to worry about
inflation. However, during this time the money supply rose by only 110%. What explains this? A
money multiplier greater than 1. A money multiplier equal to 1. A money multiplier smaller than
1. A negative money multiplier.
Solution
Money multiplier = Money supply / monetary base = 110 / 400 = 0.275
A money multiplier smaller than 1.
Prove that the T_i -property is a topological property for i = 0S.pdf
Prove that the T_i -property is a topological property for i = 0
Solution
Hausdorff spaces do not have in general the homotopy type of any finite space. Recall that a
topological space
X satisfies the T1- separation axiom if for any two distinct points x, y X there exist open sets U
and V such that
x U, y V , y / U, x / V . This is equivalent to saying that the points are closed in X. All
Hausdorff spaces are
T1, but the converse is false.
Q4.14. Which of the following species is most likely to exhibit pate.pdf
Q4.14. Which of the following species is most likely to exhibit paternal care?
The polygynous topi antelope, one of nine species of lekking mammals.
Atlantic cod, a broadcast spawner for which fertilization by satellite males is common.
The monogamous great spotted woodpecker, a species whose males have high paternity
certainty.
Bonobos, a polygynandrous primate with internal fertilization and very low paternity certainty.
Solution
Ans c the monogamous great spotted wood pecker , a species whose males have high paternity
certainty.
They belong to family picidae and live in forests or woodland habitats..
Prepare a classified balance sheet. Do not show the components that .pdf
Prepare a classified balance sheet. Do not show the components that add up to your answer in
requirement 1 but rather show only the line “Cash and Cash Equivalents.” (Amounts to be
deducted should be indicated by a minus sign.)Gatti Corporation reported the following balances
at June 30.
Solution
1. Cash and cash equivalents = Cash + Cash equivalents + Petty cash + Restricted cash
= 15 + 20 + 25 + 20
= $80
2. Gatti Corporation
Balance Sheet
June 30Assets$Liabilities$Current assetsCurrent liabilitiesCash and cash equivalents80Notes
payable20Account receivable95Accounts payable105Total current assets175Unearned
revenue45Property, plant and equipmentTotal current liabilities170Equipment350Long term
liabilitiesLess: Accumulated depreciation-45Notes payable110Property, plant and equipment,
net305Total long term liabilities110Total liabilities280Stockholders EquityCommon
stock150Retained earnings50Total stockholders equity200Total assets480Total liabilities and
stockholders equity480.
Microscopes and telescopes both consist of two converging lenses cont.pdf
Microscopes and telescopes both consist of two converging lenses contained in a tube. What is
the difference in set-up of the two lenses between a microscope and a telescope? The rearview
mirror on a truck warns the user that objects may be closer than they appear. What kind of mirror
is being used, and why was that type selected? Why does a clear stream always appear to be
shallower than it actually is? Discuss the type of aberration involved in each of the following
situations. (i) The edges of the image appear reddish. (ii) The image cannot be clearly focused.
A baby fish has his eyesight tested and is found to be myopic. His father wants to make a set of
glasses to correct for this problem. Since fish live under water, the father fish will make the
glasses out of a very thin clear plastic bag which is filled with air (n = 1.000). What type of lens
does the fish need to make? What shape should the lens be? What is the wavelength of yellow
light?
Solution
In refracting telescopes, there are typically two convex lenses. One lens acts as the objective
lens: this lens gathers light from faraway objects and forms a real, inverted image of the object at
its focal point. A second lens, called the eyepiece, is positioned such that the image formed by
the objective lens is at its focal point. When an observer looks through the eyepiece with a
relaxed eye, they are able to see an object of the image, formed at infinity. Microscopes are used
to look at magnified images of small objects. A simple microscope (a “magnifying glass”)
consists of a single convex lens. The lens is held close to the object so that the object is between
the lens and its focal point. When viewed from the other side of the lens, a magnified, virtual,
upright image is seen. The compound microscope is the most common type of microscope used
in laboratories. With these microscopes, an objective lens is used to create an inverted, real
image of the object. Using the eyepiece, the image is magnified. In this sense, its operating
principles are similar to that of a refracting telescope. The rear view mirror is a convex mirror
which forms a virtual and erect image of the object which is smaller in length than the object.
Because the image formed is smaller in length, it appears to be farther away and hence, the
warning written on it. This is because of the phenomenon of refraction of light as it crosses the
medium of water(refractive index greater than that of air). As the light ray travels from
water(denser medium) to air(rarer medium), the light ray bends away from the normal and the
image of the bottom of the stream seems to be raised and hence, the stream appears to be
shallower. a) In optics, chromatic aberration (CA, also called chromatic distortion, and
spherochromatism) is an effect resulting from dispersion in which there is a failure of a lens to
focus all colors to the same convergence point. It occurs because lenses have different refractive
indices for differentwavelength.
More from rohit219406 (20)
Below are the transactions and adjustments that occurred during the .pdf
Below are the transactions and adjustments that occurred during the .pdf
Help Please. Results not given Explain how your results for the pe.pdf
Help Please. Results not given Explain how your results for the pe.pdf
As a software developer you have been delegated with the assignment .pdf
As a software developer you have been delegated with the assignment .pdf
What scientist is credited with proposing the equivalency of mass and.pdf
What scientist is credited with proposing the equivalency of mass and.pdf
Why do countries with high GNI and GDP are attractive for foreign in.pdf
Why do countries with high GNI and GDP are attractive for foreign in.pdf
Which of the following is NOT true about the ESCBA.It acts as an.pdf
Which of the following is NOT true about the ESCBA.It acts as an.pdf
What is 4 -4 + infinity - infinity As x approaches 3 from th.pdf
What is 4 -4 + infinity - infinity As x approaches 3 from th.pdf
Use what you have learned so far to bring variety in your writing. U.pdf
Use what you have learned so far to bring variety in your writing. U.pdf
Use C programmingMake sure everything works only uploadSol.pdf
Use C programmingMake sure everything works only uploadSol.pdf
Thoroughly describe the molecular underpinnings of ONE and only one.pdf
Thoroughly describe the molecular underpinnings of ONE and only one.pdf
The Blackbeard Company Ltd provided the following information in reg.pdf
The Blackbeard Company Ltd provided the following information in reg.pdf
Thank you 1. What is responsible for anteriorposterior axis formati.pdf
Thank you 1. What is responsible for anteriorposterior axis formati.pdf
Take the basic Hardy-Weinberg Equilibrium equation, where there are a.pdf
Take the basic Hardy-Weinberg Equilibrium equation, where there are a.pdf
Systems analysis project 10 can you answer the 4 questions at the t.pdf
Systems analysis project 10 can you answer the 4 questions at the t.pdf
Step 1. Read critically and analyze the following scenarioGeraldi.pdf
Step 1. Read critically and analyze the following scenarioGeraldi.pdf
Question 3 2 pts In response to the Great Recession, the Federal Rese.pdf
Question 3 2 pts In response to the Great Recession, the Federal Rese.pdf
Prove that the T_i -property is a topological property for i = 0S.pdf
Prove that the T_i -property is a topological property for i = 0S.pdf
Q4.14. Which of the following species is most likely to exhibit pate.pdf
Q4.14. Which of the following species is most likely to exhibit pate.pdf
Prepare a classified balance sheet. Do not show the components that .pdf
Prepare a classified balance sheet. Do not show the components that .pdf
Microscopes and telescopes both consist of two converging lenses cont.pdf
Microscopes and telescopes both consist of two converging lenses cont.pdf
Recently uploaded
The Challenger.pdf DNHS Official Publication
Read| The latest issue of The Challenger is here! We are thrilled to announce that our school paper has qualified for the NATIONAL SCHOOLS PRESS CONFERENCE (NSPC) 2024. Thank you for your unwavering support and trust. Dive into the stories that made us stand out!
Sectors of the Indian Economy - Class 10 Study Notes pdf
The Indian economy is classified into different sectors to simplify the analysis and understanding of economic activities. For Class 10, it's essential to grasp the sectors of the Indian economy, understand their characteristics, and recognize their importance. This guide will provide detailed notes on the Sectors of the Indian Economy Class 10, using specific long-tail keywords to enhance comprehension.
For more information, visit-www.vavaclasses.com
How to Split Bills in the Odoo 17 POS Module
Bills have a main role in point of sale procedure. It will help to track sales, handling payments and giving receipts to customers. Bill splitting also has an important role in POS. For example, If some friends come together for dinner and if they want to divide the bill then it is possible by POS bill splitting. This slide will show how to split bills in odoo 17 POS.
The French Revolution Class 9 Study Material pdf free download
The French Revolution, which began in 1789, was a period of radical social and political upheaval in France. It marked the decline of absolute monarchies, the rise of secular and democratic republics, and the eventual rise of Napoleon Bonaparte. This revolutionary period is crucial in understanding the transition from feudalism to modernity in Europe.
For more information, visit-www.vavaclasses.com
MARUTI SUZUKI- A Successful Joint Venture in India.pptx
Let us know about Maruti Suzuki, a successful Joint venture in India.
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.
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”.
Unit 8 - Information and Communication Technology (Paper I).pdf
This slides describes the basic concepts of ICT, basics of Email, Emerging Technology and Digital Initiatives in Education. This presentations aligns with the UGC Paper I syllabus.
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
for studentd in cabridge board
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptxMohd Adib Abd Muin, Senior Lecturer at Universiti Utara Malaysia
This slide is prepared for master's students (MIFB & MIBS) UUM. May it be useful to all.TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH ANSWERS.
Unit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Students, digital devices and success - Andreas Schleicher - 27 May 2024..pptx
Andreas Schleicher presents at the OECD webinar ‘Digital devices in schools: detrimental distraction or secret to success?’ on 27 May 2024. The presentation was based on findings from PISA 2022 results and the webinar helped launch the PISA in Focus ‘Managing screen time: How to protect and equip students against distraction’ https://www.oecd-ilibrary.org/education/managing-screen-time_7c225af4-en and the OECD Education Policy Perspective ‘Students, digital devices and success’ can be found here - https://oe.cd/il/5yV
Palestine last event orientationfvgnh .pptx
An EFL lesson about the current events in Palestine. It is intended to be for intermediate students who wish to increase their listening skills through a short lesson in power point.
Model Attribute Check Company Auto Property
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
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.
Home assignment II on Spectroscopy 2024 Answers.pdf
Answers to Home assignment on UV-Visible spectroscopy: Calculation of wavelength of UV-Visible absorption
Supporting (UKRI) OA monographs at Salford.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Recently uploaded (20)
Sectors of the Indian Economy - Class 10 Study Notes pdf
Sectors of the Indian Economy - Class 10 Study Notes pdf
The French Revolution Class 9 Study Material pdf free download
The French Revolution Class 9 Study Material pdf free download
MARUTI SUZUKI- A Successful Joint Venture in India.pptx
MARUTI SUZUKI- A Successful Joint Venture in India.pptx
Unit 8 - Information and Communication Technology (Paper I).pdf
Unit 8 - Information and Communication Technology (Paper I).pdf
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
Cambridge International AS A Level Biology Coursebook - EBook (MaryFosbery J...
Chapter 3 - Islamic Banking Products and Services.pptx
Chapter 3 - Islamic Banking Products and Services.pptx
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
Students, digital devices and success - Andreas Schleicher - 27 May 2024..pptx
Students, digital devices and success - Andreas Schleicher - 27 May 2024..pptx
Home assignment II on Spectroscopy 2024 Answers.pdf
Home assignment II on Spectroscopy 2024 Answers.pdf
Data Structures in C++I am really new to C++, so links are really .pdf
- 1. 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.
- 2. 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;
- 3. // 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 == NULL || which == NULL) return; /* If node to be deleted is head node */ if(*head_ref == which) *head_ref = which->next; /* Change next only if node to be deleted is NOT the last node */ if(which->next != NULL) which->next->prev = which->prev; /* Change prev only if node to be deleted is NOT the first node */ if(which->prev != NULL) which->prev->next = which->next; /* Finally, free the memory occupied by which*/ free(which); return;
- 4. } // Add a new element to the *end* of the list void push_back(int value){ // allocate node struct node* new_node = (struct node*) malloc(sizeof(struct node)); struct node* head_ref = head(); struct node *last = *head_ref; // put in the data new_node->data = value; // This new node is going to be the last node, so make next of it as NULL new_node->next = NULL; // If the Linked List is empty, then make the new node as head if (*head_ref == NULL) { new_node->prev = NULL; *head_ref = new_node; return; } // Else traverse till the last node. while (last->next != NULL) last = last->next; // Change the next of last node last->next = new_node; // Make last node as previous of new node new_node->prev = last; return; }
- 5. // Add a new element to the *beginning* of the list void push_front(int value){ //allocate node struct node* new_node = (struct node*) malloc(sizeof(struct node)); //put in the data new_node->data = value; // Make next of new node as head and previous as NULL struct node* head_ref = head(); new_node->next = (*head_ref); new_node->prev = NULL; //change prev of head node to new node if((*head_ref) != NULL) (*head_ref)->prev = new_node ; // move the head to point to the new node (*head_ref) = new_node; } // Remove the first element void pop_front(){ struct node *toDelete; struct node *head = head(); if(head == NULL) { printf("Unable to delete. List is empty. "); } else { toDelete = head; head = head->next; //Move head pointer to 2 node head->prev = NULL; //Remove the link to previous node
- 6. free(toDelete); //Delete the first node from memory printf("SUCCESSFULLY DELETED NODE FROM BEGINNING OF THE LIST. "); } } // Remove the last element void pop_back(){ struct node * toDelete; struct node *last = head(); while(last.next!=NULL) { last = last->next; } if(last == NULL) { printf("Unable to delete. List is empty. "); } else { toDelete = last; last = last->prev; //Move last pointer to 2nd last node last->next = NULL; //Remove link to of 2nd last node with last node free(toDelete); //Delete the last node printf("SUCCESSFULLY DELETED NODE FROM END OF THE LIST. "); } } // Get the size of the list int size(){ int cnt = 0; struct node* head_ref = head(); while(head_ref!=NULL)
- 7. { cnt++; head_ref = head_ref->next; } return cnt; } // Returns true if the list is empty bool empty(){ struct node* head_ref = head(); if(head_ref == NULL) return true; else return false; } private: node* _head = nullptr; node* _tail = nullptr; }; // **** Implement ALL the following functions **** /* out << l Prints a list to the ostream out. This is mostly for your convenience in testing your code; it's much easier to figure out what's going on if you can easily print out lists! */ std::ostream& operator<< (std::ostream& out, dlist& l); /* a == b Compares two lists for equality, returning true if they have the same elements in the same positions. (Hint: it is *not* enough to just compare pointers! You have to compare the values stored in the nodes.) */ bool operator== (dlist& a, dlist& b); /* a + b Returns a new list consisting of all the elements of a, followed by all the elements of b (i.e., the list concatenation).
- 8. */ dlist operator+ (dlist& a, dlist& b); /* reverse(l) Returns a new list that is the *reversal* of l; that is, a new list containing the same elements as l but in the reverse order. */ dlist reverse(dlist& l);