1#include stdio.h#include stdlib.h#include assert.h .pdf
•
0 likes•3 views
1 #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int count = 0; /* the index of the node we\'re currently looking at */ while (current != NULL) { if (count == index) return(current->data); count++; current = current->next; } /* if we get to this line, the caller was asking for a non-existent element so we assert fail */ assert(0); } /* Drier program to test above function*/ int main() { /* Start with the empty list */ struct node* head = NULL; /* Use push() to construct below list 1->12->1->4->1 */ push(&head, 1); push(&head, 4); push(&head, 1); push(&head, 12); push(&head, 1); /* Check the count function */ printf(\"Element at index 3 is %d\", GetNth(head, 3)); getchar(); } 2 #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int count = 0; /* the index of the node we\'re currently looking at */ while (current != NULL) { if (count == index) return(current->data); count++; current = current->next; } /* if we get to this line, the caller was asking for a non-existent element so we assert fail */ assert(0); } /* Drier program to test above function*/ int main() { /* Start with the empty list */ struct node* head = NULL; /* Use push() to construct below list 1->12->1->4->1 */ push(&head, 1); push(&head, 4); push(&head, 1); push(&head, 12); push(&head, 1); /* Check the count function */ printf(\"Element at index 3 is %d\", GetNth(head, 3)); getchar(); } Solution 1 #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node*.
Report
Share
Report
Share
Download to read offline
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 .
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header using C?
Solution
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
// Update current
current = next;
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* A utility function to insert a node at the beginning of linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = new node;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf(\"Linked List before sorting \ \");
printList(a);
insertionSort(&a);
printf(\"\ Linked List after sorting \ \");
printList(a);
return 0;
}
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
C++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();
}
.
Write java program using linked list to get integer from user and.docx
Write java program using linked list to get integer from user and
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 .
How to do insertion sort on a singly linked list with no header usin.pdf
How to do insertion sort on a singly linked list with no header using C?
Solution
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct node *next = current->next;
// insert current in sorted linked list
sortedInsert(&sorted, current);
// Update current
current = next;
}
// Update head_ref to point to sorted linked list
*head_ref = sorted;
}
/* function to insert a new_node in a list. Note that this
function expects a pointer to head_ref as this can modify the
head of the input linked list (similar to push())*/
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current;
/* Special case for the head end */
if (*head_ref == NULL || (*head_ref)->data >= new_node->data)
{
new_node->next = *head_ref;
*head_ref = new_node;
}
else
{
/* Locate the node before the point of insertion */
current = *head_ref;
while (current->next!=NULL &&
current->next->data < new_node->data)
{
current = current->next;
}
new_node->next = current->next;
current->next = new_node;
}
}
/* BELOW FUNCTIONS ARE JUST UTILITY TO TEST sortedInsert */
/* Function to print linked list */
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* A utility function to insert a node at the beginning of linked list */
void push(struct node** head_ref, int new_data)
{
/* allocate node */
struct node* new_node = new node;
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*head_ref);
/* move the head to point to the new node */
(*head_ref) = new_node;
}
// Driver program to test above functions
int main()
{
struct node *a = NULL;
push(&a, 5);
push(&a, 20);
push(&a, 4);
push(&a, 3);
push(&a, 30);
printf(\"Linked List before sorting \ \");
printList(a);
insertionSort(&a);
printf(\"\ Linked List after sorting \ \");
printList(a);
return 0;
}
/* C program for insertion sort on a linked list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
// Function to insert a given node in a sorted linked list
void sortedInsert(struct node**, struct node*);
// function to sort a singly linked list using insertion sort
void insertionSort(struct node **head_ref)
{
// Initialize sorted linked list
struct node *sorted = NULL;
// Traverse the given linked list and insert every
// node to sorted
struct node *current = *head_ref;
while (current != NULL)
{
// Store next for next iteration
struct.
This assignment and the next (#5) involve design and development of a.pdf
This assignment and the next (#5) involve design and development of a sequential
non contiguous and dynamic datastructure called LinkedList. A linked list object is
a container consisting of connected ListNode objects. As before, we are not going
to use pre-fabricated classes from the c++ library, but construct the LinkedList
ADT from scratch.
The first step is construction and testing of the ListNode class. A ListNode object
contains a data field and a pointer to the next ListNode object (note the recursive
definition).
#This assignment requires you to
1. Read the Assignment 4 Notes
2. Watch the Assignment 4 Support video
3. Implement the following methods of the ListNode class
-custom constructor
-setters for next pointer and data
4. Implement the insert and remove method in the main program
5. Scan the given template to find the above //TODO and implement the code
needed
//TODO in ListNodecpp.h file
public: ListNode(T idata, ListNode<T> * newNext);
public: void setNext(ListNode<T> * newNext);
public: void setData(T newData);
// TODO in main program
void remove(ListNode<int> * &front,int value)
void insert(ListNode<int> * &front,int value)
# The driver is given ListNodeMain.cpp is given to you that does the following
tests
1. Declares a pointer called front to point to a ListNode of datatype integer
2. Constructs four ListNodes with data 1,2,4 and adds them to form a linked
list.
3. Inserts ListNode with data 3 to the list
4. Removes node 1 and adds it back to test removing and adding the first
element
5. Removes node 3 to test removing a middle node
6. Removes node 4 to test removing the last node
7. Attempt to remove a non existent node
8. Remove all existing nodes to empty the list
9. Insert node 4 and then node 1 to test if insertions preserve order
10.Print the list
Main.cpp
#include <iostream>
#include "ListNodecpp.h"
// REMEMBER each ListNode has two parts : a data field
// and an address field. The address is either null or points to the next node
//in the chain
//Requires: integer value for searching, address of front
//Effects: traverses the list node chain starting from front until the end comparing search value
with listnode getData. Returns the original search value if found, if not adds +1 to indicate not
found
//Modifies: Nothing
int search(ListNode<int> * front, int value);
//Requires: integer value for inserting, address of front
//Effects: creates a new ListNode with value and inserts in proper position (increasing order)in
the chain. If chain is empty, adds to the beginning
//Modifies: front, if node is added at the beginning.
//Also changes the next pointer of the previous node to point to the
//newly inserted list node. the next pointer of the newly inserted pointer
//points to what was the next of the previous node.
//This way both previous and current links are adjusted
//******** NOTE the use of & in passing pointer to front as parameter -
// Why do you think this is needed ?**********
void insert(ListNode<int> * &fr.
C++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();
}
.
Write java program using linked list to get integer from user and.docx
Write java program using linked list to get integer from user and
Please find the answer to the above problem as follows- Program.pdf
Please find the answer to the above problem as follows:-
/* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
void sortedDelete(struct node** head_ref, int number)
{
struct node *temp = *head_ref;
struct node *prev = NULL;
if(*head_ref != NULL && (*head_ref)->data == number){
*head_ref = (*head_ref)->next;
return;
}
while(temp != NULL)
{
if(temp->data == number){
prev->next = temp->next;
free(temp);
return;
}
prev = temp;
temp = temp->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)
{
if(*head_ref != NULL&&(*head_ref)->data==new_node->data){
return;
}
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;
}
if(current->next!=NULL && current->next->data == new_node->data){
return;
}
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;
if(temp == NULL)
printf(\"\ \");
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main(int argc, char *argv[])
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node;
FILE *fp;
fp = fopen(argv[1], \"r+\");
if(!fp){
printf(\"error\");
return 1;
}
char op = \' \';
int number = 0;
while(fscanf(fp, \"%c\\t%d\ \", &op, &number)!=EOF){
if(op==\'i\'){
new_node = newNode(number);
sortedInsert(&head, new_node);
}else if(op==\'d\'){
sortedDelete(&head, number);
}else{
printf(\"error\");
return;
}
}
printList(head);
printf(\"\ \");
return 0;
}
Solution
Please find the answer to the above problem as follows:-
/* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
void sortedDelete(struct node** head_ref, int number)
{
struct node *temp = *head_ref;
struct node *prev = NULL;
if(*head_ref != NULL && (*head_ref)->data == number){
*head_ref = (*head_ref)->next;
return;
}
while(temp != NULL)
{
if(temp->data == number){
prev->next = temp->next;
free(temp);
return;
}
prev = temp;
temp = temp->next;
}
}
/* function to insert a new_node in a list. Note that this
* function expects a point.
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.
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)
B)
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include
#include
#include
using namespace std;
// Linked list node
struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure
struct BinaryTreeNode
{
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List
void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
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;
}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node
head = head->next;
// until the end of linked list is reached, do the following steps
while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent
parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion
void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->data << \" \";
inorderTraversal( root->right );
}
}
// Driver program to test above functions
int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << \"Inorder Traversal of the constructed Binary Tree is: \ \";
inorderTraversal(root);
return 0;
}
c)
#include
#include
using namespace std;
template
class bintree
{
bintree *left;
T data;
bintree *right;
public :
bintree()
{
left=right=NULL;
}
void create();
void preorder();
void inorder();
void pos.
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
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.
c++ Computational Complexity filling in the following three .pdf
c++ Computational Complexity
/* filling in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
should output
* \"HEAD->1->2->3->NULL\"
*
* 2) Node* add(Node* head, int data)
* Given the old head pointer to a list, create a new node using the value of data, and add the new
node to the front of
* the list. Return the new head pointer.
* Example: If the original list is \"HEAD->1->2->NULL\", then after adding 5, it should
become \"HEAD->5->1->2->NULL\". The
* return value should be the address of node 5.
*
* 3) void magic(Node* p1, Node* p2)
* p1 and p2 each points to a node from a same list. p1 may point to a later node than p2. Your
task is to calculate how
* many nodes are between p1 and p2. If there are k nodes in between (excluding nodes pointed
to by p1 and p2), then the
* result is k (k could be 0). Replace the data fields of all nodes between p1 and p2 by k.
* Example: The original list is \"HEAD->1->7->5->0->3->NULL\". p1 points to node 1 (the
node with value 1), p2 points to
* node 0. There are two nodes in between p1 and p2. These two nodes\' data fields need to be
replaced by k=2. The
* resulting list should be \"HEAD->1->2->2->0->3->NULL\".
*
* You should modify sections labelled as \"fill in here\". Please leave the other sections (e.g., the
main
* function and all function protocols) intact.
*/
#include
using namespace std;
struct Node {
int data;
Node* link;
};
void disp(Node* head) {
// fill in here
}
Node* add(Node* head, int data) {
// fill in here
}
void magic(Node* p1, Node* p2) {
// fill in here
}
main() {
Node* head = NULL;
Node *p4, *p7;
for(int i = 0; i < 10; i++) {
head = add(head, i);
if (i==4) p4 = head;
if (i==7) p7 = head;
}
// at this point, we have created the following list: HEAD->9->8->7->6->5->4->3->2->1->0-
>NULL
// p4 now points to node 4 (the node containing 4); p7 now points to node 7 (the node
containing 7)
magic(p4, p7);
disp(head);
// between p4 and p7, there are k=2 nodes, and these two nodes\' values will be replaced by
k=2
// the output should be: HEAD->9->8->7->2->2->4->3->2->1->0->NULL
// housekeeping (free all nodes)
Node* tmp;
while (head) {
tmp = head;
head = head->link;
delete tmp;
}
}
Comments
Expert Answer
c++ Computational Complexity
/* Your task is to fill in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
shou.
Implement the following specification of UnsortedType using circular.pdf
Implement the following specification of UnsortedType using circular linked list as the
implementation structure.
*** I have seen this question answered here before but it is not a good answer. Can someone
please give me a original answer.***
// Deliverables:
// - A listing of the specification and implementation files for UnsortedType
// - A listing of the driver program for your test plan
// - A listing of the test plan as input to the driver.
// - A listing of the output from the driver.
template
struct NodeType;
/* Assumption: ItemType is a type for which the operators
\"<\" and \"==\" are defined-either an appropriate built-in type or a
class that overloads these operators. */
template
class UnsortedType
{
public:
// Class constructor, destructor, and copy constructor
UnsortedType();
~UnsortedType();
UnsortedType(const UnsortedType&);
void operator=(UnsortedType);
bool IsFull() const;
// Determines whether list is full.
//Post: Function value = (list is full)
int GetLength() const;
// Determines the number of elements in list.
// Post: Function value = number of elements in list.
void RetrieveItem(ItemType& item, bool& found);
// Retrieves list element whose key matches item\'s key
// (if present).
// Pre: Key member of item is initialized.
// Post: If there is an element someItem whose key matches
// item\'s key, then found = true and item is a copy of
// someItem; otherwise found = false and item is unchanged.
// List is unchanged.
void InsertItem(ItemType item);
// Adds item to list.
// Pre: List is not full.
// Item is not in list.
// Post: item is in list.
void DeleteItem(ItemType item);
// Deletes the element whose key matches item\'s key
// Pre: Key member of item is initialized.
// One and only one element in list has a key matching
// item\'s key.
// Post: No element in list has a key matching item\'s key.
void ResetList();
// Initializes current position for an iteration through the list.
// Post: Current position is prior to list.
void GetNextItem(ItemType&);
// Gets the next element in list.
// Pre: Current position is defined.
// Element at current position is not last in list.
// Post: Current position is updated to next position.
// item is a copy of element at current position.
private:
NodeType* listData;
int length;
NodeType* currentPos;
};
Solution
#include
#include
/* structure for a node */
struct node
{
int data;
struct node *next;
};
/* function to insert a new_node in a list in sorted way.
Note that this function expects a pointer to head node
as this can modify the head of the input linked list */
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current = *head_ref;
// Case 1 of the above algo
if (current == NULL)
{
new_node->next = new_node;
*head_ref = new_node;
}
// Case 2 of the above algo
else if (current->data >= new_node->data)
{
/* If value is smaller than head\'s value then
we need to change next of last node */
while(current->next != *head_ref)
current = current->next;
cur.
Template LinkedList;I am using templates to make some linkedLists.pdf
Sargent Corporation bought equipment on January 1, 2013. The equipment cost $180,000 and
had an expected salvage value of $30,000. The life of the equipment was estimated to be 6 years.
The book value of the equipment at the beginning of the third year using straight-line
depreciation would be . C $180,000. $150,000. $130,000. $50,000.
Solution
As per the information provided, Sargent Corporation bought an equipment on Jan 1, 2013 for
$180000 with 6 years life and salvage value of $30000.
Therefore, depreciation expense every year as per Straight line method would be:-
Equipment cost = $180000
LESS:- Salvage value = $30000
Amount on which depriciation is to be charged =$150000
Now, depreciation as per straight line method = $150000 / 6 years
= $25000 every year
Now, book value of Equipment at the beginning of third year is:-
Equipment cost = $180000
LESS :- Depreciation for first and second year = $25000 x 2 years = $50000
Therefore, book value at begginning of third year =$130000
Hence, as per the problem \"Option C\" is correct with book value of $130000..
C code on linked list #include stdio.h #include stdlib.h.pdf
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps
Solution
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps.
tested on eclipseDoublyLinkedList class.pdf
//tested on eclipse
/*************DoublyLinkedList class*******************/
public class DoublyLinkedList {
/*Data member variable declaration*/
private Node head;
private int count;
/**default constructor*/
public DoublyLinkedList() {
/*Initializing variable*/
head=null;
count =0;
}
/*Insert at beginning in doubly linked list*/
public void insertBeginning(String name){
/*checking head is null then we will add node at head*/
if(head==null){
head=new Node(name, null, null);
count++;
}else{
/*else create temp node and setting next to head
* and then making temp to head*/
Node temp=new Node(name,null,null);
temp.setNext(head);
head.setPrev(temp);
head=temp;
count++;
}
}
public void printList(){
Node temp=head;
/*Printing element of doubly list*/
while(temp!=null){
System.out.println(temp.getData());
temp=temp.getNext();
}
}
/*Returning count from doubly linked list*/
public int count(){
return count;
}
/*deleting specific node from doubly linked list*/
public void delete(String name){
Node current=head,previous=head;
/*if it is head node to be deleted*/
if(head.getData().equals(name)){
current=head.getNext();
current.setPrev(null);
head=current;
previous=head;
}else{
/*If node in middle of list*/
while(current.getNext()!=null){
if(current.getData().equals(name)){
current.getNext().setPrev(previous);
previous.setNext(current.getNext());
count--;
break;
}
previous=current;
current=current.getNext();
}
/*If node is at last*/
if(current.getNext()==null){
if(current.getData().equals(name)){
previous.setNext(null);
count--;
}
}
}
}
/*deleting all nodes from list by assigning head to null
* and memory releasing take care by garbage collector*/
public void clear(){
head=null;
count=0;
}
/*Inserting element in alphabetic order*/
public void insertAlpha(String name){
Node current=head,previous=head;
/*creating new node*/
Node newNode=new Node(name,null,null);
/*if head node is null*/
if(head==null){
head=newNode;
count++;
}else{
/*please read about compareTo() method about returning value*/
if(head.getData().compareTo(name)>0){
newNode.setNext(head);
head=newNode;
count++;
}else{
/*condition for getting position of node to be inserted*/
while(current!=null&¤t.getData().compareTo(name)<=0){
previous=current;
current=current.getNext();
}
/*if node need to be inserted at last*/
if(current==null){
previous=newNode;
}else{
/*If node need to inserted in middle*/
newNode.setNext(current);
previous.setNext(newNode);
current.setPrev(newNode);
newNode.setPrev(previous);
}
count++;
}
}
}
/*Main method start*/
public static void main(String args[]){
/*creating object of doubly linked list*/
DoublyLinkedList doublyLinkedList=new DoublyLinkedList();
doublyLinkedList.insertBeginning(\"sunita\");
doublyLinkedList.insertBeginning(\"lalchand\");
/*calling alphabetic order method*/
doublyLinkedList.insertAlpha(\"ramsingh\");
doublyLinkedList.insertBeginning(\"Lokesh\");
doublyLinkedList.insertBeginning(\"Pritam\");
/*****printing list********/
doublyLinkedList.printL.
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
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.
main.cpp#include TreeNode.h GIVEN void inorderTraversal(.pdf
main.cpp
#include "TreeNode.h"
//GIVEN
void inorderTraversal(TreeNode * root);
//TODO
TreeNode * search(TreeNode * node,int data);
//GIVEN
void insert(TreeNode * node,int data);
//GIVEN
bool isNull(TreeNode * node){
return node==nullptr;
}
int main() {
// create the root, gets set to null
TreeNode * root;
// create the roor and set the data of root to 5
root= new TreeNode(5);
//create two additional nodes with data values 10 and 3
// these will go to the right and left of root respectively
TreeNode * ten= new TreeNode(10);
TreeNode * three= new TreeNode(3);
//connect ten to the right of root (which has data 5)
root->setRight(ten);
//connect three to the left of root (which has data 5)
root->setLeft(three);
// note this can also be done as
//root.setRight(new TreeNode(10));
//root.setLeft(new TreeNode(3);)
// add two more nodes
//the first has data value 7. So to keep the tree in insorted order, it should get attached as the left
node of ten
// the second has data value 4. So to keep the tree in insorted order, it should get attached as the
right node of three
ten->addLeft(7);
three->addRight(4);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
std::cout<<"**************************************\n";
std::cout<<"Searching for Node \n";
TreeNode* result = search(root,4);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<4<<"\n";
result = search(root,1);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<1<<"\n";
std::cout<<"**************************************\n";
std::cout<<"Inserting 6\n";
insert(root,6);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
}
// uses recursion
void inorderTraversal(TreeNode * node){
// exit case
if (isNull(node)) return;
if (node->isLeaf()){
std::cout<<"Printing Leaf Node "<getData()<<"\n";
return;}
// reached a node with no left, so print the node and travel right
if (!isNull(node->getLeft()))
// if there is a left path, then travel further on that
inorderTraversal(node->getLeft());
std::cout<<"Printing Node "<getData()<<"\n";
// save and travel the right path of the current node being processed
inorderTraversal(node->getRight());
}
// uses recursion
//TODO
TreeNode * search(TreeNode * node, int data){
// if the node is null return the null ptr
//if this nodes data equals the search date return found
// if not, if the left tree exists and search data less than
//this nodes data return the result of recursive all to search with left pointer
// if no left tree, but right tree exists and search data greater than
//this nodes data return the result of recursive all to search with right pointer
// if both above conditions not true return null ptr
}
//uses recursion
void insert(TreeNode * node,int data){
if (node->getData()==data)
return;
else if(datagetData()){
if (!isNull(node->getLeft.
C++ Please write the whole code that is needed for this assignment- wr.docx
Brianca plans to save $5,000, $1,000, and $42,000 a year over the next three years, respectively. How much would you need to deposit in one lump sum today to have the same amount as Brianca three years from now if you both earn 10.9 percent, compounded annually? $36,115 $35,192 $43,282 $41,635 $35,372
.
1.Rule based detection 2.Statical anomaly detection1.Rule based de.pdf
1.Rule based detection 2.Statical anomaly detection
1.Rule based detection :
a set of rules are used to decide the behaviour of an intruder
in this detection we have anomaly detection and penitration identification .in anomaly detection
rules are developed to detect deviation from previous usage patterns. in penitration identification
an expert system approach that searches for suspecious behaviour
2.Statistical anomaly datection :
the collection of data relating to the behaviour of legitimate users over a period of time. then
statistical tests are applied to observed behaviour to determine with a high level of confidence
whethear that behaviour is not legitimate user behaviour
in this detection we have threshold detection and profile based detection .in threshold detection it
approaches to defining thresholds,independent of user,for the frequency of occurence of various
events and in profile based a profile of the activity of each user is developed and used to detect
changes in the behaviour of individual accounts.
Solution
1.Rule based detection 2.Statical anomaly detection
1.Rule based detection :
a set of rules are used to decide the behaviour of an intruder
in this detection we have anomaly detection and penitration identification .in anomaly detection
rules are developed to detect deviation from previous usage patterns. in penitration identification
an expert system approach that searches for suspecious behaviour
2.Statistical anomaly datection :
the collection of data relating to the behaviour of legitimate users over a period of time. then
statistical tests are applied to observed behaviour to determine with a high level of confidence
whethear that behaviour is not legitimate user behaviour
in this detection we have threshold detection and profile based detection .in threshold detection it
approaches to defining thresholds,independent of user,for the frequency of occurence of various
events and in profile based a profile of the activity of each user is developed and used to detect
changes in the behaviour of individual accounts..
14 = disease ff24 = carriers Ff25 chances that they will pro.pdf
1/4 = disease ff
2/4 = carriers Ff
25 % chances that they will produce a child which suffers from the
disorder
50 % percentage of offspring will be carriersFfFFFFffFfff
Solution
1/4 = disease ff
2/4 = carriers Ff
25 % chances that they will produce a child which suffers from the
disorder
50 % percentage of offspring will be carriersFfFFFFffFfff.
More Related Content
Similar to 1#include stdio.h#include stdlib.h#include assert.h .pdf
Please find the answer to the above problem as follows- Program.pdf
Please find the answer to the above problem as follows:-
/* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
void sortedDelete(struct node** head_ref, int number)
{
struct node *temp = *head_ref;
struct node *prev = NULL;
if(*head_ref != NULL && (*head_ref)->data == number){
*head_ref = (*head_ref)->next;
return;
}
while(temp != NULL)
{
if(temp->data == number){
prev->next = temp->next;
free(temp);
return;
}
prev = temp;
temp = temp->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)
{
if(*head_ref != NULL&&(*head_ref)->data==new_node->data){
return;
}
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;
}
if(current->next!=NULL && current->next->data == new_node->data){
return;
}
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;
if(temp == NULL)
printf(\"\ \");
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
/* Drier program to test count function*/
int main(int argc, char *argv[])
{
/* Start with the empty list */
struct node* head = NULL;
struct node *new_node;
FILE *fp;
fp = fopen(argv[1], \"r+\");
if(!fp){
printf(\"error\");
return 1;
}
char op = \' \';
int number = 0;
while(fscanf(fp, \"%c\\t%d\ \", &op, &number)!=EOF){
if(op==\'i\'){
new_node = newNode(number);
sortedInsert(&head, new_node);
}else if(op==\'d\'){
sortedDelete(&head, number);
}else{
printf(\"error\");
return;
}
}
printList(head);
printf(\"\ \");
return 0;
}
Solution
Please find the answer to the above problem as follows:-
/* Program to insert in a sorted list */
#include
#include
/* Link list node */
struct node
{
int data;
struct node* next;
};
void sortedDelete(struct node** head_ref, int number)
{
struct node *temp = *head_ref;
struct node *prev = NULL;
if(*head_ref != NULL && (*head_ref)->data == number){
*head_ref = (*head_ref)->next;
return;
}
while(temp != NULL)
{
if(temp->data == number){
prev->next = temp->next;
free(temp);
return;
}
prev = temp;
temp = temp->next;
}
}
/* function to insert a new_node in a list. Note that this
* function expects a point.
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.
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)
B)
// C++ program to create a Complete Binary tree from its Linked List
// Representation
#include
#include
#include
using namespace std;
// Linked list node
struct ListNode
{
int data;
ListNode* next;
};
// Binary tree node structure
struct BinaryTreeNode
{
int data;
BinaryTreeNode *left, *right;
};
// Function to insert a node at the beginning of the Linked List
void push(struct ListNode** head_ref, int new_data)
{
// allocate node and assign data
struct ListNode* new_node = new ListNode;
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;
}
// method to create a new binary tree node from the given data
BinaryTreeNode* newBinaryTreeNode(int data)
{
BinaryTreeNode *temp = new BinaryTreeNode;
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// converts a given linked list representing a complete binary tree into the
// linked representation of binary tree.
void convertList2Binary(ListNode *head, BinaryTreeNode* &root)
{
// queue to store the parent nodes
queue q;
// Base Case
if (head == NULL)
{
root = NULL; // Note that root is passed by reference
return;
}
// 1.) The first node is always the root node, and add it to the queue
root = newBinaryTreeNode(head->data);
q.push(root);
// advance the pointer to the next node
head = head->next;
// until the end of linked list is reached, do the following steps
while (head)
{
// 2.a) take the parent node from the q and remove it from q
BinaryTreeNode* parent = q.front();
q.pop();
// 2.c) take next two nodes from the linked list. We will add
// them as children of the current parent node in step 2.b. Push them
// into the queue so that they will be parents to the future nodes
BinaryTreeNode *leftChild = NULL, *rightChild = NULL;
leftChild = newBinaryTreeNode(head->data);
q.push(leftChild);
head = head->next;
if (head)
{
rightChild = newBinaryTreeNode(head->data);
q.push(rightChild);
head = head->next;
}
// 2.b) assign the left and right children of parent
parent->left = leftChild;
parent->right = rightChild;
}
}
// Utility function to traverse the binary tree after conversion
void inorderTraversal(BinaryTreeNode* root)
{
if (root)
{
inorderTraversal( root->left );
cout << root->data << \" \";
inorderTraversal( root->right );
}
}
// Driver program to test above functions
int main()
{
// create a linked list shown in above diagram
struct ListNode* head = NULL;
push(&head, 36); /* Last node of Linked List */
push(&head, 30);
push(&head, 25);
push(&head, 15);
push(&head, 12);
push(&head, 10); /* First node of Linked List */
BinaryTreeNode *root;
convertList2Binary(head, root);
cout << \"Inorder Traversal of the constructed Binary Tree is: \ \";
inorderTraversal(root);
return 0;
}
c)
#include
#include
using namespace std;
template
class bintree
{
bintree *left;
T data;
bintree *right;
public :
bintree()
{
left=right=NULL;
}
void create();
void preorder();
void inorder();
void pos.
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++
I am really new to C++, so links are really hard topic for me. It would be nice if you can provide
explanations of what doubly linked lists are and of some of you steps... Thank you
In this assignment, you will implement a doubly-linked list class, together with some list
operations. To make things easier, you’ll implement a list of int, rather than a template class.
Solution
A variable helps us to identify the data. For ex: int a = 5; Here 5 is identified through variable a.
Now, if we have collection of integers, we need some representation to identify them. We call it
array. For ex: int arr[5]
This array is nothing but a Data Structure.
So, a Data Structure is a way to group the data.
There are many Data Structures available like Arrays, Linked List, Doubly-Linked list, Stack,
Queue, etc.
Doubly-Linked list are the ones where you can traverse from the current node both in left and
right directions.
Why so many different types of Data Structures are required ?
Answer is very simple, grouping of data, storage of data and accessing the data is different.
For example, in case of Arrays we store all the data in contiguous locations.
What if we are not able to store the data in contiguous locations because we have huge data.
Answer is go for Linked List/Doubly-Linked list.
Here we can store the data anywhere and link the data through pointers.
I will try to provide comments for the code you have given. May be this can help you.
#pragma once
/*
dlist.h
Doubly-linked lists of ints
*/
#include
class dlist {
public:
dlist() { }
// Here we are creating a NODE, it has a integer value and two pointers.
// One pointer is to move to next node and other to go back to previous node.
struct node {
int value;
node* next;
node* prev;
};
// To return head pointer, i.e. start of the Doubly-Linked list.
node* head() const { return _head; }
// To return Tail pointer, i.e. end of the Doubly-Linked list.
node* tail() const { return _tail; }
// **** Implement ALL the following methods ****
// Returns the node at a particular index (0 is the head).
node* at(int index){
int cnt = 0;
struct node* tmp = head();
while(tmp!=NULL)
{
if (cnt+1 == index)
return tmp;
tmp = tmp->next;
}
}
// Insert a new value, after an existing one
void insert(node *previous, int value){
// check if the given previous is NULL
if (previous == NULL)
{
printf(\"the given previous node cannot be NULL\");
return;
}
// allocate new node
struct node* new_node =(struct node*) malloc(sizeof(struct node));
// put in the data
new_node->data = new_data;
// Make next of new node as next of previous
new_node->next = previous->next;
// Make the next of previous as new_node
previous->next = new_node;
// Make previous as previous of new_node
new_node->prev = previous;
// Change previous of new_node\'s next node
if (new_node->next != NULL)
new_node->next->prev = new_node;
}
// Delete the given node
void del(node* which){
struct node* head_ref = head();
/* base case */
if(*head_ref == NUL.
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.
c++ Computational Complexity filling in the following three .pdf
c++ Computational Complexity
/* filling in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
should output
* \"HEAD->1->2->3->NULL\"
*
* 2) Node* add(Node* head, int data)
* Given the old head pointer to a list, create a new node using the value of data, and add the new
node to the front of
* the list. Return the new head pointer.
* Example: If the original list is \"HEAD->1->2->NULL\", then after adding 5, it should
become \"HEAD->5->1->2->NULL\". The
* return value should be the address of node 5.
*
* 3) void magic(Node* p1, Node* p2)
* p1 and p2 each points to a node from a same list. p1 may point to a later node than p2. Your
task is to calculate how
* many nodes are between p1 and p2. If there are k nodes in between (excluding nodes pointed
to by p1 and p2), then the
* result is k (k could be 0). Replace the data fields of all nodes between p1 and p2 by k.
* Example: The original list is \"HEAD->1->7->5->0->3->NULL\". p1 points to node 1 (the
node with value 1), p2 points to
* node 0. There are two nodes in between p1 and p2. These two nodes\' data fields need to be
replaced by k=2. The
* resulting list should be \"HEAD->1->2->2->0->3->NULL\".
*
* You should modify sections labelled as \"fill in here\". Please leave the other sections (e.g., the
main
* function and all function protocols) intact.
*/
#include
using namespace std;
struct Node {
int data;
Node* link;
};
void disp(Node* head) {
// fill in here
}
Node* add(Node* head, int data) {
// fill in here
}
void magic(Node* p1, Node* p2) {
// fill in here
}
main() {
Node* head = NULL;
Node *p4, *p7;
for(int i = 0; i < 10; i++) {
head = add(head, i);
if (i==4) p4 = head;
if (i==7) p7 = head;
}
// at this point, we have created the following list: HEAD->9->8->7->6->5->4->3->2->1->0-
>NULL
// p4 now points to node 4 (the node containing 4); p7 now points to node 7 (the node
containing 7)
magic(p4, p7);
disp(head);
// between p4 and p7, there are k=2 nodes, and these two nodes\' values will be replaced by
k=2
// the output should be: HEAD->9->8->7->2->2->4->3->2->1->0->NULL
// housekeeping (free all nodes)
Node* tmp;
while (head) {
tmp = head;
head = head->link;
delete tmp;
}
}
Comments
Expert Answer
c++ Computational Complexity
/* Your task is to fill in the
* following three functions:
*
* 1) void disp(Node* head)
* Given a head pointer to a list, display the list using cout.
* If the list is empty, you should output \"HEAD->NULL\" (without the enclosing \").
* If the list contains one node whose data value is 3, you should output \"HEAD->3->NULL\".
* If the list contains three nodes and the data values are 1, 2, and 3, respectively, then you
shou.
Implement the following specification of UnsortedType using circular.pdf
Implement the following specification of UnsortedType using circular linked list as the
implementation structure.
*** I have seen this question answered here before but it is not a good answer. Can someone
please give me a original answer.***
// Deliverables:
// - A listing of the specification and implementation files for UnsortedType
// - A listing of the driver program for your test plan
// - A listing of the test plan as input to the driver.
// - A listing of the output from the driver.
template
struct NodeType;
/* Assumption: ItemType is a type for which the operators
\"<\" and \"==\" are defined-either an appropriate built-in type or a
class that overloads these operators. */
template
class UnsortedType
{
public:
// Class constructor, destructor, and copy constructor
UnsortedType();
~UnsortedType();
UnsortedType(const UnsortedType&);
void operator=(UnsortedType);
bool IsFull() const;
// Determines whether list is full.
//Post: Function value = (list is full)
int GetLength() const;
// Determines the number of elements in list.
// Post: Function value = number of elements in list.
void RetrieveItem(ItemType& item, bool& found);
// Retrieves list element whose key matches item\'s key
// (if present).
// Pre: Key member of item is initialized.
// Post: If there is an element someItem whose key matches
// item\'s key, then found = true and item is a copy of
// someItem; otherwise found = false and item is unchanged.
// List is unchanged.
void InsertItem(ItemType item);
// Adds item to list.
// Pre: List is not full.
// Item is not in list.
// Post: item is in list.
void DeleteItem(ItemType item);
// Deletes the element whose key matches item\'s key
// Pre: Key member of item is initialized.
// One and only one element in list has a key matching
// item\'s key.
// Post: No element in list has a key matching item\'s key.
void ResetList();
// Initializes current position for an iteration through the list.
// Post: Current position is prior to list.
void GetNextItem(ItemType&);
// Gets the next element in list.
// Pre: Current position is defined.
// Element at current position is not last in list.
// Post: Current position is updated to next position.
// item is a copy of element at current position.
private:
NodeType* listData;
int length;
NodeType* currentPos;
};
Solution
#include
#include
/* structure for a node */
struct node
{
int data;
struct node *next;
};
/* function to insert a new_node in a list in sorted way.
Note that this function expects a pointer to head node
as this can modify the head of the input linked list */
void sortedInsert(struct node** head_ref, struct node* new_node)
{
struct node* current = *head_ref;
// Case 1 of the above algo
if (current == NULL)
{
new_node->next = new_node;
*head_ref = new_node;
}
// Case 2 of the above algo
else if (current->data >= new_node->data)
{
/* If value is smaller than head\'s value then
we need to change next of last node */
while(current->next != *head_ref)
current = current->next;
cur.
Template LinkedList;I am using templates to make some linkedLists.pdf
Sargent Corporation bought equipment on January 1, 2013. The equipment cost $180,000 and
had an expected salvage value of $30,000. The life of the equipment was estimated to be 6 years.
The book value of the equipment at the beginning of the third year using straight-line
depreciation would be . C $180,000. $150,000. $130,000. $50,000.
Solution
As per the information provided, Sargent Corporation bought an equipment on Jan 1, 2013 for
$180000 with 6 years life and salvage value of $30000.
Therefore, depreciation expense every year as per Straight line method would be:-
Equipment cost = $180000
LESS:- Salvage value = $30000
Amount on which depriciation is to be charged =$150000
Now, depreciation as per straight line method = $150000 / 6 years
= $25000 every year
Now, book value of Equipment at the beginning of third year is:-
Equipment cost = $180000
LESS :- Depreciation for first and second year = $25000 x 2 years = $50000
Therefore, book value at begginning of third year =$130000
Hence, as per the problem \"Option C\" is correct with book value of $130000..
C code on linked list #include stdio.h #include stdlib.h.pdf
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps
Solution
For the ethanol water graph the simple distillation should be a steady smooth
increase, the fractional distillation should look like an s, that sort of takes a straight up jump in
the middle. I am unsure about the other mixture though sorry, hope that helps.
tested on eclipseDoublyLinkedList class.pdf
//tested on eclipse
/*************DoublyLinkedList class*******************/
public class DoublyLinkedList {
/*Data member variable declaration*/
private Node head;
private int count;
/**default constructor*/
public DoublyLinkedList() {
/*Initializing variable*/
head=null;
count =0;
}
/*Insert at beginning in doubly linked list*/
public void insertBeginning(String name){
/*checking head is null then we will add node at head*/
if(head==null){
head=new Node(name, null, null);
count++;
}else{
/*else create temp node and setting next to head
* and then making temp to head*/
Node temp=new Node(name,null,null);
temp.setNext(head);
head.setPrev(temp);
head=temp;
count++;
}
}
public void printList(){
Node temp=head;
/*Printing element of doubly list*/
while(temp!=null){
System.out.println(temp.getData());
temp=temp.getNext();
}
}
/*Returning count from doubly linked list*/
public int count(){
return count;
}
/*deleting specific node from doubly linked list*/
public void delete(String name){
Node current=head,previous=head;
/*if it is head node to be deleted*/
if(head.getData().equals(name)){
current=head.getNext();
current.setPrev(null);
head=current;
previous=head;
}else{
/*If node in middle of list*/
while(current.getNext()!=null){
if(current.getData().equals(name)){
current.getNext().setPrev(previous);
previous.setNext(current.getNext());
count--;
break;
}
previous=current;
current=current.getNext();
}
/*If node is at last*/
if(current.getNext()==null){
if(current.getData().equals(name)){
previous.setNext(null);
count--;
}
}
}
}
/*deleting all nodes from list by assigning head to null
* and memory releasing take care by garbage collector*/
public void clear(){
head=null;
count=0;
}
/*Inserting element in alphabetic order*/
public void insertAlpha(String name){
Node current=head,previous=head;
/*creating new node*/
Node newNode=new Node(name,null,null);
/*if head node is null*/
if(head==null){
head=newNode;
count++;
}else{
/*please read about compareTo() method about returning value*/
if(head.getData().compareTo(name)>0){
newNode.setNext(head);
head=newNode;
count++;
}else{
/*condition for getting position of node to be inserted*/
while(current!=null&¤t.getData().compareTo(name)<=0){
previous=current;
current=current.getNext();
}
/*if node need to be inserted at last*/
if(current==null){
previous=newNode;
}else{
/*If node need to inserted in middle*/
newNode.setNext(current);
previous.setNext(newNode);
current.setPrev(newNode);
newNode.setPrev(previous);
}
count++;
}
}
}
/*Main method start*/
public static void main(String args[]){
/*creating object of doubly linked list*/
DoublyLinkedList doublyLinkedList=new DoublyLinkedList();
doublyLinkedList.insertBeginning(\"sunita\");
doublyLinkedList.insertBeginning(\"lalchand\");
/*calling alphabetic order method*/
doublyLinkedList.insertAlpha(\"ramsingh\");
doublyLinkedList.insertBeginning(\"Lokesh\");
doublyLinkedList.insertBeginning(\"Pritam\");
/*****printing list********/
doublyLinkedList.printL.
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
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.
main.cpp#include TreeNode.h GIVEN void inorderTraversal(.pdf
main.cpp
#include "TreeNode.h"
//GIVEN
void inorderTraversal(TreeNode * root);
//TODO
TreeNode * search(TreeNode * node,int data);
//GIVEN
void insert(TreeNode * node,int data);
//GIVEN
bool isNull(TreeNode * node){
return node==nullptr;
}
int main() {
// create the root, gets set to null
TreeNode * root;
// create the roor and set the data of root to 5
root= new TreeNode(5);
//create two additional nodes with data values 10 and 3
// these will go to the right and left of root respectively
TreeNode * ten= new TreeNode(10);
TreeNode * three= new TreeNode(3);
//connect ten to the right of root (which has data 5)
root->setRight(ten);
//connect three to the left of root (which has data 5)
root->setLeft(three);
// note this can also be done as
//root.setRight(new TreeNode(10));
//root.setLeft(new TreeNode(3);)
// add two more nodes
//the first has data value 7. So to keep the tree in insorted order, it should get attached as the left
node of ten
// the second has data value 4. So to keep the tree in insorted order, it should get attached as the
right node of three
ten->addLeft(7);
three->addRight(4);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
std::cout<<"**************************************\n";
std::cout<<"Searching for Node \n";
TreeNode* result = search(root,4);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<4<<"\n";
result = search(root,1);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<1<<"\n";
std::cout<<"**************************************\n";
std::cout<<"Inserting 6\n";
insert(root,6);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
}
// uses recursion
void inorderTraversal(TreeNode * node){
// exit case
if (isNull(node)) return;
if (node->isLeaf()){
std::cout<<"Printing Leaf Node "<getData()<<"\n";
return;}
// reached a node with no left, so print the node and travel right
if (!isNull(node->getLeft()))
// if there is a left path, then travel further on that
inorderTraversal(node->getLeft());
std::cout<<"Printing Node "<getData()<<"\n";
// save and travel the right path of the current node being processed
inorderTraversal(node->getRight());
}
// uses recursion
//TODO
TreeNode * search(TreeNode * node, int data){
// if the node is null return the null ptr
//if this nodes data equals the search date return found
// if not, if the left tree exists and search data less than
//this nodes data return the result of recursive all to search with left pointer
// if no left tree, but right tree exists and search data greater than
//this nodes data return the result of recursive all to search with right pointer
// if both above conditions not true return null ptr
}
//uses recursion
void insert(TreeNode * node,int data){
if (node->getData()==data)
return;
else if(datagetData()){
if (!isNull(node->getLeft.
C++ Please write the whole code that is needed for this assignment- wr.docx
Brianca plans to save $5,000, $1,000, and $42,000 a year over the next three years, respectively. How much would you need to deposit in one lump sum today to have the same amount as Brianca three years from now if you both earn 10.9 percent, compounded annually? $36,115 $35,192 $43,282 $41,635 $35,372
.
Similar to 1#include stdio.h#include stdlib.h#include assert.h .pdf (20)
Please find the answer to the above problem as follows- Program.pdf
Please find the answer to the above problem as follows- Program.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
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
A)B) C++ program to create a Complete Binary tree from its Lin.pdf
Data Structures in C++I am really new to C++, so links are really .pdf
Data Structures in C++I am really new to C++, so links are really .pdf
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
c++ Computational Complexity filling in the following three .pdf
c++ Computational Complexity filling in the following three .pdf
Implement the following specification of UnsortedType using circular.pdf
Implement the following specification of UnsortedType using circular.pdf
Template LinkedList;I am using templates to make some linkedLists.pdf
Template LinkedList;I am using templates to make some linkedLists.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
C code on linked list #include stdio.h #include stdlib.h.pdf
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 04 Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
Consider a double-linked linked list implementation with the followin.pdf
Consider a double-linked linked list implementation with the followin.pdf
main.cpp#include TreeNode.h GIVEN void inorderTraversal(.pdf
main.cpp#include TreeNode.h GIVEN void inorderTraversal(.pdf
C++ Please write the whole code that is needed for this assignment- wr.docx
C++ Please write the whole code that is needed for this assignment- wr.docx
More from sudhinjv
1.Rule based detection 2.Statical anomaly detection1.Rule based de.pdf
1.Rule based detection 2.Statical anomaly detection
1.Rule based detection :
a set of rules are used to decide the behaviour of an intruder
in this detection we have anomaly detection and penitration identification .in anomaly detection
rules are developed to detect deviation from previous usage patterns. in penitration identification
an expert system approach that searches for suspecious behaviour
2.Statistical anomaly datection :
the collection of data relating to the behaviour of legitimate users over a period of time. then
statistical tests are applied to observed behaviour to determine with a high level of confidence
whethear that behaviour is not legitimate user behaviour
in this detection we have threshold detection and profile based detection .in threshold detection it
approaches to defining thresholds,independent of user,for the frequency of occurence of various
events and in profile based a profile of the activity of each user is developed and used to detect
changes in the behaviour of individual accounts.
Solution
1.Rule based detection 2.Statical anomaly detection
1.Rule based detection :
a set of rules are used to decide the behaviour of an intruder
in this detection we have anomaly detection and penitration identification .in anomaly detection
rules are developed to detect deviation from previous usage patterns. in penitration identification
an expert system approach that searches for suspecious behaviour
2.Statistical anomaly datection :
the collection of data relating to the behaviour of legitimate users over a period of time. then
statistical tests are applied to observed behaviour to determine with a high level of confidence
whethear that behaviour is not legitimate user behaviour
in this detection we have threshold detection and profile based detection .in threshold detection it
approaches to defining thresholds,independent of user,for the frequency of occurence of various
events and in profile based a profile of the activity of each user is developed and used to detect
changes in the behaviour of individual accounts..
14 = disease ff24 = carriers Ff25 chances that they will pro.pdf
1/4 = disease ff
2/4 = carriers Ff
25 % chances that they will produce a child which suffers from the
disorder
50 % percentage of offspring will be carriersFfFFFFffFfff
Solution
1/4 = disease ff
2/4 = carriers Ff
25 % chances that they will produce a child which suffers from the
disorder
50 % percentage of offspring will be carriersFfFFFFffFfff.
Mosses, lichens are great indicators of radioactive pollution. They .pdf
Mosses, lichens are great indicators of radioactive pollution. They absorb radioactive elements
specifically caesium as it is similar to patassium which forms important nutrient of mosses.
Edible mushrooms too get contaminated with such harmful elements. Hence mosses and lichens
serve as indicators for radioactive pollution areas. Inorder to check such pollution, one can
collect moss samples and check their element content of radioactive pollution. Elements like
lead, caesium, barium, titanium, berrylium are the important elements contributing o radioactive
pollution. Mosses show mutations involving somatic type giving out flowers of different colors.
Also, the mosses get damaged by reducing the plant vigor.
Solution
Mosses, lichens are great indicators of radioactive pollution. They absorb radioactive elements
specifically caesium as it is similar to patassium which forms important nutrient of mosses.
Edible mushrooms too get contaminated with such harmful elements. Hence mosses and lichens
serve as indicators for radioactive pollution areas. Inorder to check such pollution, one can
collect moss samples and check their element content of radioactive pollution. Elements like
lead, caesium, barium, titanium, berrylium are the important elements contributing o radioactive
pollution. Mosses show mutations involving somatic type giving out flowers of different colors.
Also, the mosses get damaged by reducing the plant vigor..
10 million.Sensory conflict theory argues , The brightest light at.pdf
10 million.
Sensory conflict theory argues , The brightest light at which we can see is about 10 million times
as intense as the dimmest light at which we can see.
Solution
10 million.
Sensory conflict theory argues , The brightest light at which we can see is about 10 million times
as intense as the dimmest light at which we can see..
We first find the slopes of the two lines 2M an.pdf
We first find the slopes of the two lines: 2/M and -1/4 For two lines to be
perpendicylar, the product of their slopes must be equal to -1. Hence the equation (2/M)*(-1/4) =
-1. Solve for M to find M = 1/2.
Solution
We first find the slopes of the two lines: 2/M and -1/4 For two lines to be
perpendicylar, the product of their slopes must be equal to -1. Hence the equation (2/M)*(-1/4) =
-1. Solve for M to find M = 1/2..
SO2 is a gas that mixes with water to form sulfur.pdf
SO2 is a gas that mixes with water to form sulfuric acid. The droplets can form
clouds like water does (Venus is covered with them making it bright). Sulfuric acid has a high
albedo (it reflects light), since it reflects the light, the energy it blocked from coming down.
Therefore the electromagnetic radiation (aka light) cannot is not converted into thermal energy
(it converts from light to thermal when it smacks into things). Therefore since the light cannot
make it to the surface, the thermal energy will decrease (molecules will slow down) and the
temperature will theoretically drop. :) I said theoretically because I\'m not quite sure how strong
of a greenhouse gas CO2 is (I\'m not sure if it would trap any heat that did manage to get in) as
compared to water vapor, but it doesn\'t sound like they care about that. :) Anyway sorry if I
wrote that in a confusing way, basically the light will reflect off the clouds of sulfuric acid and so
the light can\'t heat up the earth. Also, its better in the stratosphere because the sooner the light is
blocked, the less it will heat up molecules it smacks into on the way down.
Solution
SO2 is a gas that mixes with water to form sulfuric acid. The droplets can form
clouds like water does (Venus is covered with them making it bright). Sulfuric acid has a high
albedo (it reflects light), since it reflects the light, the energy it blocked from coming down.
Therefore the electromagnetic radiation (aka light) cannot is not converted into thermal energy
(it converts from light to thermal when it smacks into things). Therefore since the light cannot
make it to the surface, the thermal energy will decrease (molecules will slow down) and the
temperature will theoretically drop. :) I said theoretically because I\'m not quite sure how strong
of a greenhouse gas CO2 is (I\'m not sure if it would trap any heat that did manage to get in) as
compared to water vapor, but it doesn\'t sound like they care about that. :) Anyway sorry if I
wrote that in a confusing way, basically the light will reflect off the clouds of sulfuric acid and so
the light can\'t heat up the earth. Also, its better in the stratosphere because the sooner the light is
blocked, the less it will heat up molecules it smacks into on the way down..
1. Heterozygosity by migration calculated using the below formulaH.pdf
1. Heterozygosity by migration calculated using the below formula
H= 1 - F
where F= finite population
N= Population size
F= 1/ (2N)
By substituting F = 1/ (2N) in H= 1- F
H= 1 - 1/ 2N
H= 1 - 1/2 x 1000 = 0.9995
2. Heterozygosity by mutational drift can be calculated using
H= 4Nu / 1+ 4Nu
u= mutation rate
H= 4 x 1000 x 1 x 10-9 / 1 + 4 x 1000 x 10-9 = 3.9 x 10-6
Heterozygosity is decreased by mutation and migration. The differences in the values is large
because large mutation rates causes totally shift of the population and evolves into new species.
But migration will not act as fast as mutation .
Solution
1. Heterozygosity by migration calculated using the below formula
H= 1 - F
where F= finite population
N= Population size
F= 1/ (2N)
By substituting F = 1/ (2N) in H= 1- F
H= 1 - 1/ 2N
H= 1 - 1/2 x 1000 = 0.9995
2. Heterozygosity by mutational drift can be calculated using
H= 4Nu / 1+ 4Nu
u= mutation rate
H= 4 x 1000 x 1 x 10-9 / 1 + 4 x 1000 x 10-9 = 3.9 x 10-6
Heterozygosity is decreased by mutation and migration. The differences in the values is large
because large mutation rates causes totally shift of the population and evolves into new species.
But migration will not act as fast as mutation ..
1).Monohybrid cross between true breeding parents. Assume that the.pdf
1).
Monohybrid cross between true breeding parents. Assume that the gene “A” is dominant and “a”
is recessive. The genotype of parents are, AA (true breeding for dominant), aa (true breeding for
recessive).
Genotypes of the true-breeding parents in the _____parental___ generation are ___AA__ and
___aa_.
Genotype(s) of the offspring from the true-breeding parents is(are)_Aa____and the symbol for
this generation of offspring is __F1__.
Punnet square: AA (male) and aa (female)
A
A
a
Aa
Aa
a
Aa
Aa
A
A
a
Aa
Aa
a
Aa
Aa
Solution
1).
Monohybrid cross between true breeding parents. Assume that the gene “A” is dominant and “a”
is recessive. The genotype of parents are, AA (true breeding for dominant), aa (true breeding for
recessive).
Genotypes of the true-breeding parents in the _____parental___ generation are ___AA__ and
___aa_.
Genotype(s) of the offspring from the true-breeding parents is(are)_Aa____and the symbol for
this generation of offspring is __F1__.
Punnet square: AA (male) and aa (female)
A
A
a
Aa
Aa
a
Aa
Aa
A
A
a
Aa
Aa
a
Aa
Aa.
1. Moving down a group, the electronegativity decreases due to the l.pdf
1. Moving down a group, the electronegativity decreases due to the longer distance between the
nucleus and the valence electron shell, thereby decreasing the attraction, making the atom have
less of an attraction for electrons or protons. 2.Trend-wise, as one moves from left to right across
a period in the periodic table, the electronegativity increases due to the stronger attraction that
the atoms obtain as the nuclear charge increases.
Solution
1. Moving down a group, the electronegativity decreases due to the longer distance between the
nucleus and the valence electron shell, thereby decreasing the attraction, making the atom have
less of an attraction for electrons or protons. 2.Trend-wise, as one moves from left to right across
a period in the periodic table, the electronegativity increases due to the stronger attraction that
the atoms obtain as the nuclear charge increases..
The mercury liquid and the mercury(II) oxide are .pdf
The mercury liquid and the mercury(II) oxide are not in the equilibrium constant
expression because of being pure liguids and solids. Kc = 1/[O2] = 1/1.60 M = 0.625
Solution
The mercury liquid and the mercury(II) oxide are not in the equilibrium constant
expression because of being pure liguids and solids. Kc = 1/[O2] = 1/1.60 M = 0.625.
1 Ans Bacteria are unicellular organisms that reproduce by cell divi.pdf
1 Ans Bacteria are unicellular organisms that reproduce by cell division, while viruses are
acellular and are incapable of reproducing on their own and they need a living host.
2 Ans Persistant viral infections are slow viral infections progressive over a long period of time
and are usually fatal.
Examples:
AIDS dementia comples (HIV)
Progressive encephalitis (Rubella virus)
Latent viral infection can remain in host cells throughout life without causing disease. They may
be reactivated by immunosuppression, however, and cause disease.
Examples:
Cold sores
Shingles
Solution
1 Ans Bacteria are unicellular organisms that reproduce by cell division, while viruses are
acellular and are incapable of reproducing on their own and they need a living host.
2 Ans Persistant viral infections are slow viral infections progressive over a long period of time
and are usually fatal.
Examples:
AIDS dementia comples (HIV)
Progressive encephalitis (Rubella virus)
Latent viral infection can remain in host cells throughout life without causing disease. They may
be reactivated by immunosuppression, however, and cause disease.
Examples:
Cold sores
Shingles.
Ques-6 answerThe clinical significance of beta-hemolytic (on blo.pdf
Ques-6: answer:
The clinical significance of beta-hemolytic (on blood agar medium) streptococci isolated from
throat specimen is consequent incidence of rheumatoid fever and acute glomerulonephritis.
Streptococcus pneumoniae (normally present in our body, can be found in the upper respiratory
tract) is an organism that cause upper respiratory tract infections and otitis media. When children
with running nose touch each other, the organism passed through the secretions. This causes
infection in the healthy child, decreased immunity against the bacteria and increased activation
of the flora causes otitis media (a painful ear infection) in children. These respiratory bacteria
produce inflammatory virulent toxins to invade respiratory cells and nutrients finally become
pathogenic to host immune system result in severe respiratory illness.
Throat infections caused by beta-hemolytic streptococcal bacteria may cause \"post-streptococcal
glomerulonephritis\" if left untreated. Therefore, patient needs treatment to treat these symptoms
(antibiotics such as penicillin, corticosteroids and diuretics are to be given). The bacteria causes
inflammation of the blood vessels supplying glomeruli, which impairs the glomerular filtration.
Decreased urine filtration causes edema (swelling of body organs).
Ques-7:
The infection is strep throat and streptococcal bacteria (group B) cause it. These bacteria infect
the upper respiratory tract and causes fever, sore throat, abdominal pain, fatigue, vomiting, body
aches. In a Gram stain of sputum specimen of beta hemolytic streptococci, \"squamous epithelial
cell type\" of body cell provides an indication that the sputum specimen represents material from
an active infection. Other cells are present in the sputum during the active infection are
polymorphonuclear leukocytes (PMNs)
Solution
Ques-6: answer:
The clinical significance of beta-hemolytic (on blood agar medium) streptococci isolated from
throat specimen is consequent incidence of rheumatoid fever and acute glomerulonephritis.
Streptococcus pneumoniae (normally present in our body, can be found in the upper respiratory
tract) is an organism that cause upper respiratory tract infections and otitis media. When children
with running nose touch each other, the organism passed through the secretions. This causes
infection in the healthy child, decreased immunity against the bacteria and increased activation
of the flora causes otitis media (a painful ear infection) in children. These respiratory bacteria
produce inflammatory virulent toxins to invade respiratory cells and nutrients finally become
pathogenic to host immune system result in severe respiratory illness.
Throat infections caused by beta-hemolytic streptococcal bacteria may cause \"post-streptococcal
glomerulonephritis\" if left untreated. Therefore, patient needs treatment to treat these symptoms
(antibiotics such as penicillin, corticosteroids and diuretics are to be given). The bacteria causes
inflammat.
Valence electrons electrons at outer-most energy level.Effective.pdf
Valence electrons : electrons at outer-most energy level.
Effective nuclear charge: net positive charge experienced by an electron in a multi-electron atom.
Atomic radius: distance from the nucleus to the boundary of the surrounding cloud of electrons.
Ionic radius: measure of the size of an atom\'s ion.
Ionization Energy: nergy needed to remove electrons from an atom.
Electron Affinity: the energy change when an electron is added to the neutral atom to form a
negative ion.
Electronegativity: tendency of an atom or a functional group to attract electrons.
Oxidation number (or Oxidation state): hypothetical charge that an atom would have if all bonds
to atoms of different elements were 100% ionic.
Oxidation: Lossing electrons
Reductio: Gaining electrons
Oxidizing agent: Element being Reduced
Reducing agent: Element being Oxidized
Covalent Bond: chemical bonding by shaing of electrons (Non-metal with Non-metal).
Ionic Bond: chemical bonding of non-metal and metal
Compounds: combinations of two or more elements
Octet rule: maximum of 8 electrons (in the valence shell) can be added during a reaction.
Electrolytes: substance that can conduct electricity.
Hydration: chemical reaction when adding water.
Solubility: property of a solid, liquid, or gaseous chemical substance mix with one other to form
a homogeneous solution.
Concentration: abundance of a constituent divided by the total volume of a mixture.
Dilute: lowering the concentration of a chemical.
Concentrated solution: solution in which much of the water has been removed.
Brønsted acid: proton donor.
Brønsted base: proton acceptor.
Monoprotic acids: donate one proton per molecule during the process of dissociation.
Diprotic acids: donate two protons per molecule during the process of dissociation.
Triprotic acids: donate three protons per molecule during the process of dissociation.
pH: measure of acidity and basic of a solution.
Strong acid: ionizes completely in an aqueous solution by losing one proton.
Weak acids: acid that dissociates incompletely.
Strong base: accept hydrogen ions or more generally or donate electron pairs.
Weak base: does not ionize fully in an aqueous solution
Supersaturated solution: solute > solvent
Saturated solution: solute = solvent
unsaturated solution: solute < solvent
Solution
Valence electrons : electrons at outer-most energy level.
Effective nuclear charge: net positive charge experienced by an electron in a multi-electron atom.
Atomic radius: distance from the nucleus to the boundary of the surrounding cloud of electrons.
Ionic radius: measure of the size of an atom\'s ion.
Ionization Energy: nergy needed to remove electrons from an atom.
Electron Affinity: the energy change when an electron is added to the neutral atom to form a
negative ion.
Electronegativity: tendency of an atom or a functional group to attract electrons.
Oxidation number (or Oxidation state): hypothetical charge that an atom would have if all bonds
to atoms of different elements were 10.
What is storage mediaAns-C. the physical material on which a co.pdf
What is storage media?
Ans-
C. the physical material on which a computer keeps data, instructions, and information
Storage media are devices that store application and user information. Storage media is device on
which data can be electronically places kept and retrieved .The primary storage media for a
computer is usually the internal hard drive.
Solution
What is storage media?
Ans-
C. the physical material on which a computer keeps data, instructions, and information
Storage media are devices that store application and user information. Storage media is device on
which data can be electronically places kept and retrieved .The primary storage media for a
computer is usually the internal hard drive..
Transactional model of communication states that if people are conne.pdf
Transactional model of communication states that if people are connected through
communication, they engage in transaction. It propogates that communication is simultaneous.
5 parts or labels: The first part is the sender and receiver - they are the people involved in the
communication. The 2nd part is the message i.e the information being send/received. The 3rd
part is the channel of communication. The 4th part is the response and the decoding of messages
by the sender/receiver. The 5th part is the feedback.
It is different from the linear model of communication, in the sense that unlike the one way
model in the linear communication, the transactional model is a simultaneous model. Linear
model does not involve any feedback, unlike the transactional model.
Ethics means rules of behavior based on ideas about what is right and wrong. Interpersonal
communication is exchange of information between 2 or more people. The ethical choices
involved here is that one should be humble and polite in conversations. One should not hurt the
other person\'s religious or cultural beliefs.
I grew up in an Asian culture in the Indian subcontinent. My family and my society was
orthodox in thinking. This made me (as well as other people growing up and exposed to this
culture) not much of a risk taker. This was due to the fact that we were made to believe that god
will always help us, whatever happens, happens for good (destiny).
If i had grown in a different culture, i probably would be more of a risk taker.
Adam has perception problems. He does not interpret sensory information correctly. His
cognitive (senses of the mind) powers are not that strong.
He can improve his communication by focusing on proxemics i.e non verbal communication.
He should have a strong body movement (kinesics) for better non verbal communication. It
includes facial expressions, gestures etc.
He should also focus on paralanguage - the tone and pitch of his voice.
Solution
Transactional model of communication states that if people are connected through
communication, they engage in transaction. It propogates that communication is simultaneous.
5 parts or labels: The first part is the sender and receiver - they are the people involved in the
communication. The 2nd part is the message i.e the information being send/received. The 3rd
part is the channel of communication. The 4th part is the response and the decoding of messages
by the sender/receiver. The 5th part is the feedback.
It is different from the linear model of communication, in the sense that unlike the one way
model in the linear communication, the transactional model is a simultaneous model. Linear
model does not involve any feedback, unlike the transactional model.
Ethics means rules of behavior based on ideas about what is right and wrong. Interpersonal
communication is exchange of information between 2 or more people. The ethical choices
involved here is that one should be humble and polite in conversations. One should not hur.
What is the measure of the strength of the relationship between inde.pdf
What is the measure of the strength of the relationship between independent and dependent
variables.
Solution
The pearson correlation coefficient measures the strength of the LINEAR
relationship between two variables. The R-squared values measures the proportion of variation
in the dependent variable that can be explained by the independent (predictor) variables..
Some of the SO32- is oxidized by atmospheric oxygen in air into SO42.pdf
Some of the SO32- is oxidized by atmospheric oxygen in air into SO42-:
2 SO32-(aq) + O2 (g) --> 2 SO42-(aq)
Thus a positive test forSO42-is expected in solutions ofSO32-even when noSO42-has been
placed.
Solution
Some of the SO32- is oxidized by atmospheric oxygen in air into SO42-:
2 SO32-(aq) + O2 (g) --> 2 SO42-(aq)
Thus a positive test forSO42-is expected in solutions ofSO32-even when noSO42-has been
placed..
Should begin with a letter and may contain additional letters and di.pdf
Should begin with a letter and may contain additional letters and digits. Identifiers are the same
as variables.
Use descriptive n Use single letters only for the counter in loops.
Variable names start with lower-case
Multi-word identifiers are internally capitalized
Do not use hyphens or underscores to separate multi-word identifiers.
Need to print extra characters?
What about the unicode set?
This is the format: \\uHHHH
Remember any other escape characters such as \ , \\t and \\\\?
The following lists some of these conventions based on the type of identifier:
Class name
The first letter of each word is capitalized, examples:
Mammal, SeaMammal
Function name
The first letter of each, except the first, word is capitalized, examples:
getAge, setHeight
Variable name
The first letter of each, except the first, word is capitalized, examples:
age, brainSize
Constant names
Every letter is capitalized and underscores are used between words, examples:
MAX_HEIGHT, MAX_AGE
RESERVED WORDS
As you may have noticed, many of Java\'s keywords are borrowed from C/C++. Also, as in
C/C++, keywords are always written in lowercase.
Data declaration keywords (boolean, float, int)
Loop keywords (continue, while, for)
Conditional keywords (if, else, switch)
Exception keywords (try, throw, catch)
Structure keywords (class, extends)
Modifier and access keywords (private, public)
Miscellaneous keywords (true, null)
The following keywords and their use, you SHOULD know.
boolean default for private switch
break double if protected this
case else import public throws
catch extends int return try
char final new static void
class float package super while
VARIABLE SCOPE
Where is it appropriate to declare a variable? Does it make a difference?
PRIMITIVE DATA TYPES
int (16-bit)
float (32-bit)
double (64-bit
boolean (true/false)
char (16-bit unicode)
What about String?
What about Integer, and Double?
OBJECTS
Why object oriented programming?
Objects need to be built, so we need constructors.
Instance variables and the role they play when defining objects.
What about methods of an object?
ARRAYS
int[] array = new int[5]; // one-dimensional array
it may also be declared as:
int[] array = {1, 2, 3, 4, 5}; // it is initialized and declared at the same time.
Arrays can be of any primitive data type or object. Arrays have an instance variable \"length\"
that we can access to find out how big the array is. Remember that an Array can throw an
IndexOutOfBoundsException. Make use of it to make your code safe.
VECTORS
Must import java.util.*;
Unlike arrays, vectors can only hold objects, no primitive data types are allowed. Vectors can
grow big and unbounded. You may want to specify the capacity of the vector but you dont need
to. The default capacity is 10 and it doubles in size every time the capacity is reached.
Just like arrays have the \"length\" instance variable, Vectors have a .size() method that returns
the current size of the vector.
void .addElement(Object obj)
void .setElementA.
#include iostream #include string #include iomanip #incl.pdf
#include
#include
#include
#include
#include
#include
using std::cin;
using std::cout;
using std::string;
using std::endl;
using std::vector;
static const string colors[] = { \"red\", \"green\", \"blue\", \"cyan\", \"magenta\", \"yellow\" };
static const int PEGNUM = 4;
static int getRandomValue()
{
static bool first = true;
if (first)
{
first = false;
srand((int)time(0));
}
return(rand());
}
static string easyToLower(string word)
{
transform(word.begin(), word.end(), word.begin(), ::tolower);
return word;
}
inline string trim(string& str) // courtesy of stack overflow
{
str.erase(0, str.find_first_not_of(\' \')); //prefixing spaces
str.erase(str.find_last_not_of(\' \') + 1); //surfixing spaces
return str;
}
static vector setNewCode()
{
vector theCode;
for (int i = 0; i < PEGNUM; i++)
{
theCode.push_back(colors[getRandomValue() % 6]);
}
return theCode;
}
static vector getPlayerGuess()
{
vector words;
string in = \"\", word=\"\";
bool okay = false;
bool quitting = false;
while (!okay)
{
cout << \"Enter your guess (red, green, blue, cyan, magenta, yellow. Enter 4 colors): \ \"< 0)
//get input
{
in = trim(in);
index = in.find_first_of(\" \");
if (index == -1)
{
word = in;
in = \"\";
}
else
word = in.substr(0, index);
words.push_back(word);
in = in.substr(index+1);
if (words.size() == PEGNUM)
{
break;
}
}
okay = true;
for (int i = 0; i < words.size(); i++) // check and standardize inputs
{
words[i] = easyToLower(words[i]);
if (words[i] == \"red\" || words[i] == \"r\")
{
words[i] = colors[0];
//cout << words[i] << endl;
}
else if (words[i] == \"green\" || words[i] == \"g\")
{
words[i] = colors[1];
//cout << words[i] << endl;
}
else if (words[i] == \"blue\" || words[i] == \"b\")
{
words[i] = colors[2];
//cout << words[i] << endl;
}
else if (words[i] == \"cyan\" || words[i] == \"c\")
{
words[i] = colors[3];
//cout << words[i] << endl;
}
else if (words[i] == \"magenta\" || words[i] == \"m\")
{
words[i] = colors[4];
//cout << words[i] << endl;
}
else if (words[i] == \"yellow\" || words[i] == \"y\")
{
words[i] = colors[5];
//cout << words[i] << endl;
}
else if (words[i] == \"quit\")
{
quitting = true;
words.clear();
words.push_back(\"quit\");
return words;
}
else
{
cout << words[i] << \" is an invalid submittion\" << endl;
words.clear();
okay = false;
}
}
if (!okay)
cout << \"Invalid entry. Please try again\ \" << endl;
if (words.size() != PEGNUM) // check if 4 entries
{
cout << \"Must enter 4 colors. Try again\ \" << endl;
words.clear();
okay = false;
}
}
return words;
}
static int setBlackPegs(vector theCode, vector guessCode)
{
int bps = 0;
for (int i = 0; i < PEGNUM; i++)
{
if (theCode[i] == guessCode[i])
bps++;
}
return bps;
}
static int setWhitePegs(vector theCode, vector guessCode, int bps)
{
int RGBCMYnumsTheCode[6];
int RGBCMYnumsGuessCode[6];
int wps=0;
for (int i = 0; i < 6; i++)
{
RGBCMYnumsTheCode[i] = 0;
RGBCMYnumsGuessCode[i] = 0;
}
for (int i = 0; i < PEGNUM; i++)
{
if (theCode[i] == colors[0])
{
RGBCMYnumsTheCode[0]++;
}
else if (theCo.
Prostomes are mollusca, annelids and arthropods while deuterostomes .pdf
Prostomes are mollusca, annelids and arthropods while deuterostomes are echinoderms,
hemichordates and chordates
So correct answer is prostomes and bilaterally symmetrical (D)
Solution
Prostomes are mollusca, annelids and arthropods while deuterostomes are echinoderms,
hemichordates and chordates
So correct answer is prostomes and bilaterally symmetrical (D).
More from sudhinjv (20)
1.Rule based detection 2.Statical anomaly detection1.Rule based de.pdf
1.Rule based detection 2.Statical anomaly detection1.Rule based de.pdf
14 = disease ff24 = carriers Ff25 chances that they will pro.pdf
14 = disease ff24 = carriers Ff25 chances that they will pro.pdf
Mosses, lichens are great indicators of radioactive pollution. They .pdf
Mosses, lichens are great indicators of radioactive pollution. They .pdf
10 million.Sensory conflict theory argues , The brightest light at.pdf
10 million.Sensory conflict theory argues , The brightest light at.pdf
We first find the slopes of the two lines 2M an.pdf
We first find the slopes of the two lines 2M an.pdf
SO2 is a gas that mixes with water to form sulfur.pdf
SO2 is a gas that mixes with water to form sulfur.pdf
1. Heterozygosity by migration calculated using the below formulaH.pdf
1. Heterozygosity by migration calculated using the below formulaH.pdf
1).Monohybrid cross between true breeding parents. Assume that the.pdf
1).Monohybrid cross between true breeding parents. Assume that the.pdf
1. Moving down a group, the electronegativity decreases due to the l.pdf
1. Moving down a group, the electronegativity decreases due to the l.pdf
The mercury liquid and the mercury(II) oxide are .pdf
The mercury liquid and the mercury(II) oxide are .pdf
1 Ans Bacteria are unicellular organisms that reproduce by cell divi.pdf
1 Ans Bacteria are unicellular organisms that reproduce by cell divi.pdf
Ques-6 answerThe clinical significance of beta-hemolytic (on blo.pdf
Ques-6 answerThe clinical significance of beta-hemolytic (on blo.pdf
Valence electrons electrons at outer-most energy level.Effective.pdf
Valence electrons electrons at outer-most energy level.Effective.pdf
What is storage mediaAns-C. the physical material on which a co.pdf
What is storage mediaAns-C. the physical material on which a co.pdf
Transactional model of communication states that if people are conne.pdf
Transactional model of communication states that if people are conne.pdf
What is the measure of the strength of the relationship between inde.pdf
What is the measure of the strength of the relationship between inde.pdf
Some of the SO32- is oxidized by atmospheric oxygen in air into SO42.pdf
Some of the SO32- is oxidized by atmospheric oxygen in air into SO42.pdf
Should begin with a letter and may contain additional letters and di.pdf
Should begin with a letter and may contain additional letters and di.pdf
#include iostream #include string #include iomanip #incl.pdf
#include iostream #include string #include iomanip #incl.pdf
Prostomes are mollusca, annelids and arthropods while deuterostomes .pdf
Prostomes are mollusca, annelids and arthropods while deuterostomes .pdf
Recently uploaded
Operation Blue Star - Saka Neela Tara
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
How to Make a Field invisible in Odoo 17
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH ANSWERS.
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.
2024.06.01 Introducing a competency framework for languag learning materials ...
http://sandymillin.wordpress.com/iateflwebinar2024
Published classroom materials form the basis of syllabuses, drive teacher professional development, and have a potentially huge influence on learners, teachers and education systems. All teachers also create their own materials, whether a few sentences on a blackboard, a highly-structured fully-realised online course, or anything in between. Despite this, the knowledge and skills needed to create effective language learning materials are rarely part of teacher training, and are mostly learnt by trial and error.
Knowledge and skills frameworks, generally called competency frameworks, for ELT teachers, trainers and managers have existed for a few years now. However, until I created one for my MA dissertation, there wasn’t one drawing together what we need to know and do to be able to effectively produce language learning materials.
This webinar will introduce you to my framework, highlighting the key competencies I identified from my research. It will also show how anybody involved in language teaching (any language, not just English!), teacher training, managing schools or developing language learning materials can benefit from using the framework.
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
Letter from the Congress of the United States regarding Anti-Semitism sent June 3rd to MIT President Sally Kornbluth, MIT Corp Chair, Mark Gorenberg
Dear Dr. Kornbluth and Mr. Gorenberg,
The US House of Representatives is deeply concerned by ongoing and pervasive acts of antisemitic
harassment and intimidation at the Massachusetts Institute of Technology (MIT). Failing to act decisively to ensure a safe learning environment for all students would be a grave dereliction of your responsibilities as President of MIT and Chair of the MIT Corporation.
This Congress will not stand idly by and allow an environment hostile to Jewish students to persist. The House believes that your institution is in violation of Title VI of the Civil Rights Act, and the inability or
unwillingness to rectify this violation through action requires accountability.
Postsecondary education is a unique opportunity for students to learn and have their ideas and beliefs challenged. However, universities receiving hundreds of millions of federal funds annually have denied
students that opportunity and have been hijacked to become venues for the promotion of terrorism, antisemitic harassment and intimidation, unlawful encampments, and in some cases, assaults and riots.
The House of Representatives will not countenance the use of federal funds to indoctrinate students into hateful, antisemitic, anti-American supporters of terrorism. Investigations into campus antisemitism by the Committee on Education and the Workforce and the Committee on Ways and Means have been expanded into a Congress-wide probe across all relevant jurisdictions to address this national crisis. The undersigned Committees will conduct oversight into the use of federal funds at MIT and its learning environment under authorities granted to each Committee.
• The Committee on Education and the Workforce has been investigating your institution since December 7, 2023. The Committee has broad jurisdiction over postsecondary education, including its compliance with Title VI of the Civil Rights Act, campus safety concerns over disruptions to the learning environment, and the awarding of federal student aid under the Higher Education Act.
• The Committee on Oversight and Accountability is investigating the sources of funding and other support flowing to groups espousing pro-Hamas propaganda and engaged in antisemitic harassment and intimidation of students. The Committee on Oversight and Accountability is the principal oversight committee of the US House of Representatives and has broad authority to investigate “any matter” at “any time” under House Rule X.
• The Committee on Ways and Means has been investigating several universities since November 15, 2023, when the Committee held a hearing entitled From Ivory Towers to Dark Corners: Investigating the Nexus Between Antisemitism, Tax-Exempt Universities, and Terror Financing. The Committee followed the hearing with letters to those institutions on January 10, 202
Polish students' mobility in the Czech Republic
Polish students mobility to the Czech Republic within eTwinning project "Medieval adventures with Marco Polo"
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
A Strategic Approach: GenAI in Education
Artificial Intelligence (AI) technologies such as Generative AI, Image Generators and Large Language Models have had a dramatic impact on teaching, learning and assessment over the past 18 months. The most immediate threat AI posed was to Academic Integrity with Higher Education Institutes (HEIs) focusing their efforts on combating the use of GenAI in assessment. Guidelines were developed for staff and students, policies put in place too. Innovative educators have forged paths in the use of Generative AI for teaching, learning and assessments leading to pockets of transformation springing up across HEIs, often with little or no top-down guidance, support or direction.
This Gasta posits a strategic approach to integrating AI into HEIs to prepare staff, students and the curriculum for an evolving world and workplace. We will highlight the advantages of working with these technologies beyond the realm of teaching, learning and assessment by considering prompt engineering skills, industry impact, curriculum changes, and the need for staff upskilling. In contrast, not engaging strategically with Generative AI poses risks, including falling behind peers, missed opportunities and failing to ensure our graduates remain employable. The rapid evolution of AI technologies necessitates a proactive and strategic approach if we are to remain relevant.
1.4 modern child centered education - mahatma gandhi-2.pptx
Child centred education is an educational approach that priorities the interest, needs and abilities of the child in the learning process.
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...Nguyen Thanh Tu Collection
https://app.box.com/s/hqnndn05v4q5a4k4jd597rkdbda0fniiUnit 2- Research Aptitude (UGC NET Paper I).pdf
This slide describes the research aptitude of unit 2 in the UGC NET paper I.
Thesis Statement for students diagnonsed withADHD.ppt
Presentation required for the master in Education.
The approach at University of Liverpool.pptx
How libraries can support authors with open access requirements for UKRI funded books
Wednesday 22 May 2024, 14:00-15:00.
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Event Link:-
https://meetups.mulesoft.com/events/details/mulesoft-mysore-presents-exploring-gemini-ai-and-integration-with-mulesoft/
Agenda
● Java 17 Upgrade Overview
● Why and by when do customers need to upgrade to Java 17?
● Is there any immediate impact to upgrading to Mule Runtime 4.6 and beyond?
● Which MuleSoft products are in scope?
For Upcoming Meetups Join Mysore Meetup Group - https://meetups.mulesoft.com/mysore/
YouTube:- youtube.com/@mulesoftmysore
Mysore WhatsApp group:- https://chat.whatsapp.com/EhqtHtCC75vCAX7gaO842N
Speaker:-
Shubham Chaurasia - https://www.linkedin.com/in/shubhamchaurasia1/
Priya Shaw - https://www.linkedin.com/in/priya-shaw
Organizers:-
Shubham Chaurasia - https://www.linkedin.com/in/shubhamchaurasia1/
Giridhar Meka - https://www.linkedin.com/in/giridharmeka
Priya Shaw - https://www.linkedin.com/in/priya-shaw
Shyam Raj Prasad-
https://www.linkedin.com/in/shyam-raj-prasad/
Home assignment II on Spectroscopy 2024 Answers.pdf
Answers to Home assignment on UV-Visible spectroscopy: Calculation of wavelength of UV-Visible absorption
Honest Reviews of Tim Han LMA Course Program.pptx
Personal development courses are widely available today, with each one promising life-changing outcomes. Tim Han’s Life Mastery Achievers (LMA) Course has drawn a lot of interest. In addition to offering my frank assessment of Success Insider’s LMA Course, this piece examines the course’s effects via a variety of Tim Han LMA course reviews and Success Insider comments.
Recently uploaded (20)
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
TESDA TM1 REVIEWER FOR NATIONAL ASSESSMENT WRITTEN AND ORAL QUESTIONS WITH A...
Adversarial Attention Modeling for Multi-dimensional Emotion Regression.pdf
Adversarial Attention Modeling for Multi-dimensional Emotion Regression.pdf
2024.06.01 Introducing a competency framework for languag learning materials ...
2024.06.01 Introducing a competency framework for languag learning materials ...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
June 3, 2024 Anti-Semitism Letter Sent to MIT President Kornbluth and MIT Cor...
How libraries can support authors with open access requirements for UKRI fund...
How libraries can support authors with open access requirements for UKRI fund...
1.4 modern child centered education - mahatma gandhi-2.pptx
1.4 modern child centered education - mahatma gandhi-2.pptx
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
BÀI TẬP BỔ TRỢ TIẾNG ANH GLOBAL SUCCESS LỚP 3 - CẢ NĂM (CÓ FILE NGHE VÀ ĐÁP Á...
Thesis Statement for students diagnonsed withADHD.ppt
Thesis Statement for students diagnonsed withADHD.ppt
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Mule 4.6 & Java 17 Upgrade | MuleSoft Mysore Meetup #46
Home assignment II on Spectroscopy 2024 Answers.pdf
Home assignment II on Spectroscopy 2024 Answers.pdf
1#include stdio.h#include stdlib.h#include assert.h .pdf
- 1. 1 #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int count = 0; /* the index of the node we're currently looking at */ while (current != NULL)
- 2. { if (count == index) return(current->data); count++; current = current->next; } /* if we get to this line, the caller was asking for a non-existent element so we assert fail */ assert(0); } /* Drier program to test above function*/ int main() { /* Start with the empty list */ struct node* head = NULL; /* Use push() to construct below list 1->12->1->4->1 */ push(&head, 1); push(&head, 4); push(&head, 1); push(&head, 12); push(&head, 1); /* Check the count function */ printf("Element at index 3 is %d", GetNth(head, 3)); getchar(); } 2 #include #include #include /* Link list node */ struct node {
- 3. int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int count = 0; /* the index of the node we're currently looking at */ while (current != NULL) { if (count == index) return(current->data); count++; current = current->next; } /* if we get to this line, the caller was asking
- 4. for a non-existent element so we assert fail */ assert(0); } /* Drier program to test above function*/ int main() { /* Start with the empty list */ struct node* head = NULL; /* Use push() to construct below list 1->12->1->4->1 */ push(&head, 1); push(&head, 4); push(&head, 1); push(&head, 12); push(&head, 1); /* Check the count function */ printf("Element at index 3 is %d", GetNth(head, 3)); getchar(); } Solution 1 #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front
- 5. of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data; /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int count = 0; /* the index of the node we're currently looking at */ while (current != NULL) { if (count == index) return(current->data); count++; current = current->next; } /* if we get to this line, the caller was asking for a non-existent element so we assert fail */ assert(0); } /* Drier program to test above function*/ int main()
- 6. { /* Start with the empty list */ struct node* head = NULL; /* Use push() to construct below list 1->12->1->4->1 */ push(&head, 1); push(&head, 4); push(&head, 1); push(&head, 12); push(&head, 1); /* Check the count function */ printf("Element at index 3 is %d", GetNth(head, 3)); getchar(); } 2 #include #include #include /* Link list node */ struct node { int data; struct node* next; }; /* Given a reference (pointer to pointer) to the head of a list and an int, push a new node on the front of the list. */ void push(struct node** head_ref, int new_data) { /* allocate node */ struct node* new_node = (struct node*) malloc(sizeof(struct node)); /* put in the data */ new_node->data = new_data;
- 7. /* link the old list off the new node */ new_node->next = (*head_ref); /* move the head to point to the new node */ (*head_ref) = new_node; } /* Takes head pointer of the linked list and index as arguments and return data at index*/ int GetNth(struct node* head, int index) { struct node* current = head; int count = 0; /* the index of the node we're currently looking at */ while (current != NULL) { if (count == index) return(current->data); count++; current = current->next; } /* if we get to this line, the caller was asking for a non-existent element so we assert fail */ assert(0); } /* Drier program to test above function*/ int main() { /* Start with the empty list */ struct node* head = NULL; /* Use push() to construct below list 1->12->1->4->1 */ push(&head, 1); push(&head, 4);
- 8. push(&head, 1); push(&head, 12); push(&head, 1); /* Check the count function */ printf("Element at index 3 is %d", GetNth(head, 3)); getchar(); }