Implement a priority queue using a doublyLinked-cpp where the node wit.pdf
•
0 likes•3 views
Implement a priority queue using a doublyLinked.cpp where the node with the highest priority (key) is the right-most node. The remove (de-queue) operation returns the node with the highest priority (key). If displayForward() displays List (first-->last) : 10 30 40 55 remove() would return the node with key 55. please only code in c++ not anything else. keep it simple and thank you!! Demonstrate by inserting keys at random, displayForward(), call remove then displayForward() again. int main() { DoublyLinkedList pqList; pqList.priorityInsert(50); pqList.priorityInsert(40); pqList.priorityInsert(30); pqList.priorityInsert(20); pqList.priorityInsert(10); cout<<"-------------- PriorityQueue -------------"<<endl; pqList.displayForward(); cout<<"calling priorityRemove()"<<endl; double key = pqList.priorityRemove(); cout<<"Removed node with key "<<key<<endl; pqList.displayForward(); key = pqList.priorityRemove(); cout<<"Removed node with key "<<key<<endl; pqList.displayForward(); return 0; } Sample output" -------------- PriorityQueue ------------- List (first-->last): 10 20 30 40 50 calling priorityRemove() Removed node with key 50 List (first-->last): 10 20 30 40 Removed node with key 40 List (first-->last): 10 20 30 I may change numbers when grading. doublyLinked.cpp //doublyLinked.cpp //demonstrates doubly-linked list #include <iostream> using namespace std; //////////////////////////////////////////////////////////////// class Link { public: double dData; //data item Link * pNext; //next link in list Link * pPrevious; //previous link in list public: //------------------------------------------------------------- Link(double dd): //constructor dData(dd), pNext(NULL), pPrevious(NULL) {} //------------------------------------------------------------- void displayLink() //display this link { cout << dData << " "; } //------------------------------------------------------------- }; //end class Link //////////////////////////////////////////////////////////////// class DoublyLinkedList { private: Link * pFirst; //pointer to first item Link * pLast; //pointer to last item public: //------------------------------------------------------------- DoublyLinkedList(): //constructor pFirst(NULL), pLast(NULL) {} //------------------------------------------------------------- ~DoublyLinkedList() //destructor (deletes links) { Link * pCurrent = pFirst; //start at beginning of list while (pCurrent != NULL) //until end of list, { Link * pOldCur = pCurrent; //save current link pCurrent = pCurrent -> pNext; //move to next link delete pOldCur; //delete old current } } //------------------------------------------------------------- bool isEmpty() //true if no links { return pFirst == NULL; } //------------------------------------------------------------- void insertFirst(double dd) //insert at front of list { Link * pNewLink = new Link(dd); //make new link if (isEmpty()) //if empty list, pLast = pNewLink; //newLink <-- last else pFirst -> pPrevious = pNewLink; //newLi.
Report
Share
Report
Share
Download to read offline
Recommended
Solution#includestdio.h#includeconio.h#includealloc.h.pdf
Solution
:
#include
#include
#include
//-------------------------------------------------
struct node
{
int data;
struct node *next;
}*start=NULL;
//------------------------------------------------------------
void creat()
{
char ch;
do
{
struct node *new_node,*current;
new_node=(struct node *)malloc(sizeof(struct node));
printf(\"nEnter the data : \");
scanf(\"%d\",&new_node->data);
new_node->next=NULL;
if(start==NULL)
{
start=new_node;
current=new_node;
}
else
{
current->next=new_node;
current=new_node;
}
printf(\"nDo you want to creat another : \");
ch=getche();
}while(ch!=\'n\');
}
//------------------------------------------------------------------
void display()
{
struct node *new_node;
printf(\"The Linked List : n\");
new_node=start;
while(new_node!=NULL)
{
printf(\"%d--->\",new_node->data);
new_node=new_node->next;
}
printf(\"NULL\");
}
//----------------------------------------------------
void main()
{
create();
display();
}
//----------------------------------------------------
Output :
#include
#include
#include
#include
struct node {
int data;
int key;
struct node *next;
struct node *prev;
};
//this link always point to first Link
struct node *head = NULL;
//this link always point to last Link
struct node *last = NULL;
struct node *current = NULL;
//is list empty
bool isEmpty(){
return head == NULL;
}
int length(){
int length = 0;
struct node *current;
for(current = head; current != NULL; current = current->next){
length++;
}
return length;
}
//display the list in from first to last
void displayForward(){
//start from the beginning
struct node *ptr = head;
//navigate till the end of the list
printf(\"\ [ \");
while(ptr != NULL){
printf(\"(%d,%d) \",ptr->key,ptr->data);
ptr = ptr->next;
}
printf(\" ]\");
}
//display the list from last to first
void displayBackward(){
//start from the last
struct node *ptr = last;
//navigate till the start of the list
printf(\"\ [ \");
while(ptr != NULL){
//print data
printf(\"(%d,%d) \",ptr->key,ptr->data);
//move to next item
ptr = ptr ->prev;
printf(\" \");
}
printf(\" ]\");
}
//insert link at the first location
void insertFirst(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//update first prev link
head->prev = link;
}
//point it to old first link
link->next = head;
//point first to new first link
head = link;
}
//insert link at the last location
void insertLast(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//make link a new last link
last->next = link;
//mark old last node as prev of new link
link->prev = last;
}
//point last to new last node
last = link;
}
//delete first item
struct node* deleteFirst(){
//save reference to first link
struct node *tempLink = head;
//if only one link
if(head->next == .
#include iostream#include d_node.h #include d_nodel.h.docx
The document defines C++ functions for working with linked lists: getMax returns the maximum node, eraseValue removes the first occurrence of a target value, sum returns the sum of all node values, and outputReverse prints the list in reverse order. The main function creates a linked list of random numbers, prints it, calls sum and outputReverse, then removes nodes in descending order while printing. Templates are used to allow different data types.
C++ projectMachine Problem 7 - HashingWrite a program to do the .pdf
C++ project
Machine Problem 7 - Hashing
Write a program to do the following:
loads username/password sets from the file password.txt and insert them into the hash table until
the end of file is reached on password.txt. The password.txt file will look something like this
with one username/password set per line.
mary changeMe!
The program will then present a login prompt, read one username, present a password prompt,
and after looking up the username\'s password in the hash table, will print either \"Authentication
successful\" or \"Authentication failure\".
The above step will be repeated until the end of the input data (EOF) is reached on the console
input stream (cin). The EOF character on the PC\'s is the CTRL Z character.
To convert from a string to an integer, we can add the ascii value of each character together. For
instance, Mary\'s conversion from string to integer might look something like this:
109(\'m\') + 97(\'a\') + 114(\'r\') + 121(\'y\')=441
We\'ve converted the string to an integer, but we still need to convert the integer to an index. For
an array of 10 elements we can divide by 10 and use the remainder as an index. Combining these
two hash functions, we will get Mary\'s index to be: 441 % 10 = 1
Your primary tasks for this homework are to edit the login.cpp to replace the comments with
lines so that it does the following:
Insert passwords into the Hash Table.
Retrieve one user\'s Password structure from the Hash Table.
Compare retrieved user password to input password and print \"Authentication failure\" or
\"Authentication successful.\"
//--------------------------------------------------------------------
//
// listlnk.h
//
//--------------------------------------------------------------------
#pragma warning( disable : 4290 )
#include
#include
#include
#include
#include
#include
#include
using namespace std;
template < class T > // Forward declaration of the List class
class List;
template < class T >
class ListNode // Facilitator class for the List class
{
private:
ListNode(const T &nodeData, ListNode *nextPtr);
T dataItem; // List data item
ListNode *next; // Pointer to the next list node
friend class List;
};
//--------------------------------------------------------------------
template < class T >
class List
{
public:
List(int ignored = 0);
~List();
void insert(const T &newData) throw (bad_alloc); // Insert after cursor
void remove() throw (logic_error); // Remove data item
void replace(const T &newData) throw (logic_error); // Replace data item
void clear();
bool isEmpty() const;
bool isFull() const;
// List iteration operations
void gotoBeginning() throw (logic_error);
void gotoEnd() throw (logic_error);
bool gotoNext();
bool gotoPrior();
T getCursor() const throw (logic_error); // Return item
void showStructure() const;
void moveToBeginning() throw (logic_error); // Move to beginning
void insertBefore(const T &newElement) throw (bad_alloc); // Insert before cursor
private:
ListNode *head, // Pointer to the beginni.
Qestion Please add pre-condition, post-conditions and descriptions .pdf
Qestion: Please add pre-condition, post-conditions and descriptions for each member function of
the LINKED_LIST_CLASS. Answer with your new version of the program.
#include
using namespace std;
class LIST_NODE
{
public:
int data; // data element of node
LIST_NODE *next; // pointer element of node
};
class LINKED_LIST_CLASS
{
public:
LINKED_LIST_CLASS(); // default constructor
LINKED_LIST_CLASS(LINKED_LIST_CLASS &); // copy constructor
~LINKED_LIST_CLASS(); // destructor
void Add(int); // mutator
void Print(); // accessor
LIST_NODE * Search(int); // accessor
void Remove(int); // mutator
bool Is_Empty(); // accessor
private:
LIST_NODE *front; // pointer to front of list
};
LINKED_LIST_CLASS::LINKED_LIST_CLASS()
{
cout << endl << \"The default constructor has been called.\ \";
front = new LIST_NODE;
front->next = 0; // initialize the next field to null
front->data = -10000;
}
LINKED_LIST_CLASS::LINKED_LIST_CLASS(LINKED_LIST_CLASS & org)
{
cout << endl << \"The copy constructor has been called.\ \";
front = new LIST_NODE;
front->next = 0;
front->data = -10000;
LIST_NODE *p = org.front->next;
LIST_NODE *back = 0;
while(p!=0)
{
if (back == 0)
{
front->next = new LIST_NODE;
back = front->next;
back->next = 0;
back->data = p->data;
}
else
{
back->next = new LIST_NODE;
back = back->next;
back->data = p->data;
back->next = 0;
}
p=p->next;
}
}
LINKED_LIST_CLASS::~LINKED_LIST_CLASS()
{
cout << endl << \"The destructor has been called.\ \";
while (front->next != 0)
{
LIST_NODE *p = front->next;
front->next = front->next->next;
delete p;
}
delete front;
front = 0;
}
void LINKED_LIST_CLASS::Add(int item)
{
LIST_NODE *p = new LIST_NODE;
p->data = item;
if (front->next== 0) // empty list
{
front->next = p;
p->next = 0;
}
else // list has information and is not empty
{
p->next = front->next;
front->next = p;
}
}
void LINKED_LIST_CLASS::Print()
{
cout << endl;
for(LIST_NODE *p = front->next; p != 0; p = p->next)
{
cout << p->data;
if (p->next != 0)
{
cout << \"-->\";
}
}
cout<next; p!=0; p=p->next)
{
if (p->data == key)
return p;
}
return 0; // key not found in list
}
void LINKED_LIST_CLASS::Remove(int key)
{
LIST_NODE *p = Search(key);
if (Is_Empty())
{
cout << key << \" is not in the list. No removal performed!\ \";
}
else
{
LIST_NODE *q = front;
while (q->next->data != key)
{
q = q->next;
}
q->next = p->next; // CRITICAL STEP!!!!
delete p;
}
}
bool LINKED_LIST_CLASS::Is_Empty()
{
return front->next == 0;
}
int main()
{
LINKED_LIST_CLASS L1;
L1.Add(5);
L1.Add(10);
L1.Add(29);
L1.Print();
LINKED_LIST_CLASS L2 = L1;
L2.Print();
L1.Remove(10);
L1.Print();
return 0;
}
Solution
#include
using namespace std;
class LIST_NODE
{
public:
int data; // data element of node
LIST_NODE *next; // pointer element of node
};
class LINKED_LIST_CLASS
{
public:
LINKED_LIST_CLASS(); // default constructor
LINKED_LIST_CLASS(LINKED_LIST_CLASS &); // copy constructor
~LINKED_LIST_CLASS(); // destructor
void Add(int); // mutator
void Print(); // accessor
LIST_NODE * Search(int); // ac.
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.
In C++ I need help with this method that Im trying to write fillLi.pdf
In C++ I need help with this method that I'm trying to write: fillListFromFile( ) : void -- this
method will add elements to the list from a file called linkedListData1.txt HINT: this is where
you will keep track of the number of elements in the list
I have all of the other methods, but I'm stuck on this one and I've added it as the last method in
the application. The code I have so far is below.
.cpp file:
.h file:
main:
#include
#include
#include
#include "Node.h"
using namespace std;
void displayList(Node*);
void insertFront(Node** head, int value);
void insertBack(Node** ptrToHead, int value);
void insertAfter(Node* previous, int value);
void deleteAtN(Node** ptrToHead, int n);
void deleteNode(Node** ptrToHead, int searchVal);
void clearList(Node**);
bool searchVal(Node** head, int value);
int countFrequencyOf(Node** ptrTohead, int value);
int size(Node** ptrTohead);
void displayFromFrontToN(Node** ptrToHead, int n);
void displayFromNToEnd(Node** ptrToHead, int n);
void insertInOrder(Node** head, Node* ptrToHead);
void displayInRows(Node** ptrToHead);
int main()
{
Node* node1 = new Node();
node1->setValue(10);
Node* node2 = new Node();
node2->setValue(20);
Node* node3 = new Node();
node3->setValue(30);
node1->next = node2;
node2->next = node3;
Node* head = node1;
displayList(head);
insertFront(&head, 5);
displayList(head);
insertBack(&head, 50);
displayList(head);
insertBack(&head, 60);
displayList(head);
insertAfter(node2, 25);
displayList(head);
deleteAtN(&head, 2);
displayList(head);
deleteNode(&head, 50);
displayList(head);
clearList(&head);
displayList(head);
insertFront(&head, 5);
insertFront(&head, 10);
insertFront(&head, 20);
insertBack(&head, 50);
searchVal(&head, 50);
displayList(head);
countFrequencyOf(&head, 25);
displayList(head);
insertBack(&head, 25);
insertFront(&head, 25);
countFrequencyOf(&head, 25);
displayList(head);
size(&head);
cout << "add one item to list" << endl;
insertBack(&head, 25);
size(&head);
displayList(head);
cout << "Display From Front To N" << endl;
displayFromFrontToN(&head, 4);
cout << "Display From N To End" << endl;
displayFromNToEnd(&head, 3);
cout << "Display In Rows" << endl;
displayInRows(&head);
insertFront(&head, 12);
insertFront(&head, 17);
insertFront(&head, 22);
insertBack(&head, 58);
cout << "Display In Rows" << endl;
displayInRows(&head);//call displayInRows()
return 0;
}//end main()
void displayList(Node* ptr) {
if (ptr == nullptr)
cout << "empty list" << endl;
else {
while (ptr != nullptr) {
cout << ptr->getValue() << endl;
ptr = ptr->next;
}
}
cout << "---------------------------" << endl;
}//end displayList()
void insertFront(Node** head, int value) {
Node* newNode = new Node();
newNode->setValue(value);
//cout<< newNode->getValue() << endl;
newNode->next = *head;
*head = newNode;
}
void insertBack(Node** ptrToHead, int value) {
Node* newNode = new Node();
newNode->setValue(value);
newNode->next = nullptr;
if (*ptrToHead == nullptr)
{
*ptrToHead = newNode;
}//end if
else
{
Node* last .
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
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();
}.
Recommended
Solution#includestdio.h#includeconio.h#includealloc.h.pdf
Solution
:
#include
#include
#include
//-------------------------------------------------
struct node
{
int data;
struct node *next;
}*start=NULL;
//------------------------------------------------------------
void creat()
{
char ch;
do
{
struct node *new_node,*current;
new_node=(struct node *)malloc(sizeof(struct node));
printf(\"nEnter the data : \");
scanf(\"%d\",&new_node->data);
new_node->next=NULL;
if(start==NULL)
{
start=new_node;
current=new_node;
}
else
{
current->next=new_node;
current=new_node;
}
printf(\"nDo you want to creat another : \");
ch=getche();
}while(ch!=\'n\');
}
//------------------------------------------------------------------
void display()
{
struct node *new_node;
printf(\"The Linked List : n\");
new_node=start;
while(new_node!=NULL)
{
printf(\"%d--->\",new_node->data);
new_node=new_node->next;
}
printf(\"NULL\");
}
//----------------------------------------------------
void main()
{
create();
display();
}
//----------------------------------------------------
Output :
#include
#include
#include
#include
struct node {
int data;
int key;
struct node *next;
struct node *prev;
};
//this link always point to first Link
struct node *head = NULL;
//this link always point to last Link
struct node *last = NULL;
struct node *current = NULL;
//is list empty
bool isEmpty(){
return head == NULL;
}
int length(){
int length = 0;
struct node *current;
for(current = head; current != NULL; current = current->next){
length++;
}
return length;
}
//display the list in from first to last
void displayForward(){
//start from the beginning
struct node *ptr = head;
//navigate till the end of the list
printf(\"\ [ \");
while(ptr != NULL){
printf(\"(%d,%d) \",ptr->key,ptr->data);
ptr = ptr->next;
}
printf(\" ]\");
}
//display the list from last to first
void displayBackward(){
//start from the last
struct node *ptr = last;
//navigate till the start of the list
printf(\"\ [ \");
while(ptr != NULL){
//print data
printf(\"(%d,%d) \",ptr->key,ptr->data);
//move to next item
ptr = ptr ->prev;
printf(\" \");
}
printf(\" ]\");
}
//insert link at the first location
void insertFirst(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//update first prev link
head->prev = link;
}
//point it to old first link
link->next = head;
//point first to new first link
head = link;
}
//insert link at the last location
void insertLast(int key, int data){
//create a link
struct node *link = (struct node*) malloc(sizeof(struct node));
link->key = key;
link->data = data;
if(isEmpty()){
//make it the last link
last = link;
}else {
//make link a new last link
last->next = link;
//mark old last node as prev of new link
link->prev = last;
}
//point last to new last node
last = link;
}
//delete first item
struct node* deleteFirst(){
//save reference to first link
struct node *tempLink = head;
//if only one link
if(head->next == .
#include iostream#include d_node.h #include d_nodel.h.docx
The document defines C++ functions for working with linked lists: getMax returns the maximum node, eraseValue removes the first occurrence of a target value, sum returns the sum of all node values, and outputReverse prints the list in reverse order. The main function creates a linked list of random numbers, prints it, calls sum and outputReverse, then removes nodes in descending order while printing. Templates are used to allow different data types.
C++ projectMachine Problem 7 - HashingWrite a program to do the .pdf
C++ project
Machine Problem 7 - Hashing
Write a program to do the following:
loads username/password sets from the file password.txt and insert them into the hash table until
the end of file is reached on password.txt. The password.txt file will look something like this
with one username/password set per line.
mary changeMe!
The program will then present a login prompt, read one username, present a password prompt,
and after looking up the username\'s password in the hash table, will print either \"Authentication
successful\" or \"Authentication failure\".
The above step will be repeated until the end of the input data (EOF) is reached on the console
input stream (cin). The EOF character on the PC\'s is the CTRL Z character.
To convert from a string to an integer, we can add the ascii value of each character together. For
instance, Mary\'s conversion from string to integer might look something like this:
109(\'m\') + 97(\'a\') + 114(\'r\') + 121(\'y\')=441
We\'ve converted the string to an integer, but we still need to convert the integer to an index. For
an array of 10 elements we can divide by 10 and use the remainder as an index. Combining these
two hash functions, we will get Mary\'s index to be: 441 % 10 = 1
Your primary tasks for this homework are to edit the login.cpp to replace the comments with
lines so that it does the following:
Insert passwords into the Hash Table.
Retrieve one user\'s Password structure from the Hash Table.
Compare retrieved user password to input password and print \"Authentication failure\" or
\"Authentication successful.\"
//--------------------------------------------------------------------
//
// listlnk.h
//
//--------------------------------------------------------------------
#pragma warning( disable : 4290 )
#include
#include
#include
#include
#include
#include
#include
using namespace std;
template < class T > // Forward declaration of the List class
class List;
template < class T >
class ListNode // Facilitator class for the List class
{
private:
ListNode(const T &nodeData, ListNode *nextPtr);
T dataItem; // List data item
ListNode *next; // Pointer to the next list node
friend class List;
};
//--------------------------------------------------------------------
template < class T >
class List
{
public:
List(int ignored = 0);
~List();
void insert(const T &newData) throw (bad_alloc); // Insert after cursor
void remove() throw (logic_error); // Remove data item
void replace(const T &newData) throw (logic_error); // Replace data item
void clear();
bool isEmpty() const;
bool isFull() const;
// List iteration operations
void gotoBeginning() throw (logic_error);
void gotoEnd() throw (logic_error);
bool gotoNext();
bool gotoPrior();
T getCursor() const throw (logic_error); // Return item
void showStructure() const;
void moveToBeginning() throw (logic_error); // Move to beginning
void insertBefore(const T &newElement) throw (bad_alloc); // Insert before cursor
private:
ListNode *head, // Pointer to the beginni.
Qestion Please add pre-condition, post-conditions and descriptions .pdf
Qestion: Please add pre-condition, post-conditions and descriptions for each member function of
the LINKED_LIST_CLASS. Answer with your new version of the program.
#include
using namespace std;
class LIST_NODE
{
public:
int data; // data element of node
LIST_NODE *next; // pointer element of node
};
class LINKED_LIST_CLASS
{
public:
LINKED_LIST_CLASS(); // default constructor
LINKED_LIST_CLASS(LINKED_LIST_CLASS &); // copy constructor
~LINKED_LIST_CLASS(); // destructor
void Add(int); // mutator
void Print(); // accessor
LIST_NODE * Search(int); // accessor
void Remove(int); // mutator
bool Is_Empty(); // accessor
private:
LIST_NODE *front; // pointer to front of list
};
LINKED_LIST_CLASS::LINKED_LIST_CLASS()
{
cout << endl << \"The default constructor has been called.\ \";
front = new LIST_NODE;
front->next = 0; // initialize the next field to null
front->data = -10000;
}
LINKED_LIST_CLASS::LINKED_LIST_CLASS(LINKED_LIST_CLASS & org)
{
cout << endl << \"The copy constructor has been called.\ \";
front = new LIST_NODE;
front->next = 0;
front->data = -10000;
LIST_NODE *p = org.front->next;
LIST_NODE *back = 0;
while(p!=0)
{
if (back == 0)
{
front->next = new LIST_NODE;
back = front->next;
back->next = 0;
back->data = p->data;
}
else
{
back->next = new LIST_NODE;
back = back->next;
back->data = p->data;
back->next = 0;
}
p=p->next;
}
}
LINKED_LIST_CLASS::~LINKED_LIST_CLASS()
{
cout << endl << \"The destructor has been called.\ \";
while (front->next != 0)
{
LIST_NODE *p = front->next;
front->next = front->next->next;
delete p;
}
delete front;
front = 0;
}
void LINKED_LIST_CLASS::Add(int item)
{
LIST_NODE *p = new LIST_NODE;
p->data = item;
if (front->next== 0) // empty list
{
front->next = p;
p->next = 0;
}
else // list has information and is not empty
{
p->next = front->next;
front->next = p;
}
}
void LINKED_LIST_CLASS::Print()
{
cout << endl;
for(LIST_NODE *p = front->next; p != 0; p = p->next)
{
cout << p->data;
if (p->next != 0)
{
cout << \"-->\";
}
}
cout<next; p!=0; p=p->next)
{
if (p->data == key)
return p;
}
return 0; // key not found in list
}
void LINKED_LIST_CLASS::Remove(int key)
{
LIST_NODE *p = Search(key);
if (Is_Empty())
{
cout << key << \" is not in the list. No removal performed!\ \";
}
else
{
LIST_NODE *q = front;
while (q->next->data != key)
{
q = q->next;
}
q->next = p->next; // CRITICAL STEP!!!!
delete p;
}
}
bool LINKED_LIST_CLASS::Is_Empty()
{
return front->next == 0;
}
int main()
{
LINKED_LIST_CLASS L1;
L1.Add(5);
L1.Add(10);
L1.Add(29);
L1.Print();
LINKED_LIST_CLASS L2 = L1;
L2.Print();
L1.Remove(10);
L1.Print();
return 0;
}
Solution
#include
using namespace std;
class LIST_NODE
{
public:
int data; // data element of node
LIST_NODE *next; // pointer element of node
};
class LINKED_LIST_CLASS
{
public:
LINKED_LIST_CLASS(); // default constructor
LINKED_LIST_CLASS(LINKED_LIST_CLASS &); // copy constructor
~LINKED_LIST_CLASS(); // destructor
void Add(int); // mutator
void Print(); // accessor
LIST_NODE * Search(int); // ac.
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.
In C++ I need help with this method that Im trying to write fillLi.pdf
In C++ I need help with this method that I'm trying to write: fillListFromFile( ) : void -- this
method will add elements to the list from a file called linkedListData1.txt HINT: this is where
you will keep track of the number of elements in the list
I have all of the other methods, but I'm stuck on this one and I've added it as the last method in
the application. The code I have so far is below.
.cpp file:
.h file:
main:
#include
#include
#include
#include "Node.h"
using namespace std;
void displayList(Node*);
void insertFront(Node** head, int value);
void insertBack(Node** ptrToHead, int value);
void insertAfter(Node* previous, int value);
void deleteAtN(Node** ptrToHead, int n);
void deleteNode(Node** ptrToHead, int searchVal);
void clearList(Node**);
bool searchVal(Node** head, int value);
int countFrequencyOf(Node** ptrTohead, int value);
int size(Node** ptrTohead);
void displayFromFrontToN(Node** ptrToHead, int n);
void displayFromNToEnd(Node** ptrToHead, int n);
void insertInOrder(Node** head, Node* ptrToHead);
void displayInRows(Node** ptrToHead);
int main()
{
Node* node1 = new Node();
node1->setValue(10);
Node* node2 = new Node();
node2->setValue(20);
Node* node3 = new Node();
node3->setValue(30);
node1->next = node2;
node2->next = node3;
Node* head = node1;
displayList(head);
insertFront(&head, 5);
displayList(head);
insertBack(&head, 50);
displayList(head);
insertBack(&head, 60);
displayList(head);
insertAfter(node2, 25);
displayList(head);
deleteAtN(&head, 2);
displayList(head);
deleteNode(&head, 50);
displayList(head);
clearList(&head);
displayList(head);
insertFront(&head, 5);
insertFront(&head, 10);
insertFront(&head, 20);
insertBack(&head, 50);
searchVal(&head, 50);
displayList(head);
countFrequencyOf(&head, 25);
displayList(head);
insertBack(&head, 25);
insertFront(&head, 25);
countFrequencyOf(&head, 25);
displayList(head);
size(&head);
cout << "add one item to list" << endl;
insertBack(&head, 25);
size(&head);
displayList(head);
cout << "Display From Front To N" << endl;
displayFromFrontToN(&head, 4);
cout << "Display From N To End" << endl;
displayFromNToEnd(&head, 3);
cout << "Display In Rows" << endl;
displayInRows(&head);
insertFront(&head, 12);
insertFront(&head, 17);
insertFront(&head, 22);
insertBack(&head, 58);
cout << "Display In Rows" << endl;
displayInRows(&head);//call displayInRows()
return 0;
}//end main()
void displayList(Node* ptr) {
if (ptr == nullptr)
cout << "empty list" << endl;
else {
while (ptr != nullptr) {
cout << ptr->getValue() << endl;
ptr = ptr->next;
}
}
cout << "---------------------------" << endl;
}//end displayList()
void insertFront(Node** head, int value) {
Node* newNode = new Node();
newNode->setValue(value);
//cout<< newNode->getValue() << endl;
newNode->next = *head;
*head = newNode;
}
void insertBack(Node** ptrToHead, int value) {
Node* newNode = new Node();
newNode->setValue(value);
newNode->next = nullptr;
if (*ptrToHead == nullptr)
{
*ptrToHead = newNode;
}//end if
else
{
Node* last .
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
Data Structures and Agorithm: DS 05 Doubly Linked List.pptx
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();
}.
Program 8 C++newproblems.txt12333142013KristinBrewer1032823.docx
Program 8 C++/newproblems.txt12333/14/2013KristinBrewer10328/23/2013MarciaStephenson12228/28/2013JeremySavage11519/4/2013AlfredReddy10919/20/2013JustinLiu11734/22/2013FrancisWheeler11114/25/2013JeremyChung11934/26/2013MonicaFuller11125/1/2013ClaraGraves10535/3/2013DorothyCox11135/8/2013BryanMcCall10215/13/2013LorraineTe107210/7/2013AndreaBraun110210/8/2013DebbieBritt124210/9/2013WandaEnnis118210/11/2013TammyGrant120310/15/2013DorothyFlowers116110/16/2013ChristineBullardrrell
Program 8 C++/orderLinkedList.h
//*********************************************
// The ListNode class creates a type used to *
// store a node of the linked list. *
// PRECONDITIONS: *
// Choice for ItemType implements 'cout' *
// as well as "==" and "<" operators *
//*********************************************
#ifndef OrderOrderLinkedList_H
#define OrderOrderLinkedList_H
template <class ItemType>
class ListNode
{
public:
ItemType info; // Node value
ListNode<ItemType> *next; // Pointer to the next node
// Constructor
ListNode (ItemType nodeValue)
{
info = nodeValue;
next = NULL;
}
};
//*********************************************
// OrderLinkedList class *
//*********************************************
template <class ItemType>
class OrderLinkedList
{
private:
ListNode<ItemType> *head; // List head pointer
ListNode<ItemType> *currentPos; // Pointer to "current" list item
int length; // Length
public:
OrderLinkedList(); // Constructor
~OrderLinkedList(); // Destructor
OrderLinkedList( const OrderLinkedList<ItemType>& anotherList ); // Copy constructor
void operator= ( const OrderLinkedList<ItemType>& ); // Assignment op
void insertNode(ItemType);
void deleteNode(ItemType);
bool searchList(ItemType& item);
int getLength();
void displayList();
void resetList();
ItemType getNextItem(); // Iterator
bool atEnd();
};
//**************************************************
// Constructor *
// Initial list head pointer and length *
//**************************************************
template <class ItemType>
OrderLinkedList<ItemType>::OrderLinkedList()
{
head = NULL;
length = 0;
}
//**************************************************
// displayList shows the value stored in each node *
// of the linked list pointed to by head. *
// Precondition: "cout" operator enabled for *
// ItemType data type. *
//**************************************************
template <class ItemType>
void OrderLinkedList<ItemType>::displayList()
{
List ...
Linked list
Linked lists are linear data structures where each node contains a data field and a pointer to the next node. There are two types: singly linked lists where each node has a single next pointer, and doubly linked lists where each node has next and previous pointers. Common operations on linked lists include insertion and deletion which have O(1) time complexity for singly linked lists but require changing multiple pointers for doubly linked lists. Linked lists are useful when the number of elements is dynamic as they allow efficient insertions and deletions without shifting elements unlike arrays.
Linked lists
The document contains C++ code for implementing and testing various operations on linked lists, including adding/deleting nodes, sorting, splitting lists, reversing lists, and checking for circularity. It defines a Node struct with data and next pointer, and includes functions for initializing nodes, adding/deleting nodes, sorting, splitting, reversing lists, checking for circularity, and more. It also includes unit tests for various functions using the BOOST test framework.
Using C++I keep getting messagehead does not name a type.pdf
Using C++
I keep getting message:
\'head does not name a type\'
\'teal does not name a type\'
Where do I place this code in my program:
/*search and delete with respect to location as current, head and tail
//define below 2 lines in LinkedList() function
head = new NodeType;
tail = new NodeType;
void UnsorderedType::DeleteItem(ItemType item)
{
NodeType *tempLocation, *location;
bool stop = false;
if(!isEmpty())
{
location = head;
tempLocation = head->link;
while (templocation != tail && !stop)
{
if (templocation->info == item)
stop = true;
else
{
location = templocation;
templocation = templocation->link;
}
}
if (!stop)
cout << \"The node to delete is not in the list!\" << endl;
else
{
location->link = templocation->link;
delete templocation;
count--;
}
}
else
{
cout << \"The list is empty!\" << endl;
}
}*/
/Problem and code:
Implement the UnsortedList class to store a list of strings that are input into the list from
data2.txt.
- create a main.cpp file that gets the numbers from the file
- insert the word \"cat\" into the list
- insert another word \"antibacterial\" into the list
- delete the word \"letter\" from the list
- print out the following:
--the entire list
- the greatest
- the least
2. Attach the main.cpp, UnsortedList.cpp, the ItemType.h, and the output file one called
outfile1.txt
- Yes you need to make your program output an \"outfile1.txt\"
3. Implement the UnsortedList class to store a list of numbers that are input into the list from
data.txt.
- create a main.cpp file that gets the numbers from the file
- insert the number 7 into the list
- insert another number 300 into the list
- delete the number 6 from the list
- print out the following:
--the entire list
- the greatest
- the least
2. Attach the main.cpp, UnsortedList.cpp, the ItemType.h, and the output file two called
outfile2.txt
- Yes you need to make your program output an \"outfile2.txt\"
data.txt
super formula travel free thick Josephine Clara education
data2.txt
super formula travel free thick Josephine Clara education
//My main.cpp
//--------------------------------------------------------------
// Test driver for Linked List UnsortedType list
// Navarr Barnier
// Your class CS3350 TTh 1:00
// Due date: Thursday, September 13, 2012
//
// Compile command: g++ hw2.cpp ch03-UnsortedType.cpp ch03-ItemType.cpp
// Input file name: hw2.txt
// Contains list of commands to add items to list, split original
// list into two lists, print each list and get the length of
// each list.
// Output: The result of each command is displayed on the screen.
// Filename: hw2.cpp
//--------------------------------------------------------------
#include
#include
#include
#include
#include
#include \"ItemType.h\"
using namespace std;
void PrintList(UnsortedType&);
void SplitList(UnsortedType&, ItemType);
ItemType GetItem(ItemType& item, bool& found);
int main()
{
ifstream inFile; // file containing operations
ofstream outFS; // Output file stream
string data; // operation to be executed
s.
I need help with implementing the priority queue data structure with a.docx
I need help with implementing the priority queue data structure with a linked list implementation and with modifying my code with a template. Make sure that the code has the required methods to get the given test code in driver.cpp to work properly. I will provide the main cpp file and what I have so far below. The code is in C++. Add comments to where you modified the code, so I know what you did to change it. Thank you.
//////////////////////// driver.cpp /////////////////////////////
#include <iostream>
#include <string>
#include "stackLL.h"
#include "queueLL.h"
#include "priorityQueueLL.h"
using namespace std;
int main()
{
/////////////Test code for stack ///////////////
stackLL stk;
stk.push(5);
stk.push(13);
stk.push(7);
stk.push(3);
stk.push(2);
stk.push(11);
cout << "Popping: " << stk.pop() << endl;
cout << "Popping: " << stk.pop() << endl;
stk.push(17);
stk.push(19);
stk.push(23);
while (!stk.empty())
{
cout << "Popping: " << stk.pop() << endl;
}
// output order: 11,2,23,19,17,3,7,13,5
stackLL stkx;
stkx.push(5);
stkx.push(10);
stkx.push(15);
stkx.push(20);
stkx.push(25);
stkx.push(30);
stkx.insertAt(-100, 3);
stkx.insertAt(-200, 7);
stkx.insertAt(-300, 0);
//output order: -300,30,25,20,-100,15,10,5,-200
while (!stkx.empty())
cout << "Popping: " << stkx.pop() << endl;
///////////////////////////////////////
//////////Test code for queue ///////////
queueLL Q;
Q.enqueue(1);
Q.enqueue(2);
Q.enqueue(3);
cout << "Dequeuing: " << Q.dequeue() << endl; //1
cout << "Dequeuing: " << Q.dequeue() << endl; //2
Q.enqueue(4);
Q.enqueue(5);
//3 4 5
while (!Q.empty())
{
cout << "Dequeuing: " << Q.dequeue() << endl;
}
/////////////////////////////////////////
//////////Test code for priority queue/////
priorityQueueLL<int> pQueue;
const int SIZE = 20;
//insert a bunch of random numbers
for (int i = 0; i < SIZE; i++)
{
pQueue.insert(rand());
}
//pull them back out..
//They must come out in order from smallest to largest
while (!pQueue.empty())
{
cout << pQueue.extractMin() << endl;
}
priorityQueueLL<string> pqs;
pqs.insert("whale");
pqs.insert("snake");
pqs.insert("buffalo");
pqs.insert("elmo");
pqs.insert("fire");
pqs.insert("waffle");
//buffalo elmo fire snake waffle whale
while (!pqs.empty())
{
cout << pqs.extractMin() << endl;
}
///////////////////////////////////////////
//1) Template your queue class
//2) Add a decimate method to your queue class
queueLL<int> qx;
for (int i = 1; i <= 100; i++)
qx.enqueue(i);
//Eliminate every 10th item from list
//https://en.wikipedia.org/wiki/Decimation_(punishment)
qx.decimate();
//1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 21 22... 98 99
while (!qx.empty())
cout << qx.dequeue() << endl;
queueLL<string> qy;
qy.enqueue("sparticus");
qy.enqueue("maximus");
qy.enqueue("killicus");
qy.enqueue("awesomeicus");
qy.enqueue("gannicus");
qy.enqueue("varro");
qy.enqueue("oenomous");
qy.enqueue("slayicus");
qy.enqueue("bladeicus");
qy.enqueue("ted.
Shapes and calculate (area and contour) / C++ oop concept
The document describes a C++ program that uses object-oriented programming concepts to represent matrices and perform operations on them like addition, finding the maximum value, and calculating the total sum. The program uses linked lists to store the matrix elements and defines functions for reading, writing, adding, and analyzing matrices. It provides a menu-driven interface for users to choose different operations to perform on matrices of varying sizes.
Link list part 2
This document discusses linked lists and their applications. It contains the following key points:
1. Linked lists can be used to implement stacks and queues using nodes with next pointers. Circular linked lists are also discussed where the last node points back to the first node.
2. The code template provided shows the implementation of a queue using a linked list with nodes containing data and next pointers. Functions like add, delete, and empty are demonstrated.
3. Doubly linked lists are introduced which contain previous and next pointers in each node. This allows traversal in both directions and simplifies operations like deletion compared to circular single linked lists.
Shapes and calculate (area and contour) / C++ oop concept
The document describes a C++ program that uses object-oriented programming concepts to represent matrices and perform operations on them such as reading, writing, adding, summing elements, and finding the maximum element. The main functionality includes defining a struct to represent matrix elements and nodes, reading in matrices from user input, writing matrices to output, adding two matrices by iterating through their elements, summing all elements of a matrix, and finding the maximum value and its position. The program uses a menu to allow the user to choose which operation to perform on sample matrices.
Binary Tree in C++ coding in the data structure
This document discusses binary trees and binary search trees in C++. It includes functions to create and traverse binary trees in preorder, inorder, and postorder fashion. For binary search trees, it includes functions to insert nodes, perform inorder traversal, find the minimum value node, and delete nodes. These data structures and functions provide ways to organize and manipulate tree-based data in C++ programs.
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Create a link list. Add some nodes to it, search and delete nodes from it.
Solution
#include
#include
using std::cout;
using std::endl;
/*
A linked list is a list constructed using pointers. It is not fixed in
size and could grow and shrink while the program is running.
A typical defination of list nodes contains at least two parts, both the
content or date of each element and the pointer to the next element,
which is shown in the figure below.
+---------+
| Data | -----> holds the data of this element in the list.
+---------+
| pointer | -----> is a pointer to the next element in the list.
+---------+
***Attention***:
The pointer holds the address of the next element, not the address of the
data in the next element, even though they are the same in value sometimes.
And It should be set to NULL while acting as the last node of the list.
Implementation of the single linked list:
+---------+ --->+---------+ --->+---------+
| Data | | | Data | | | Data |
+---------+ | +---------+ | +---------+
| pointer |----- | pointer |----- | pointer |
+---------+ +---------+ +---------+
*/
/* definition of the list node class */
class Node
{
friend class LinkedList;
private:
int _value; /* data, can be any data type, but use integer for easiness */
Node *_pNext; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: _pNext(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: _value(val), _pNext(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: _value(val), _pNext(next)
{}
/* Getters */
int getValue(void)
{ return _value; }
Node* getNext(void)
{ return _pNext; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *_pHead;
/* pointer of tail node */
Node *_pTail;
public:
/* Constructors with No Arguments */
LinkedList(void);
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to add a node at the head of a linked list */
void headInsert(int val);
/* Function to add a node in the middle of a linked list */
void insertAfter(Node* afterMe, int val);
/* Function to append a node to the end of a linked list */
void tailAppend(int val);
/* Function to get the node in the specific position */
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
LinkedList::LinkedList()
{
/* Initialize the head and tail node */
_pHead = _pTail = NULL;
}
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
_pHead = new Node(val);
_pTail = _pHead;
}
LinkedList::~LinkedList()
{
/*
* Leave it empty temporarily.
* It will be described in detail in the example \"How to delete a linkedlist\".
*/
}
void LinkedList::headInsert(int val)
{
/* The list is empty? */
if (_pHead == NULL) {
/* the same to create a new list with a given value */
_pTail = _pHead = new Node(val);
.
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
#includeiostream #includecstdio #includecstdlib using na.pdf
#include
#include
#include
using namespace std;
struct node
{
int val;
struct node *next;
}*startNode;
// declaring class
class LinkedList
{
public:
node* create_node(int);
void insert_last();
void sort();
void search();
void reverse();
void display();
LinkedList()
{
startNode = NULL;
}
};
// main
main()
{
int userChoice, linkedListNodes, i;
LinkedList LinkList;
startNode = NULL;
while (1)
{
// displaying menu
cout<<\" 1)Insert\";
cout<<\"2) Remove\";
cout<<\"3) Search\";
cout<<\"4) Display\";
cout<<\"5) Reverse\";
cout<<\"6) Exit \";
// reading user choice
cout<<\"Enter your userChoice : \";
cin>>userChoice;
switch(userChoice)
{
case 1:
cout<<\"Inserting node to linked list: \";
LinkList.insert_begin();
cout;
break;
case 2:
cout<<\"Delete element from linked list: \";
LinkList.delete();
break;
case 3:
cout<<\"Searching data in linked list: \";
LinkList.search();
cout;
break;
case 4:
cout<<\"Displaying linked list data: \";
LinkList.display();
cout;
break;
case 5:
cout<<\"Linked list reversing: \";
LinkList.reverse();
cout;
break;
case 6:
cout<<\"Exiting...\";
exit(1);
break;
default:
cout<<\"Enter correct userChoice\";
}
}
}
// node creating to store into list
node *LinkedList::create_node(int val)
{
struct node *tempNode, *tempNode;
tempNode = new(struct node);
if (tempNode == NULL)
{
cout<<\"No memory allocated \";
return 0;
}
else
{
tempNode->val = val;
tempNode->next = NULL;
return tempNode;
}
}
/*
* Inserting Node at last
*/
void LinkedList::insert_last()
{
int val;
cout<<\"Enter the val to be inserted: \";
cin>>val;
struct node *tempNode, *tempNode;
tempNode = create_node(val);
tempNode = startNode;
while (tempNode->next != NULL)
{
tempNode = tempNode->next;
}
tempNode->next = NULL;
tempNode->next = tempNode;
cout<<\"Element Inserted\";
}
// deleting element
void LinkedList::delete()
{
int position, i, count = 0;
if (startNode == NULL)
{
cout<<\"Linkedlist empty\"<>position;
struct node *tempNode, *ptr;
tempNode = startNode;
if (position == 1)
{
startNode = tempNode->next;
}
else
{
while (tempNode != NULL)
{
tempNode = tempNode->next;
count++;
}
if (position > 0 && position <= count)
{
tempNode = startNode;
for (i = 1;i < position;i++)
{
ptr = tempNode;
tempNode = tempNode->next;
}
ptr->next = tempNode->next;
}
else
{
cout<<\"Enter correct position\";
}
}
}
// search data in linked list
void LinkedList::search()
{
int val, position = 0;
bool flagValue = false;
if (startNode == NULL)
{
cout<<\"List is empty\";
return;
}
cout<<\"Enter the val to search: \";
cin>>val;
struct node *tempNode;
tempNode = startNode;
while (tempNode != NULL)
{
position++;
if (tempNode->val == val)
{
flagValue = true;
cout<<\"Data \"<next;
}
if (!flagValue)
cout<<\"data not found\";
}
// linkedlist reverese
void LinkedList::reverse()
{
struct node *pointer1, *pointer2, *pointer3;
if (startNode == NULL)
{
cout<<\"List is empty\"<next == NULL)
{
return;
}
pointer1 = startNode;
pointer2 = pointer1->next;
pointer3 = pointer2->next;
pointer1->next = NULL;
pointer2->.
LISTINGS.txt345678 116900 0 80513-2918 Metro Brokers432395.docx
LISTINGS.txt
345678 116900 0 80513-2918 Metro Brokers
432395 150743 1 80512-2771 City Realty
353455 342522 2 34534-3454 Upper East
999999 99999 2 92130-1312 This Test
555555 555555 0 77777-7777 Final Test
CHANGES.txt
432395 -25000
353455 -2500
221111 -1000
345678 +5000
HodellAssn#6.cpp
//*************************************************************************
#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <cctype>
using namespace std;
// Global structure definition
enum availability { AVAILABLE, CONTRACT, SOLD };
struct propertiesRec
{
int mlsNum;
double price;
availability status;
string zipCode;
string realtor;
};
//FUNCTION PROTOTYPES SECTION -
//Previous Lab#4 functions with linked list mods
void IntroProgram ();
char MenuOne();
char UserMenuChoices ();
void Add_New_Listing ();
int Existing_Listings ();
int Get_Validate_MLS_Input ();
double Get_Validate_Price_Input ();
availability Get_Status_Entry();
string Status_Enum_Text ( int );
string Get_Validate_ZipCode_Input ();
string Get_Validate_Realtor_Input ();
int CountIntegers( int );
void Display_MLS_Numbers ();
bool Does_File_Exist(const char *fileName);
//Class Definition - New Lab#6 Functions
class node
{
propertiesRec Xdata;
node *next;
public:
//Default constructor used to initialize variable with values
node() { next=0; }
//Constructor with parameters
node ( propertiesRec varibable ) { Xdata = varibable; next = 0; }
void put_next ( node *n ) { next = n; }
node *Get_Next ( ) { return next; }
int Get_MLS ( ) { return Xdata.mlsNum; }
double Get_AskingPrice ( ) { return Xdata.price; }
int Get_ListingStatus ( ) { return Xdata.status; }
string Get_ZipCode() { return Xdata.zipCode; }
string Get_Realtor() { return Xdata.realtor; }
void SetAskingPrice( double );
void Append_List( propertiesRec );
void Remove_Node();
void DisplayListings();
void WriteToFile();
void ChangeAskingPrice();
//Declaring two nodes: header and 'n' initialized to 0.
} *header=0, *n=0;
//Input data constants
const int MAX_REALTY_NAME = 15;
const int MAX_ZIPCODE = 10;
const char Y_UPPERCASE = 'Y';
const char N_UPPERCASE = 'N';
const char ADD_LISTING = 'A';
const char REMOVE_LISTING = 'R';
const char DISPLAY_ALL = 'D';
const char CHANGE_ASKING_PRICE = 'C';
const char EXIT_PROGRAM = 'E';
//*************************************************************************
// FUNCTION: main
// DESCRIPTION: Main function will call various functions to read, input,
// calculate and display per account the phone usage totals
// CALLS TO:
// IntroProgram
//*************************************************************************
int main() {
// variables
int count;
char additional;
...
Implement of c & its coding programming by sarmad baloch
The C program implements a singly linked list with functions to insert and delete nodes, print the list, find a node by key, sort the list by data, and reverse the list. It demonstrates using the functions to create a list, delete all nodes, find and delete a node, sort the list, and reverse it, printing the list after each operation.
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 .
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 StructuresPlease I need help completing this c++ program..pdf
Data Structures
Please I need help completing this c++ program. it was giving to complete it with no other
discriptions.
#include
using namespace std;
template
struct node
{
datatype info;
node *left, *right;
};
template
class tree
{
public:
tree();
~tree();
bool isempty();
void inserttree(datatype data);
void print();
private:
node *root;
};
template
tree::tree()
{
root = NULL;
}
template
void tree ::inserttree(datatype data)
{
node *temp;
temp = new node ;
temp->left = NULL;
temp->right = NULL;
temp->info = data;
if (root == NULL)
root = temp;
else
before = NULL;
after = root;
while (after != NULL)
{
b = a;
root
...;
else
}
if(temp->info< before->info)
before->left = temp;
else
before->right = temp;
//before = after;
//if (temp->info < after->info)
//after = after->left;
//else
//after = after->right;
//if(temp->info< before->info)
//before->left = temp;
//else
//before->right = temp;
}
template
void tree ::print(tree *temp)
{
if (temp != NULL)
{
print(temp->left);
cout << temp->info << endl;
print(temp->right);
}
p();
print(root);
}
int main()
{
tree t;
//put this in a loop
t.inserttree(90);
t.inserttree(80);
t.inserttree(108);
t.p();
}
Solution
// HEADER FILE FOR BINARY TREE//
// Define a structure to be used as the tree node
struct TreeNode
{
int Key;
float fValue;
int iValue;
char cArray[7];
TreeNode *left;
TreeNode *right;
};
class Code202_Tree
{
private:
TreeNode *root;
public:
Code202_Tree();
~Code202_Tree();
bool isEmpty();
TreeNode *SearchTree(int Key);
bool Insert(TreeNode *newNode);
bool Insert(int Key, float f, int i, char *cA);
bool Delete(int Key);
void PrintOne(TreeNode *T);
void PrintTree();
private:
void ClearTree(TreeNode *T);
TreeNode *DupNode(TreeNode * T);
void PrintAll(TreeNode *T);
};
#endif
//IMPLEMENTATION .CPP FILE FOR BINARY TREE//
#include
#include
#include \"Code202_Tree.h\"
using namespace std;
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class constructor.
//--------------------------------------------
Code202_Tree::Code202_Tree()
{
root = NULL;
return;
}
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class destructor.
//--------------------------------------------
Code202_Tree::~Code202_Tree()
{
ClearTree(root);
return;
}
//--------------------------------------------
// Function: ClearTree()
// Purpose: Perform a recursive traversal of
// a tree destroying all nodes.
//--------------------------------------------
void Code202_Tree::ClearTree(TreeNode *T)
{
if(T==NULL) return; // Nothing to clear
if(T->left != NULL) ClearTree(T->left); // Clear left sub-tree
if(T->right != NULL) ClearTree(T->right); // Clear right sub-tree
delete T; // Destroy this node
return;
}
//--------------------------------------------
// Function: isEmpty()
// Purpose: Return TRUE if tree is empty.
//--------------------------------------------
bool Code202_Tree::isEmpty()
{
return(root==NULL);
}
//--------------------------------------------
// Function.
File name a2.cppTaskFor this assignment, you are required to ei.pdf
File name: a2.cpp
Task
For this assignment, you are required to either A) modify your linked list code to implement a
queue or B) modify the provided stack code to implement a queue. Your program should
implement a C++ queue class with the following member functions:
- Void enq(int)
- Void deq()
- Void front()
- Bool isEmpty()
- Void printq()
Your program will take in a command file called “cmd.txt” which will instruct your program
what operations to run
File Format
<0 or 1 arguments>
Commands
- 1 enq
- 2 deq
- 3 front
- 4 isEmpty
- 5 printq
Example File
1 1
5
1 2
5
1 3
5
1 4
5
3
2
5
2
5
3
Expectations
You should not use any already pre implemented code for your queue such as a standard library
object
Your code should be well formatted with proper spacing and proper naming
Your code should have well named variables. No a’s b’s or c’s as names unless it is for
something like a loop counter
Your code should have the same output formatting you see below
Your code MUST follow the formatting you see below
Your file MUST be named a2.cpp
My example file does not contain all possible test cases it is up to you to determine any other
special cases to test your program against.
Example Output
//LinkedList class
#include
#include
#include
#include
#include
using namespace std;
struct Node
{
int data;
Node *next;
};
class LinkedList
{
private:
Node *head;
Node *tail;
public:
LinkedList(); //constructor
void prepend(int num);
void append(int num);
void removeFront();
void removeBack();
void remove(int num);
int search(int num);
void printList();
};
//constructor
LinkedList::LinkedList()
{
head=NULL;
tail=NULL;
}
//prepend() method
void LinkedList::prepend(int num)
{
//allocate space for new node
Node *node=new Node;
//populate node
node->data=num;
node->next= NULL;
//attach new node to start of list
//if linked list empty
if(head==NULL)
{
head=node;
tail=node;
}
else //linked list not empty
{
node->next=head;
head=node;
}
}
//append() method
void LinkedList::append(int num)
{
//allocate space for new node
Node *node=new Node;
//populate node
node->data=num;
node->next= NULL;
//attach new node to end of list
//if linked list empty
if(head==NULL)
{
head=node;
tail=node;
}
else //linked list not empty
{
tail->next=node;
tail=node;
}
}
//removeFront() method
void LinkedList::removeFront()
{
//if linked list empty, then underflow
if(head==NULL)
{
cerr<<\"Underflow\"<next;
//delete node
cout<<\"Removing \"<data<<\" from the list\"<next!=NULL)
{
/*if(curr==tail)
break;*/
prev=curr;
curr=curr->next;
}
prev->next=NULL;
tail=prev;
//delete node
cout<<\"Removing \"<data<<\" from the list\"<data=num)
break;
prev=curr;
curr=curr->next;
}
//preserve node
Node *temp=curr;
//detach node from linked list
prev->next=curr->next;
//delete node
cout<<\"Removing \"<data<<\" from the list\"<data=num)
{
found=1; //num found
break;
}
curr=curr->next;
}
return found;
}
//printList() method
void LinkedList::printList()
{
//traverse linked list
Node *curr=head;
while(curr!=NULL)
{
c.
solution in c++program Program to implement a queue using two .pdf
solution in c++
program
/* Program to implement a queue using two stacks */
#include
#include
using namespace std;
/* structure of a stack node */
struct sNode
{
int data;
struct sNode *next;
};
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data);
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref);
/* structure of queue having two stacks */
struct queue
{
struct sNode *stack1;
struct sNode *stack2;
};
/* Function to enqueue an item to queue */
void enQueue(struct queue *q, int x)
{
push(&q->stack1, x);
}
/* Function to dequeue an item from queue */
int deQueue(struct queue *q)
{
int x;
/* If both stacks are empty then error */
if(q->stack1 == NULL && q->stack2 == NULL)
{
printf(\"Q is empty\");
getchar();
exit(0);
}
/* Move elements from satck1 to stack 2 only if
stack2 is empty */
if(q->stack2 == NULL)
{
while(q->stack1 != NULL)
{
x = pop(&q->stack1);
push(&q->stack2, x);
}
}
x = pop(&q->stack2);
return x;
}
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data)
{
/* allocate node */
struct sNode* new_node =
(struct sNode*) malloc(sizeof(struct sNode));
if(new_node == NULL)
{
printf(\"Stack is empty \ \");
getchar();
exit(0);
}
else{
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*top_ref);
/* move the head to point to the new node */
(*top_ref) = new_node;
}
}
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref)
{
int res;
struct sNode *top;
/*If stack is empty then error */
if(*top_ref == NULL)
{
printf(\"Stack overflow \ \");
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->data;
*top_ref = top->next;
free(top);
return res;
}
}
/* Driver function to test anove functions */
int main()
{
/* Create a queue with items 1 2 3*/
struct queue *q = (struct queue*)malloc(sizeof(struct queue));
q->stack1 = NULL;
q->stack2 = NULL;
for(int i=0;i<15;i++)
{
enQueue(q, i);
}
//enQueue(q, 2);
//enQueue(q, 3);
//enQueue(q,4);
/* Dequeue items */
printf(\"the dequeue items\");
for(int i=0;i<16;i++)
{
printf(\"%d \", deQueue(q));
//printf(\"%d \", deQueue(q));
}
getchar();
}
output
the dequeue items
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
q is empty
Solution
solution in c++
program
/* Program to implement a queue using two stacks */
#include
#include
using namespace std;
/* structure of a stack node */
struct sNode
{
int data;
struct sNode *next;
};
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data);
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref);
/* structure of queue having two stacks */
struct queue
{
struct sNode *stack1;
struct sNode *stack2;
};
/* Function to enqueue an item to queue */
void enQueue(struct queue *q, int x)
{
push(&q->stack1, x);
}
/* Function to dequeue an item from queue */
int deQueue(struct queue *q)
{
int x;
/* If both stacks are empty then error */
if(q->stack1 == NULL && q->stack2 == NULL)
{
printf(\"Q .
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.
IN KOTLIN PLZ Define a public class named Stepper with a single instan.pdf
IN KOTLIN PLZ
Define a public class named Stepper with a single instance method named next that takes no
parameters and returns an Int. Called multiple times, next returns a sequence of values separated
by a step amount provided to the primary constructor. Stepper should also provide a primary
constructor that accepts a Int argument and sets the step amount. Stepper maintains two pieces of
private state: the step amount, and the current value, which always starts at 0 . The step amount
is passed to the constructor, and should be part of your primary constructor declaration. But the
current value should be declared separately. Calling next increments the current value by the step
amount, but returns the previous value. So, for example: Note that the internal state should be
private..
In less than two pages- I want you to examine the pattern of human pop.pdf
In less than two pages, I want you to examine the pattern of human population over the
past 10,000 years and describe the factors that influenced it: become familiar with the work
of Thomas Robert Malthus in the area of population growth and briefly describe its
relevance to human populations and development. describe the demographic transition and
summarize the stages of the demographic transition model finally, explain any limitations
of you see in this model..
More Related Content
Similar to Implement a priority queue using a doublyLinked-cpp where the node wit.pdf
Program 8 C++newproblems.txt12333142013KristinBrewer1032823.docx
Program 8 C++/newproblems.txt12333/14/2013KristinBrewer10328/23/2013MarciaStephenson12228/28/2013JeremySavage11519/4/2013AlfredReddy10919/20/2013JustinLiu11734/22/2013FrancisWheeler11114/25/2013JeremyChung11934/26/2013MonicaFuller11125/1/2013ClaraGraves10535/3/2013DorothyCox11135/8/2013BryanMcCall10215/13/2013LorraineTe107210/7/2013AndreaBraun110210/8/2013DebbieBritt124210/9/2013WandaEnnis118210/11/2013TammyGrant120310/15/2013DorothyFlowers116110/16/2013ChristineBullardrrell
Program 8 C++/orderLinkedList.h
//*********************************************
// The ListNode class creates a type used to *
// store a node of the linked list. *
// PRECONDITIONS: *
// Choice for ItemType implements 'cout' *
// as well as "==" and "<" operators *
//*********************************************
#ifndef OrderOrderLinkedList_H
#define OrderOrderLinkedList_H
template <class ItemType>
class ListNode
{
public:
ItemType info; // Node value
ListNode<ItemType> *next; // Pointer to the next node
// Constructor
ListNode (ItemType nodeValue)
{
info = nodeValue;
next = NULL;
}
};
//*********************************************
// OrderLinkedList class *
//*********************************************
template <class ItemType>
class OrderLinkedList
{
private:
ListNode<ItemType> *head; // List head pointer
ListNode<ItemType> *currentPos; // Pointer to "current" list item
int length; // Length
public:
OrderLinkedList(); // Constructor
~OrderLinkedList(); // Destructor
OrderLinkedList( const OrderLinkedList<ItemType>& anotherList ); // Copy constructor
void operator= ( const OrderLinkedList<ItemType>& ); // Assignment op
void insertNode(ItemType);
void deleteNode(ItemType);
bool searchList(ItemType& item);
int getLength();
void displayList();
void resetList();
ItemType getNextItem(); // Iterator
bool atEnd();
};
//**************************************************
// Constructor *
// Initial list head pointer and length *
//**************************************************
template <class ItemType>
OrderLinkedList<ItemType>::OrderLinkedList()
{
head = NULL;
length = 0;
}
//**************************************************
// displayList shows the value stored in each node *
// of the linked list pointed to by head. *
// Precondition: "cout" operator enabled for *
// ItemType data type. *
//**************************************************
template <class ItemType>
void OrderLinkedList<ItemType>::displayList()
{
List ...
Linked list
Linked lists are linear data structures where each node contains a data field and a pointer to the next node. There are two types: singly linked lists where each node has a single next pointer, and doubly linked lists where each node has next and previous pointers. Common operations on linked lists include insertion and deletion which have O(1) time complexity for singly linked lists but require changing multiple pointers for doubly linked lists. Linked lists are useful when the number of elements is dynamic as they allow efficient insertions and deletions without shifting elements unlike arrays.
Linked lists
The document contains C++ code for implementing and testing various operations on linked lists, including adding/deleting nodes, sorting, splitting lists, reversing lists, and checking for circularity. It defines a Node struct with data and next pointer, and includes functions for initializing nodes, adding/deleting nodes, sorting, splitting, reversing lists, checking for circularity, and more. It also includes unit tests for various functions using the BOOST test framework.
Using C++I keep getting messagehead does not name a type.pdf
Using C++
I keep getting message:
\'head does not name a type\'
\'teal does not name a type\'
Where do I place this code in my program:
/*search and delete with respect to location as current, head and tail
//define below 2 lines in LinkedList() function
head = new NodeType;
tail = new NodeType;
void UnsorderedType::DeleteItem(ItemType item)
{
NodeType *tempLocation, *location;
bool stop = false;
if(!isEmpty())
{
location = head;
tempLocation = head->link;
while (templocation != tail && !stop)
{
if (templocation->info == item)
stop = true;
else
{
location = templocation;
templocation = templocation->link;
}
}
if (!stop)
cout << \"The node to delete is not in the list!\" << endl;
else
{
location->link = templocation->link;
delete templocation;
count--;
}
}
else
{
cout << \"The list is empty!\" << endl;
}
}*/
/Problem and code:
Implement the UnsortedList class to store a list of strings that are input into the list from
data2.txt.
- create a main.cpp file that gets the numbers from the file
- insert the word \"cat\" into the list
- insert another word \"antibacterial\" into the list
- delete the word \"letter\" from the list
- print out the following:
--the entire list
- the greatest
- the least
2. Attach the main.cpp, UnsortedList.cpp, the ItemType.h, and the output file one called
outfile1.txt
- Yes you need to make your program output an \"outfile1.txt\"
3. Implement the UnsortedList class to store a list of numbers that are input into the list from
data.txt.
- create a main.cpp file that gets the numbers from the file
- insert the number 7 into the list
- insert another number 300 into the list
- delete the number 6 from the list
- print out the following:
--the entire list
- the greatest
- the least
2. Attach the main.cpp, UnsortedList.cpp, the ItemType.h, and the output file two called
outfile2.txt
- Yes you need to make your program output an \"outfile2.txt\"
data.txt
super formula travel free thick Josephine Clara education
data2.txt
super formula travel free thick Josephine Clara education
//My main.cpp
//--------------------------------------------------------------
// Test driver for Linked List UnsortedType list
// Navarr Barnier
// Your class CS3350 TTh 1:00
// Due date: Thursday, September 13, 2012
//
// Compile command: g++ hw2.cpp ch03-UnsortedType.cpp ch03-ItemType.cpp
// Input file name: hw2.txt
// Contains list of commands to add items to list, split original
// list into two lists, print each list and get the length of
// each list.
// Output: The result of each command is displayed on the screen.
// Filename: hw2.cpp
//--------------------------------------------------------------
#include
#include
#include
#include
#include
#include \"ItemType.h\"
using namespace std;
void PrintList(UnsortedType&);
void SplitList(UnsortedType&, ItemType);
ItemType GetItem(ItemType& item, bool& found);
int main()
{
ifstream inFile; // file containing operations
ofstream outFS; // Output file stream
string data; // operation to be executed
s.
I need help with implementing the priority queue data structure with a.docx
I need help with implementing the priority queue data structure with a linked list implementation and with modifying my code with a template. Make sure that the code has the required methods to get the given test code in driver.cpp to work properly. I will provide the main cpp file and what I have so far below. The code is in C++. Add comments to where you modified the code, so I know what you did to change it. Thank you.
//////////////////////// driver.cpp /////////////////////////////
#include <iostream>
#include <string>
#include "stackLL.h"
#include "queueLL.h"
#include "priorityQueueLL.h"
using namespace std;
int main()
{
/////////////Test code for stack ///////////////
stackLL stk;
stk.push(5);
stk.push(13);
stk.push(7);
stk.push(3);
stk.push(2);
stk.push(11);
cout << "Popping: " << stk.pop() << endl;
cout << "Popping: " << stk.pop() << endl;
stk.push(17);
stk.push(19);
stk.push(23);
while (!stk.empty())
{
cout << "Popping: " << stk.pop() << endl;
}
// output order: 11,2,23,19,17,3,7,13,5
stackLL stkx;
stkx.push(5);
stkx.push(10);
stkx.push(15);
stkx.push(20);
stkx.push(25);
stkx.push(30);
stkx.insertAt(-100, 3);
stkx.insertAt(-200, 7);
stkx.insertAt(-300, 0);
//output order: -300,30,25,20,-100,15,10,5,-200
while (!stkx.empty())
cout << "Popping: " << stkx.pop() << endl;
///////////////////////////////////////
//////////Test code for queue ///////////
queueLL Q;
Q.enqueue(1);
Q.enqueue(2);
Q.enqueue(3);
cout << "Dequeuing: " << Q.dequeue() << endl; //1
cout << "Dequeuing: " << Q.dequeue() << endl; //2
Q.enqueue(4);
Q.enqueue(5);
//3 4 5
while (!Q.empty())
{
cout << "Dequeuing: " << Q.dequeue() << endl;
}
/////////////////////////////////////////
//////////Test code for priority queue/////
priorityQueueLL<int> pQueue;
const int SIZE = 20;
//insert a bunch of random numbers
for (int i = 0; i < SIZE; i++)
{
pQueue.insert(rand());
}
//pull them back out..
//They must come out in order from smallest to largest
while (!pQueue.empty())
{
cout << pQueue.extractMin() << endl;
}
priorityQueueLL<string> pqs;
pqs.insert("whale");
pqs.insert("snake");
pqs.insert("buffalo");
pqs.insert("elmo");
pqs.insert("fire");
pqs.insert("waffle");
//buffalo elmo fire snake waffle whale
while (!pqs.empty())
{
cout << pqs.extractMin() << endl;
}
///////////////////////////////////////////
//1) Template your queue class
//2) Add a decimate method to your queue class
queueLL<int> qx;
for (int i = 1; i <= 100; i++)
qx.enqueue(i);
//Eliminate every 10th item from list
//https://en.wikipedia.org/wiki/Decimation_(punishment)
qx.decimate();
//1 2 3 4 5 6 7 8 9 11 12 13 14 15 16 17 18 19 21 22... 98 99
while (!qx.empty())
cout << qx.dequeue() << endl;
queueLL<string> qy;
qy.enqueue("sparticus");
qy.enqueue("maximus");
qy.enqueue("killicus");
qy.enqueue("awesomeicus");
qy.enqueue("gannicus");
qy.enqueue("varro");
qy.enqueue("oenomous");
qy.enqueue("slayicus");
qy.enqueue("bladeicus");
qy.enqueue("ted.
Shapes and calculate (area and contour) / C++ oop concept
The document describes a C++ program that uses object-oriented programming concepts to represent matrices and perform operations on them like addition, finding the maximum value, and calculating the total sum. The program uses linked lists to store the matrix elements and defines functions for reading, writing, adding, and analyzing matrices. It provides a menu-driven interface for users to choose different operations to perform on matrices of varying sizes.
Link list part 2
This document discusses linked lists and their applications. It contains the following key points:
1. Linked lists can be used to implement stacks and queues using nodes with next pointers. Circular linked lists are also discussed where the last node points back to the first node.
2. The code template provided shows the implementation of a queue using a linked list with nodes containing data and next pointers. Functions like add, delete, and empty are demonstrated.
3. Doubly linked lists are introduced which contain previous and next pointers in each node. This allows traversal in both directions and simplifies operations like deletion compared to circular single linked lists.
Shapes and calculate (area and contour) / C++ oop concept
The document describes a C++ program that uses object-oriented programming concepts to represent matrices and perform operations on them such as reading, writing, adding, summing elements, and finding the maximum element. The main functionality includes defining a struct to represent matrix elements and nodes, reading in matrices from user input, writing matrices to output, adding two matrices by iterating through their elements, summing all elements of a matrix, and finding the maximum value and its position. The program uses a menu to allow the user to choose which operation to perform on sample matrices.
Binary Tree in C++ coding in the data structure
This document discusses binary trees and binary search trees in C++. It includes functions to create and traverse binary trees in preorder, inorder, and postorder fashion. For binary search trees, it includes functions to insert nodes, perform inorder traversal, find the minimum value node, and delete nodes. These data structures and functions provide ways to organize and manipulate tree-based data in C++ programs.
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Create a link list. Add some nodes to it, search and delete nodes from it.
Solution
#include
#include
using std::cout;
using std::endl;
/*
A linked list is a list constructed using pointers. It is not fixed in
size and could grow and shrink while the program is running.
A typical defination of list nodes contains at least two parts, both the
content or date of each element and the pointer to the next element,
which is shown in the figure below.
+---------+
| Data | -----> holds the data of this element in the list.
+---------+
| pointer | -----> is a pointer to the next element in the list.
+---------+
***Attention***:
The pointer holds the address of the next element, not the address of the
data in the next element, even though they are the same in value sometimes.
And It should be set to NULL while acting as the last node of the list.
Implementation of the single linked list:
+---------+ --->+---------+ --->+---------+
| Data | | | Data | | | Data |
+---------+ | +---------+ | +---------+
| pointer |----- | pointer |----- | pointer |
+---------+ +---------+ +---------+
*/
/* definition of the list node class */
class Node
{
friend class LinkedList;
private:
int _value; /* data, can be any data type, but use integer for easiness */
Node *_pNext; /* pointer to the next node */
public:
/* Constructors with No Arguments */
Node(void)
: _pNext(NULL)
{ }
/* Constructors with a given value */
Node(int val)
: _value(val), _pNext(NULL)
{ }
/* Constructors with a given value and a link of the next node */
Node(int val, Node* next)
: _value(val), _pNext(next)
{}
/* Getters */
int getValue(void)
{ return _value; }
Node* getNext(void)
{ return _pNext; }
};
/* definition of the linked list class */
class LinkedList
{
private:
/* pointer of head node */
Node *_pHead;
/* pointer of tail node */
Node *_pTail;
public:
/* Constructors with No Arguments */
LinkedList(void);
/* Constructors with a given value of a list node */
LinkedList(int val);
/* Destructor */
~LinkedList(void);
/* Function to add a node at the head of a linked list */
void headInsert(int val);
/* Function to add a node in the middle of a linked list */
void insertAfter(Node* afterMe, int val);
/* Function to append a node to the end of a linked list */
void tailAppend(int val);
/* Function to get the node in the specific position */
Node* getNode(int pos);
/* Traversing the list and printing the value of each node */
void traverse_and_print();
};
LinkedList::LinkedList()
{
/* Initialize the head and tail node */
_pHead = _pTail = NULL;
}
LinkedList::LinkedList(int val)
{
/* Create a new node, acting as both the head and tail node */
_pHead = new Node(val);
_pTail = _pHead;
}
LinkedList::~LinkedList()
{
/*
* Leave it empty temporarily.
* It will be described in detail in the example \"How to delete a linkedlist\".
*/
}
void LinkedList::headInsert(int val)
{
/* The list is empty? */
if (_pHead == NULL) {
/* the same to create a new list with a given value */
_pTail = _pHead = new Node(val);
.
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
#includeiostream #includecstdio #includecstdlib using na.pdf
#include
#include
#include
using namespace std;
struct node
{
int val;
struct node *next;
}*startNode;
// declaring class
class LinkedList
{
public:
node* create_node(int);
void insert_last();
void sort();
void search();
void reverse();
void display();
LinkedList()
{
startNode = NULL;
}
};
// main
main()
{
int userChoice, linkedListNodes, i;
LinkedList LinkList;
startNode = NULL;
while (1)
{
// displaying menu
cout<<\" 1)Insert\";
cout<<\"2) Remove\";
cout<<\"3) Search\";
cout<<\"4) Display\";
cout<<\"5) Reverse\";
cout<<\"6) Exit \";
// reading user choice
cout<<\"Enter your userChoice : \";
cin>>userChoice;
switch(userChoice)
{
case 1:
cout<<\"Inserting node to linked list: \";
LinkList.insert_begin();
cout;
break;
case 2:
cout<<\"Delete element from linked list: \";
LinkList.delete();
break;
case 3:
cout<<\"Searching data in linked list: \";
LinkList.search();
cout;
break;
case 4:
cout<<\"Displaying linked list data: \";
LinkList.display();
cout;
break;
case 5:
cout<<\"Linked list reversing: \";
LinkList.reverse();
cout;
break;
case 6:
cout<<\"Exiting...\";
exit(1);
break;
default:
cout<<\"Enter correct userChoice\";
}
}
}
// node creating to store into list
node *LinkedList::create_node(int val)
{
struct node *tempNode, *tempNode;
tempNode = new(struct node);
if (tempNode == NULL)
{
cout<<\"No memory allocated \";
return 0;
}
else
{
tempNode->val = val;
tempNode->next = NULL;
return tempNode;
}
}
/*
* Inserting Node at last
*/
void LinkedList::insert_last()
{
int val;
cout<<\"Enter the val to be inserted: \";
cin>>val;
struct node *tempNode, *tempNode;
tempNode = create_node(val);
tempNode = startNode;
while (tempNode->next != NULL)
{
tempNode = tempNode->next;
}
tempNode->next = NULL;
tempNode->next = tempNode;
cout<<\"Element Inserted\";
}
// deleting element
void LinkedList::delete()
{
int position, i, count = 0;
if (startNode == NULL)
{
cout<<\"Linkedlist empty\"<>position;
struct node *tempNode, *ptr;
tempNode = startNode;
if (position == 1)
{
startNode = tempNode->next;
}
else
{
while (tempNode != NULL)
{
tempNode = tempNode->next;
count++;
}
if (position > 0 && position <= count)
{
tempNode = startNode;
for (i = 1;i < position;i++)
{
ptr = tempNode;
tempNode = tempNode->next;
}
ptr->next = tempNode->next;
}
else
{
cout<<\"Enter correct position\";
}
}
}
// search data in linked list
void LinkedList::search()
{
int val, position = 0;
bool flagValue = false;
if (startNode == NULL)
{
cout<<\"List is empty\";
return;
}
cout<<\"Enter the val to search: \";
cin>>val;
struct node *tempNode;
tempNode = startNode;
while (tempNode != NULL)
{
position++;
if (tempNode->val == val)
{
flagValue = true;
cout<<\"Data \"<next;
}
if (!flagValue)
cout<<\"data not found\";
}
// linkedlist reverese
void LinkedList::reverse()
{
struct node *pointer1, *pointer2, *pointer3;
if (startNode == NULL)
{
cout<<\"List is empty\"<next == NULL)
{
return;
}
pointer1 = startNode;
pointer2 = pointer1->next;
pointer3 = pointer2->next;
pointer1->next = NULL;
pointer2->.
LISTINGS.txt345678 116900 0 80513-2918 Metro Brokers432395.docx
LISTINGS.txt
345678 116900 0 80513-2918 Metro Brokers
432395 150743 1 80512-2771 City Realty
353455 342522 2 34534-3454 Upper East
999999 99999 2 92130-1312 This Test
555555 555555 0 77777-7777 Final Test
CHANGES.txt
432395 -25000
353455 -2500
221111 -1000
345678 +5000
HodellAssn#6.cpp
//*************************************************************************
#include <iostream>
#include <fstream>
#include <string>
#include <iomanip>
#include <cctype>
using namespace std;
// Global structure definition
enum availability { AVAILABLE, CONTRACT, SOLD };
struct propertiesRec
{
int mlsNum;
double price;
availability status;
string zipCode;
string realtor;
};
//FUNCTION PROTOTYPES SECTION -
//Previous Lab#4 functions with linked list mods
void IntroProgram ();
char MenuOne();
char UserMenuChoices ();
void Add_New_Listing ();
int Existing_Listings ();
int Get_Validate_MLS_Input ();
double Get_Validate_Price_Input ();
availability Get_Status_Entry();
string Status_Enum_Text ( int );
string Get_Validate_ZipCode_Input ();
string Get_Validate_Realtor_Input ();
int CountIntegers( int );
void Display_MLS_Numbers ();
bool Does_File_Exist(const char *fileName);
//Class Definition - New Lab#6 Functions
class node
{
propertiesRec Xdata;
node *next;
public:
//Default constructor used to initialize variable with values
node() { next=0; }
//Constructor with parameters
node ( propertiesRec varibable ) { Xdata = varibable; next = 0; }
void put_next ( node *n ) { next = n; }
node *Get_Next ( ) { return next; }
int Get_MLS ( ) { return Xdata.mlsNum; }
double Get_AskingPrice ( ) { return Xdata.price; }
int Get_ListingStatus ( ) { return Xdata.status; }
string Get_ZipCode() { return Xdata.zipCode; }
string Get_Realtor() { return Xdata.realtor; }
void SetAskingPrice( double );
void Append_List( propertiesRec );
void Remove_Node();
void DisplayListings();
void WriteToFile();
void ChangeAskingPrice();
//Declaring two nodes: header and 'n' initialized to 0.
} *header=0, *n=0;
//Input data constants
const int MAX_REALTY_NAME = 15;
const int MAX_ZIPCODE = 10;
const char Y_UPPERCASE = 'Y';
const char N_UPPERCASE = 'N';
const char ADD_LISTING = 'A';
const char REMOVE_LISTING = 'R';
const char DISPLAY_ALL = 'D';
const char CHANGE_ASKING_PRICE = 'C';
const char EXIT_PROGRAM = 'E';
//*************************************************************************
// FUNCTION: main
// DESCRIPTION: Main function will call various functions to read, input,
// calculate and display per account the phone usage totals
// CALLS TO:
// IntroProgram
//*************************************************************************
int main() {
// variables
int count;
char additional;
...
Implement of c & its coding programming by sarmad baloch
The C program implements a singly linked list with functions to insert and delete nodes, print the list, find a node by key, sort the list by data, and reverse the list. It demonstrates using the functions to create a list, delete all nodes, find and delete a node, sort the list, and reverse it, printing the list after each operation.
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 .
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 StructuresPlease I need help completing this c++ program..pdf
Data Structures
Please I need help completing this c++ program. it was giving to complete it with no other
discriptions.
#include
using namespace std;
template
struct node
{
datatype info;
node *left, *right;
};
template
class tree
{
public:
tree();
~tree();
bool isempty();
void inserttree(datatype data);
void print();
private:
node *root;
};
template
tree::tree()
{
root = NULL;
}
template
void tree ::inserttree(datatype data)
{
node *temp;
temp = new node ;
temp->left = NULL;
temp->right = NULL;
temp->info = data;
if (root == NULL)
root = temp;
else
before = NULL;
after = root;
while (after != NULL)
{
b = a;
root
...;
else
}
if(temp->info< before->info)
before->left = temp;
else
before->right = temp;
//before = after;
//if (temp->info < after->info)
//after = after->left;
//else
//after = after->right;
//if(temp->info< before->info)
//before->left = temp;
//else
//before->right = temp;
}
template
void tree ::print(tree *temp)
{
if (temp != NULL)
{
print(temp->left);
cout << temp->info << endl;
print(temp->right);
}
p();
print(root);
}
int main()
{
tree t;
//put this in a loop
t.inserttree(90);
t.inserttree(80);
t.inserttree(108);
t.p();
}
Solution
// HEADER FILE FOR BINARY TREE//
// Define a structure to be used as the tree node
struct TreeNode
{
int Key;
float fValue;
int iValue;
char cArray[7];
TreeNode *left;
TreeNode *right;
};
class Code202_Tree
{
private:
TreeNode *root;
public:
Code202_Tree();
~Code202_Tree();
bool isEmpty();
TreeNode *SearchTree(int Key);
bool Insert(TreeNode *newNode);
bool Insert(int Key, float f, int i, char *cA);
bool Delete(int Key);
void PrintOne(TreeNode *T);
void PrintTree();
private:
void ClearTree(TreeNode *T);
TreeNode *DupNode(TreeNode * T);
void PrintAll(TreeNode *T);
};
#endif
//IMPLEMENTATION .CPP FILE FOR BINARY TREE//
#include
#include
#include \"Code202_Tree.h\"
using namespace std;
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class constructor.
//--------------------------------------------
Code202_Tree::Code202_Tree()
{
root = NULL;
return;
}
//--------------------------------------------
// Function: Code202_Tree()
// Purpose: Class destructor.
//--------------------------------------------
Code202_Tree::~Code202_Tree()
{
ClearTree(root);
return;
}
//--------------------------------------------
// Function: ClearTree()
// Purpose: Perform a recursive traversal of
// a tree destroying all nodes.
//--------------------------------------------
void Code202_Tree::ClearTree(TreeNode *T)
{
if(T==NULL) return; // Nothing to clear
if(T->left != NULL) ClearTree(T->left); // Clear left sub-tree
if(T->right != NULL) ClearTree(T->right); // Clear right sub-tree
delete T; // Destroy this node
return;
}
//--------------------------------------------
// Function: isEmpty()
// Purpose: Return TRUE if tree is empty.
//--------------------------------------------
bool Code202_Tree::isEmpty()
{
return(root==NULL);
}
//--------------------------------------------
// Function.
File name a2.cppTaskFor this assignment, you are required to ei.pdf
File name: a2.cpp
Task
For this assignment, you are required to either A) modify your linked list code to implement a
queue or B) modify the provided stack code to implement a queue. Your program should
implement a C++ queue class with the following member functions:
- Void enq(int)
- Void deq()
- Void front()
- Bool isEmpty()
- Void printq()
Your program will take in a command file called “cmd.txt” which will instruct your program
what operations to run
File Format
<0 or 1 arguments>
Commands
- 1 enq
- 2 deq
- 3 front
- 4 isEmpty
- 5 printq
Example File
1 1
5
1 2
5
1 3
5
1 4
5
3
2
5
2
5
3
Expectations
You should not use any already pre implemented code for your queue such as a standard library
object
Your code should be well formatted with proper spacing and proper naming
Your code should have well named variables. No a’s b’s or c’s as names unless it is for
something like a loop counter
Your code should have the same output formatting you see below
Your code MUST follow the formatting you see below
Your file MUST be named a2.cpp
My example file does not contain all possible test cases it is up to you to determine any other
special cases to test your program against.
Example Output
//LinkedList class
#include
#include
#include
#include
#include
using namespace std;
struct Node
{
int data;
Node *next;
};
class LinkedList
{
private:
Node *head;
Node *tail;
public:
LinkedList(); //constructor
void prepend(int num);
void append(int num);
void removeFront();
void removeBack();
void remove(int num);
int search(int num);
void printList();
};
//constructor
LinkedList::LinkedList()
{
head=NULL;
tail=NULL;
}
//prepend() method
void LinkedList::prepend(int num)
{
//allocate space for new node
Node *node=new Node;
//populate node
node->data=num;
node->next= NULL;
//attach new node to start of list
//if linked list empty
if(head==NULL)
{
head=node;
tail=node;
}
else //linked list not empty
{
node->next=head;
head=node;
}
}
//append() method
void LinkedList::append(int num)
{
//allocate space for new node
Node *node=new Node;
//populate node
node->data=num;
node->next= NULL;
//attach new node to end of list
//if linked list empty
if(head==NULL)
{
head=node;
tail=node;
}
else //linked list not empty
{
tail->next=node;
tail=node;
}
}
//removeFront() method
void LinkedList::removeFront()
{
//if linked list empty, then underflow
if(head==NULL)
{
cerr<<\"Underflow\"<next;
//delete node
cout<<\"Removing \"<data<<\" from the list\"<next!=NULL)
{
/*if(curr==tail)
break;*/
prev=curr;
curr=curr->next;
}
prev->next=NULL;
tail=prev;
//delete node
cout<<\"Removing \"<data<<\" from the list\"<data=num)
break;
prev=curr;
curr=curr->next;
}
//preserve node
Node *temp=curr;
//detach node from linked list
prev->next=curr->next;
//delete node
cout<<\"Removing \"<data<<\" from the list\"<data=num)
{
found=1; //num found
break;
}
curr=curr->next;
}
return found;
}
//printList() method
void LinkedList::printList()
{
//traverse linked list
Node *curr=head;
while(curr!=NULL)
{
c.
solution in c++program Program to implement a queue using two .pdf
solution in c++
program
/* Program to implement a queue using two stacks */
#include
#include
using namespace std;
/* structure of a stack node */
struct sNode
{
int data;
struct sNode *next;
};
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data);
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref);
/* structure of queue having two stacks */
struct queue
{
struct sNode *stack1;
struct sNode *stack2;
};
/* Function to enqueue an item to queue */
void enQueue(struct queue *q, int x)
{
push(&q->stack1, x);
}
/* Function to dequeue an item from queue */
int deQueue(struct queue *q)
{
int x;
/* If both stacks are empty then error */
if(q->stack1 == NULL && q->stack2 == NULL)
{
printf(\"Q is empty\");
getchar();
exit(0);
}
/* Move elements from satck1 to stack 2 only if
stack2 is empty */
if(q->stack2 == NULL)
{
while(q->stack1 != NULL)
{
x = pop(&q->stack1);
push(&q->stack2, x);
}
}
x = pop(&q->stack2);
return x;
}
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data)
{
/* allocate node */
struct sNode* new_node =
(struct sNode*) malloc(sizeof(struct sNode));
if(new_node == NULL)
{
printf(\"Stack is empty \ \");
getchar();
exit(0);
}
else{
/* put in the data */
new_node->data = new_data;
/* link the old list off the new node */
new_node->next = (*top_ref);
/* move the head to point to the new node */
(*top_ref) = new_node;
}
}
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref)
{
int res;
struct sNode *top;
/*If stack is empty then error */
if(*top_ref == NULL)
{
printf(\"Stack overflow \ \");
getchar();
exit(0);
}
else
{
top = *top_ref;
res = top->data;
*top_ref = top->next;
free(top);
return res;
}
}
/* Driver function to test anove functions */
int main()
{
/* Create a queue with items 1 2 3*/
struct queue *q = (struct queue*)malloc(sizeof(struct queue));
q->stack1 = NULL;
q->stack2 = NULL;
for(int i=0;i<15;i++)
{
enQueue(q, i);
}
//enQueue(q, 2);
//enQueue(q, 3);
//enQueue(q,4);
/* Dequeue items */
printf(\"the dequeue items\");
for(int i=0;i<16;i++)
{
printf(\"%d \", deQueue(q));
//printf(\"%d \", deQueue(q));
}
getchar();
}
output
the dequeue items
0 1 2 3 4 5 6 7 8 9 10 11 12 13 14
q is empty
Solution
solution in c++
program
/* Program to implement a queue using two stacks */
#include
#include
using namespace std;
/* structure of a stack node */
struct sNode
{
int data;
struct sNode *next;
};
/* Function to push an item to stack*/
void push(struct sNode** top_ref, int new_data);
/* Function to pop an item from stack*/
int pop(struct sNode** top_ref);
/* structure of queue having two stacks */
struct queue
{
struct sNode *stack1;
struct sNode *stack2;
};
/* Function to enqueue an item to queue */
void enQueue(struct queue *q, int x)
{
push(&q->stack1, x);
}
/* Function to dequeue an item from queue */
int deQueue(struct queue *q)
{
int x;
/* If both stacks are empty then error */
if(q->stack1 == NULL && q->stack2 == NULL)
{
printf(\"Q .
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.
Similar to Implement a priority queue using a doublyLinked-cpp where the node wit.pdf (20)
Program 8 C++newproblems.txt12333142013KristinBrewer1032823.docx
Program 8 C++newproblems.txt12333142013KristinBrewer1032823.docx
Using C++I keep getting messagehead does not name a type.pdf
Using C++I keep getting messagehead does not name a type.pdf
I need help with implementing the priority queue data structure with a.docx
I need help with implementing the priority queue data structure with a.docx
Shapes and calculate (area and contour) / C++ oop concept
Shapes and calculate (area and contour) / C++ oop concept
Shapes and calculate (area and contour) / C++ oop concept
Shapes and calculate (area and contour) / C++ oop concept
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
Create a link list. Add some nodes to it, search and delete nodes fro.pdf
How do you stop infinite loop Because I believe that it is making a.pdf
How do you stop infinite loop Because I believe that it is making a.pdf
#includeiostream #includecstdio #includecstdlib using na.pdf
#includeiostream #includecstdio #includecstdlib using na.pdf
LISTINGS.txt345678 116900 0 80513-2918 Metro Brokers432395.docx
LISTINGS.txt345678 116900 0 80513-2918 Metro Brokers432395.docx
Implement of c & its coding programming by sarmad baloch
Implement of c & its coding programming by sarmad baloch
Program to insert in a sorted list #includestdio.h#include.pdf
Program to insert in a sorted list #includestdio.h#include.pdf
Data StructuresPlease I need help completing this c++ program..pdf
Data StructuresPlease I need help completing this c++ program..pdf
File name a2.cppTaskFor this assignment, you are required to ei.pdf
File name a2.cppTaskFor this assignment, you are required to ei.pdf
solution in c++program Program to implement a queue using two .pdf
solution in c++program Program to implement a queue using two .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
More from BlakeY8lBucklandh
IN KOTLIN PLZ Define a public class named Stepper with a single instan.pdf
IN KOTLIN PLZ
Define a public class named Stepper with a single instance method named next that takes no
parameters and returns an Int. Called multiple times, next returns a sequence of values separated
by a step amount provided to the primary constructor. Stepper should also provide a primary
constructor that accepts a Int argument and sets the step amount. Stepper maintains two pieces of
private state: the step amount, and the current value, which always starts at 0 . The step amount
is passed to the constructor, and should be part of your primary constructor declaration. But the
current value should be declared separately. Calling next increments the current value by the step
amount, but returns the previous value. So, for example: Note that the internal state should be
private..
In less than two pages- I want you to examine the pattern of human pop.pdf
In less than two pages, I want you to examine the pattern of human population over the
past 10,000 years and describe the factors that influenced it: become familiar with the work
of Thomas Robert Malthus in the area of population growth and briefly describe its
relevance to human populations and development. describe the demographic transition and
summarize the stages of the demographic transition model finally, explain any limitations
of you see in this model..
in HTML 2- Write an html file that has two images side by side- The i.pdf
in HTML
2. Write an html file that has two images side by side. The images are two hyperlinks to your
favorite sites. Notice the blue border around the images. Images as Links - Mozilla Firefox Ele
Edit View History Bookmarks Iools Help file:///C:/Documents and sett Most Visited Getting
started A Latest Headines Images as Links My Favorite Links.
In Germany the corporate board is--- A-Legally charged with representi.pdf
In Germany the corporate board is...
A.Legally charged with representing the interests of shareholders exclusively.
B.Legally charged with looking after the interests of stakeholders (e.g., workers, creditors, etc.)in
general, not just shareholders.
C.Legally charged as a supervisory board only.
D.Legally charged as a management board only..
In Excel- you are allowed to put other functions inside an -F( ) state.pdf
In Excel, you are allowed to put other functions inside an = F ( ) statement, but you cannot place
an IF statement inside another IF statement. True False.
In examining those two profiles from Mount Saint Helens- which one has.pdf
In examining those two profiles from Mount Saint Helens, which one has a more disturbed (by
the eruption) and variable profile? In other words, which one has more variability in topography
(elevation goes up and down a lot more)?
A.) North
B.) South
C.) They both have very similar profiles.
In December 1991- the United Nations (UN) warned that wheat would be s.pdf
In December 1991, the United Nations (UN) warned that wheat would be scarce in the coming
year, but the futures price of wheat at the time was inconsistent with a wheat shortage. It turned
out that: the UN retracted its warning when the futures price of wheat began to rise. the futures
price of wheat quickly adjusted to reflect the wisdom of the UN's warning. a devastating famine
wiped out much of the world's wheat crop in 1992. wheat was not particularly scarce in 1992..
In carrying out their engagements- which financial advisor would NOT b.pdf
In carrying out their engagements, which financial advisor would NOT be subject to the Preparer
penaity? a) George, who is preparing a tax return for Mario b) Sandra, who is providing tax
advice to Frank c) Allan, who is providing financial planning advice to Joan d) Margo, who is
preparing an appraisal report to be filed with the income tax returns of the partners in Sleepy
Hollow Golf Course.
In astronomy- it is important to look for trends in your data- Based o.pdf
In astronomy, it is important to look for trends in your data. Based on the average latitude and
rotation period of each sunspot, what is the trend for rotation period as it relates to latitude?
Sunspots have a shorter rotation period near the equator (at low latitudes), and a longer rotation
period near the poles (at high latitudes). Sunspots have a longer rotation period near the equator
(at low latitudes), and a shorter rotation period near the poles (at high latitudes). There is no
correlation between latitude and rotation rate for sunspots; they are all random. There is no
correlation between latitude and rotation rate for sunspots; they are all the same. QUESTION 31
In astronomy, it is important to look for trends in your data. Based on the average latitudes and
rotation rate of each sunspot, what is the trend for rotation rate as it relates to latitude? Sunspots
rotate faster near the equator (at low latitudes) , and slower near the poles (at high latitudes).
Sunspots rotate slower near the equator (at low latitudes), and faster near the poles (at high
latitudes). There is no correlation between rotation rate and latitude; they are all random. There is
no correlation between rotation rate and latitude; they are all the same..
In a horizontal structure- __________ deal directly with the organizat.pdf
In a horizontal structure, __________ deal directly with the organization's primary goods or
services; they make things, sell things, or provide customer service.
Multiple Choice
public relation divisions
accounting divisions
staff departments
organic structures
line departments.
In a certain residential area 50- of the residents subscribe to the mo.pdf
In a certain residential area 50% of the residents subscribe to the morning newspapers, 65\%
subscribe to afternoon newspapers, and 85% subscribe to at least one of the two newspapers.
What percentage of the residents subscribe to both newspapers..
In a binary tree class- implement a Python method _find(p- _Node- key-.pdf
In a binary tree class, implement a Python method _find(p: _Node, key: int), that takes in a key
and a reference to a node p, where p represents the root of a binary tree, the function should
search the binary tree for key, and returns T/F accordingly. What is the time complexity of your
function?.
Implementing a Singly Linked List The purpose of the lab is to help gi.pdf
Implementing a Singly Linked List
The purpose of the lab is to help give you a conceptual understanding of how a singly linked list
works by actually implementing one in Java.
The following files are included in this lab:
L9
MyLinkedList.java (The file you will modify.)
MiniList.java (The interface you will implement.)
LLTest.java (*The read-only, main in zyLabs.).
Implement the following classes in the UML- 1- Iist class includes- co.pdf
Implement the following classes in the UML: 1. Iist class includes: constructor Iist (] ) Create an
empty list with a maximum length of 100 . Hint: double [] 1 ist = new double [ 100 ] ;
constructor Zist (lent int) : Create a List with a user specified maximum length. Hint: double []
1ist: new double [1en]; add: add a new element to the end of the unsorted list. print: display the
list 2. Sortedriat class inciudes two constructors : similar to the constructors in Uist, add: add a
new element into the ascending sorted list. 3. FeatProgram: main method creates a genera list
(unsorted) and a sorted list with random numbers using add methods; display the unsorted and
sorted lists. List -list: double [] -length: int + List() + List(len: int) + add(ele: double) : void +
getlist(): double[] + getlength(): int + setLength(int len): void + setList(double[] list):void +
print(): void + Sortedlist() + SortedList(len: int) + main(args: String [1): void tadd(ele: double) :
void.
In 2017 Marcus Hutchins (Malware Tech Blog) was arrested as he was att.pdf
In 2017 Marcus Hutchins (Malware Tech Blog) was arrested as he was attempting to leave the
Defcon security conference. He is being charged with being the author of malware as a teenager.
Please research this case, summarize, and give your opinion on how people who may have done
bad as teenagers but ultimately turned around should be handled.
In 2012- Facebook Inc- filed with the SEC a registration statement und.pdf
In 2012, Facebook Inc. filed with the SEC a registration statement under the Securities Act of
1933, pursuant to which Facebook would make a public offering of securities. During the
waiting period prior to the effective date of the registration statement, Facebook determined
that, at least in the short term, it was not able to monetize its mobile application as quickly and
as well as it had monetized its desktop application. That was an important discovery because
Facebook users were rapidly moving to exclusive or primary use of mobile applications,
especially on smartphones. What did Facebook do with the new information to ensure it
complied with Section 11 of the 1933 Act?.
Ildentity the tollowing fuctors affecting kpecies distribution that ar.pdf
Ildentity the tollowing fuctors affecting kpecies distribution that are biotic foctors Select al that
apbly Piediton firmperiatore Disease Suright comperition Levation Water avilabiazy Question 31
2 pts Which of the following are TAUE stotements regarding populstions? They inchude
indiduas that can interact and breed in a designated ares They incliade ongstioms of a spectic
species They are affected by both abistic ard biatic tactors They are sffected by only biotic
factors They involve mutiole groups of aitferent species Question 32 2 22 squirrels, 8 deer, 12
rabbits, and 1 skunk can be found in a 5 acre city park. Which populatic hes the highest density?
Rabibit shink Souinel Deer.
If X is normally distributed with a mean of 10 and a standard deviatio (1).pdf
If X is normally distributed with a mean of 10 and a standard deviation of 6 , find P ( 10 X 16 ) .
a) 0.841 b) 0.341 c) 0.441 d) 0.641 e) 0.541 f) None of the above.
If ZN(0-1)- compute P(Z2-3)-.pdf
To find P(Z^2 < 3) where Z ~ N(0, 1), we first recognize that Z^2 follows a chi-squared distribution with 1 degree of freedom. Then looking up the chi-squared distribution, we find that P(Z^2 < 3) is approximately 0.9545.
illings is exceeding the design specification- Use Table 11-1- interpr.pdf
illings is exceeding the design specification. Use Table 11.1 . interpret: The population variance
appears to be exceeding the standard..
More from BlakeY8lBucklandh (20)
IN KOTLIN PLZ Define a public class named Stepper with a single instan.pdf
IN KOTLIN PLZ Define a public class named Stepper with a single instan.pdf
In less than two pages- I want you to examine the pattern of human pop.pdf
In less than two pages- I want you to examine the pattern of human pop.pdf
in HTML 2- Write an html file that has two images side by side- The i.pdf
in HTML 2- Write an html file that has two images side by side- The i.pdf
In Germany the corporate board is--- A-Legally charged with representi.pdf
In Germany the corporate board is--- A-Legally charged with representi.pdf
In Excel- you are allowed to put other functions inside an -F( ) state.pdf
In Excel- you are allowed to put other functions inside an -F( ) state.pdf
In examining those two profiles from Mount Saint Helens- which one has.pdf
In examining those two profiles from Mount Saint Helens- which one has.pdf
In December 1991- the United Nations (UN) warned that wheat would be s.pdf
In December 1991- the United Nations (UN) warned that wheat would be s.pdf
In carrying out their engagements- which financial advisor would NOT b.pdf
In carrying out their engagements- which financial advisor would NOT b.pdf
In astronomy- it is important to look for trends in your data- Based o.pdf
In astronomy- it is important to look for trends in your data- Based o.pdf
In a horizontal structure- __________ deal directly with the organizat.pdf
In a horizontal structure- __________ deal directly with the organizat.pdf
In a certain residential area 50- of the residents subscribe to the mo.pdf
In a certain residential area 50- of the residents subscribe to the mo.pdf
In a binary tree class- implement a Python method _find(p- _Node- key-.pdf
In a binary tree class- implement a Python method _find(p- _Node- key-.pdf
Implementing a Singly Linked List The purpose of the lab is to help gi.pdf
Implementing a Singly Linked List The purpose of the lab is to help gi.pdf
Implement the following classes in the UML- 1- Iist class includes- co.pdf
Implement the following classes in the UML- 1- Iist class includes- co.pdf
In 2017 Marcus Hutchins (Malware Tech Blog) was arrested as he was att.pdf
In 2017 Marcus Hutchins (Malware Tech Blog) was arrested as he was att.pdf
In 2012- Facebook Inc- filed with the SEC a registration statement und.pdf
In 2012- Facebook Inc- filed with the SEC a registration statement und.pdf
Ildentity the tollowing fuctors affecting kpecies distribution that ar.pdf
Ildentity the tollowing fuctors affecting kpecies distribution that ar.pdf
If X is normally distributed with a mean of 10 and a standard deviatio (1).pdf
If X is normally distributed with a mean of 10 and a standard deviatio (1).pdf
illings is exceeding the design specification- Use Table 11-1- interpr.pdf
illings is exceeding the design specification- Use Table 11-1- interpr.pdf
Recently uploaded
DRUGS AND ITS classification slide share
Any substance (other than food) that is used to prevent, diagnose, treat, or relieve symptoms of a
disease or abnormal condition
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...National Information Standards Organization (NISO)
This presentation was provided by Steph Pollock of The American Psychological Association’s Journals Program, and Damita Snow, of The American Society of Civil Engineers (ASCE), for the initial session of NISO's 2024 Training Series "DEIA in the Scholarly Landscape." Session One: 'Setting Expectations: a DEIA Primer,' was held June 6, 2024.ANATOMY AND BIOMECHANICS OF HIP JOINT.pdf
it describes the bony anatomy including the femoral head , acetabulum, labrum . also discusses the capsule , ligaments . muscle that act on the hip joint and the range of motion are outlined. factors affecting hip joint stability and weight transmission through the joint are summarized.
Introduction to AI for Nonprofits with Tapp Network
Dive into the world of AI! Experts Jon Hill and Tareq Monaur will guide you through AI's role in enhancing nonprofit websites and basic marketing strategies, making it easy to understand and apply.
Hindi varnamala | hindi alphabet PPT.pdf
हिंदी वर्णमाला पीपीटी, hindi alphabet PPT presentation, hindi varnamala PPT, Hindi Varnamala pdf, हिंदी स्वर, हिंदी व्यंजन, sikhiye hindi varnmala, dr. mulla adam ali, hindi language and literature, hindi alphabet with drawing, hindi alphabet pdf, hindi varnamala for childrens, hindi language, hindi varnamala practice for kids, https://www.drmullaadamali.com
Assessment and Planning in Educational technology.pptx
In an education system, it is understood that assessment is only for the students, but on the other hand, the Assessment of teachers is also an important aspect of the education system that ensures teachers are providing high-quality instruction to students. The assessment process can be used to provide feedback and support for professional development, to inform decisions about teacher retention or promotion, or to evaluate teacher effectiveness for accountability purposes.
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...
Denis is a dynamic and results-driven Chief Information Officer (CIO) with a distinguished career spanning information systems analysis and technical project management. With a proven track record of spearheading the design and delivery of cutting-edge Information Management solutions, he has consistently elevated business operations, streamlined reporting functions, and maximized process efficiency.
Certified as an ISO/IEC 27001: Information Security Management Systems (ISMS) Lead Implementer, Data Protection Officer, and Cyber Risks Analyst, Denis brings a heightened focus on data security, privacy, and cyber resilience to every endeavor.
His expertise extends across a diverse spectrum of reporting, database, and web development applications, underpinned by an exceptional grasp of data storage and virtualization technologies. His proficiency in application testing, database administration, and data cleansing ensures seamless execution of complex projects.
What sets Denis apart is his comprehensive understanding of Business and Systems Analysis technologies, honed through involvement in all phases of the Software Development Lifecycle (SDLC). From meticulous requirements gathering to precise analysis, innovative design, rigorous development, thorough testing, and successful implementation, he has consistently delivered exceptional results.
Throughout his career, he has taken on multifaceted roles, from leading technical project management teams to owning solutions that drive operational excellence. His conscientious and proactive approach is unwavering, whether he is working independently or collaboratively within a team. His ability to connect with colleagues on a personal level underscores his commitment to fostering a harmonious and productive workplace environment.
Date: May 29, 2024
Tags: Information Security, ISO/IEC 27001, ISO/IEC 42001, Artificial Intelligence, GDPR
-------------------------------------------------------------------------------
Find out more about ISO training and certification services
Training: ISO/IEC 27001 Information Security Management System - EN | PECB
ISO/IEC 42001 Artificial Intelligence Management System - EN | PECB
General Data Protection Regulation (GDPR) - Training Courses - EN | PECB
Webinars: https://pecb.com/webinars
Article: https://pecb.com/article
-------------------------------------------------------------------------------
For more information about PECB:
Website: https://pecb.com/
LinkedIn: https://www.linkedin.com/company/pecb/
Facebook: https://www.facebook.com/PECBInternational/
Slideshare: http://www.slideshare.net/PECBCERTIFICATION
Top five deadliest dog breeds in America
Thinking of getting a dog? Be aware that breeds like Pit Bulls, Rottweilers, and German Shepherds can be loyal and dangerous. Proper training and socialization are crucial to preventing aggressive behaviors. Ensure safety by understanding their needs and always supervising interactions. Stay safe, and enjoy your furry friends!
How to Add Chatter in the odoo 17 ERP Module
In Odoo, the chatter is like a chat tool that helps you work together on records. You can leave notes and track things, making it easier to talk with your team and partners. Inside chatter, all communication history, activity, and changes will be displayed.
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)Academy of Science of South Africa
A workshop hosted by the South African Journal of Science aimed at postgraduate students and early career researchers with little or no experience in writing and publishing journal articles.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.
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...Nguyen Thanh Tu Collection
https://app.box.com/s/y977uz6bpd3af4qsebv7r9b7s21935vdRecently uploaded (20)
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Pollock and Snow "DEIA in the Scholarly Landscape, Session One: Setting Expec...
Digital Artefact 1 - Tiny Home Environmental Design
Digital Artefact 1 - Tiny Home Environmental Design
Introduction to AI for Nonprofits with Tapp Network
Introduction to AI for Nonprofits with Tapp Network
Assessment and Planning in Educational technology.pptx
Assessment and Planning in Educational technology.pptx
Liberal Approach to the Study of Indian Politics.pdf
Liberal Approach to the Study of Indian Politics.pdf
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...
ISO/IEC 27001, ISO/IEC 42001, and GDPR: Best Practices for Implementation and...
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...
BÀI TẬP BỔ TRỢ TIẾNG ANH 8 CẢ NĂM - GLOBAL SUCCESS - NĂM HỌC 2023-2024 (CÓ FI...
Implement a priority queue using a doublyLinked-cpp where the node wit.pdf
- 1. Implement a priority queue using a doublyLinked.cpp where the node with the highest priority (key) is the right-most node. The remove (de-queue) operation returns the node with the highest priority (key). If displayForward() displays List (first-->last) : 10 30 40 55 remove() would return the node with key 55. please only code in c++ not anything else. keep it simple and thank you!! Demonstrate by inserting keys at random, displayForward(), call remove then displayForward() again. int main() { DoublyLinkedList pqList; pqList.priorityInsert(50); pqList.priorityInsert(40); pqList.priorityInsert(30); pqList.priorityInsert(20); pqList.priorityInsert(10); cout<<"-------------- PriorityQueue -------------"<<endl; pqList.displayForward(); cout<<"calling priorityRemove()"<<endl; double key = pqList.priorityRemove(); cout<<"Removed node with key "<<key<<endl; pqList.displayForward(); key = pqList.priorityRemove(); cout<<"Removed node with key "<<key<<endl; pqList.displayForward(); return 0; } Sample output" -------------- PriorityQueue ------------- List (first-->last): 10 20 30 40 50 calling priorityRemove() Removed node with key 50 List (first-->last): 10 20 30 40 Removed node with key 40 List (first-->last): 10 20 30 I may change numbers when grading. doublyLinked.cpp //doublyLinked.cpp //demonstrates doubly-linked list #include <iostream>
- 2. using namespace std; //////////////////////////////////////////////////////////////// class Link { public: double dData; //data item Link * pNext; //next link in list Link * pPrevious; //previous link in list public: //------------------------------------------------------------- Link(double dd): //constructor dData(dd), pNext(NULL), pPrevious(NULL) {} //------------------------------------------------------------- void displayLink() //display this link { cout << dData << " "; } //------------------------------------------------------------- }; //end class Link //////////////////////////////////////////////////////////////// class DoublyLinkedList { private: Link * pFirst; //pointer to first item Link * pLast; //pointer to last item public: //------------------------------------------------------------- DoublyLinkedList(): //constructor pFirst(NULL), pLast(NULL) {} //------------------------------------------------------------- ~DoublyLinkedList() //destructor (deletes links) { Link * pCurrent = pFirst; //start at beginning of list while (pCurrent != NULL) //until end of list, { Link * pOldCur = pCurrent; //save current link pCurrent = pCurrent -> pNext; //move to next link delete pOldCur; //delete old current } } //------------------------------------------------------------- bool isEmpty() //true if no links { return pFirst == NULL;
- 3. } //------------------------------------------------------------- void insertFirst(double dd) //insert at front of list { Link * pNewLink = new Link(dd); //make new link if (isEmpty()) //if empty list, pLast = pNewLink; //newLink <-- last else pFirst -> pPrevious = pNewLink; //newLink <-- old first pNewLink -> pNext = pFirst; //newLink --> old first pFirst = pNewLink; //first --> newLink } //------------------------------------------------------------- void insertLast(double dd) //insert at end of list { Link * pNewLink = new Link(dd); //make new link if (isEmpty()) //if empty list, pFirst = pNewLink; //first --> newLink else { pLast -> pNext = pNewLink; //old last --> newLink pNewLink -> pPrevious = pLast; //old last <-- newLink } pLast = pNewLink; //newLink <-- last } //------------------------------------------------------------- void removeFirst() //remove first link { //(assumes non-empty list) Link * pTemp = pFirst; if (pFirst -> pNext == NULL) //if only one item pLast = NULL; //null <-- last else pFirst -> pNext -> pPrevious = NULL; //null <-- old next pFirst = pFirst -> pNext; //first --> old next delete pTemp; //delete old first } //-------------------------------------------------------------
- 4. void removeLast() //remove last link { //(assumes non-empty list) Link * pTemp = pLast; if (pFirst -> pNext == NULL) //if only one item pFirst = NULL; //first --> null else pLast -> pPrevious -> pNext = NULL; //old previous --> null pLast = pLast -> pPrevious; //old previous <-- last delete pTemp; //delete old last } //------------------------------------------------------------- //insert dd just after key bool insertAfter(double key, double dd) { //(assumes non-empty list) Link * pCurrent = pFirst; //start at beginning while (pCurrent -> dData != key) //until match is found, { pCurrent = pCurrent -> pNext; //move to next link if (pCurrent == NULL) return false; //didnt find it } Link * pNewLink = new Link(dd); //make new link if (pCurrent == pLast) //if last link, { pNewLink -> pNext = NULL; //newLink --> null pLast = pNewLink; //newLink <-- last } else //not last link, { //newLink --> old next pNewLink -> pNext = pCurrent -> pNext; //newLink <-- old next pCurrent -> pNext -> pPrevious = pNewLink; } pNewLink -> pPrevious = pCurrent; //old current <-- newLink pCurrent -> pNext = pNewLink; //old current --> newLink return true; //found it, did insertion } //------------------------------------------------------------- bool removeKey(double key) //remove item w/ given key { //(assumes non-empty list)
- 5. Link * pCurrent = pFirst; //start at beginning while (pCurrent -> dData != key) //until match is found, { pCurrent = pCurrent -> pNext; //move to next link if (pCurrent == NULL) return false; //didnt find it } if (pCurrent == pFirst) //found it; first item? pFirst = pCurrent -> pNext; //first --> old next else //not first //old previous --> old next pCurrent -> pPrevious -> pNext = pCurrent -> pNext; if (pCurrent == pLast) //last item? pLast = pCurrent -> pPrevious; //old previous <-- last else //not last //old previous <-- old next pCurrent -> pNext -> pPrevious = pCurrent -> pPrevious; delete pCurrent; //delete item return true; //successful deletion } //------------------------------------------------------------- void displayForward() { cout << "List (first-->last): "; Link * pCurrent = pFirst; //start at beginning while (pCurrent != NULL) //until end of list, { pCurrent -> displayLink(); //display data pCurrent = pCurrent -> pNext; //move to next link } cout << endl; } //------------------------------------------------------------- void displayBackward() { cout << "List (last-->first): "; Link * pCurrent = pLast; //start at end while (pCurrent != NULL) //until start of list, { pCurrent -> displayLink(); //display data pCurrent = pCurrent -> pPrevious; //go to previous link
- 6. } cout << endl; } //------------------------------------------------------------- }; //end class DoublyLinkedList //////////////////////////////////////////////////////////////// int main() { DoublyLinkedList theList; //make a new list theList.insertFirst(22); //insert at front theList.insertFirst(44); theList.insertFirst(66); theList.insertLast(11); //insert at rear theList.insertLast(33); theList.insertLast(55); theList.displayForward(); //display list forward theList.displayBackward(); //display list backward cout << "Deleting first, last, and 11" << endl; theList.removeFirst(); //remove first item theList.removeLast(); //remove last item theList.removeKey(11); //remove item with key 11 theList.displayForward(); //display list forward cout << "Inserting 77 after 22, and 88 after 33" << endl; theList.insertAfter(22, 77); //insert 77 after 22 theList.insertAfter(33, 88); //insert 88 after 33 theList.displayForward(); //display list forward return 0; } //end main() Program 5 to test the code and call it. #include "doublyLinked2.cpp" #include <iostream> using namespace std; int main() { DoublyLinkedList pqList;
- 7. pqList.priorityInsert(50); pqList.displayForward(); pqList.priorityInsert(80); pqList.displayForward(); pqList.priorityInsert(40); pqList.displayForward(); pqList.priorityInsert(30); pqList.priorityInsert(20); pqList.priorityInsert(10); pqList.priorityInsert(70); pqList.priorityInsert(24); cout<<"-------------- PriorityQueue -------------"<<endl; pqList.displayForward(); cout<<"ncalling priorityRemove()"<<endl; double key = pqList.priorityRemove(); cout<<"Removed node with key "<<key<<endl; pqList.displayForward(); key = pqList.priorityRemove(); cout<<"Removed node with key "<<key<<endl; pqList.displayForward(); cout<<"Display backward:"<<endl; pqList.displayBackward(); return 0; }