1. Create the binary tree with 9 nodes (Figure 1) by using pointer-b.pdf
•
0 likes•6 views
1. Create the binary tree with 9 nodes (Figure 1) by using pointer-based representation. struct TreeNode { int info; TreeNode * left; TreeNode * right; } 2. Implement pre-order, in-order, and post-order traversals, and print the results of the tree The pre-order transversal looks like this: 2 7 2 6 5 11 5 9 4 The in-order transversal looks like this: 2 7 5 6 11 2 5 4 9 The post-order transversal looks like this: 2 5 11 6 7 4 9 5 2 Solution Here is the code for you: #include #include #include typedef struct node { int info; struct node *left; struct node *right; } node; void insert(node **,int); void preorder(node *); void postorder(node *); void inorder(node *); int main() { node *root; int ch,ele; root=NULL; while(1) { printf(\"TREE OPERATIONS\ \"); printf(\"1.INSERT\ \"); printf(\"2.INORDER\ \"); printf(\"3.PREORDER\ \"); printf(\"4.POSTORDER\ \"); printf(\"5.EXIT\ \"); printf(\"Enter your choice: \"); scanf(\"%d\",&ch); switch(ch) { case 1: printf(\"Enter the element you want to insert: \"); scanf(\"%d\",&ele); insert(&root,ele); break; case 2: inorder(root); break; case 3: preorder(root); break; case 4: postorder(root); break; case 5: exit(0); default: printf(\"Invalid Choice. Please enter a valid choice.\ \"); } } } void insert(node **root, int ele) { node *temp,*x,*y; x=y=*root; temp= (node *)malloc(sizeof(node)); temp->info=ele; temp->left = temp->right = NULL; while(x!=NULL) { y=x; if(ele < x->info) x = x->left; else x = x->right; } if(y == NULL) *root=temp; else if(ele < y->info) y->left = temp; else y->right = temp; } void inorder(node *root) { if(root != NULL) { inorder(root->left); printf(\"%d \",root->info); inorder(root->right); } } void preorder(node *root) { if(root != NULL) { printf(\"%d \",root->info); inorder(root->left); inorder(root->right); } } void postorder(node *root) { if(root != NULL) { inorder(root->left); inorder(root->right); printf(\"%d \",root->info); } }.
Report
Share
Report
Share
Download to read offline
Recommended
Write a function in C++ to generate an N-node random binary search t.pdf
Write a function in C++ to generate an N-node random binary search tree with distinct keys 1
through N.
Assume that you have available a function, randInt(lower,upper), that generates a uniform
random integer in the appropriate closed interval.
What is the running time of your routine?
Solution
/ A C++ prgroam to contrcut all unique BSTs for keys from 1 to n
#include
#include
using namespace std;
// node structure
struct node
{
int key;
struct node *left, *right;
};
// A utility function to create a new BST node
struct node *newNode(int item)
{
struct node *temp = new node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to do preorder traversal of BST
void preorder(struct node *root)
{
if (root != NULL)
{
cout << root->key << \" \";
preorder(root->left);
preorder(root->right);
}
}
// function for constructing trees
vector constructTrees(int start, int end)
{
vector list;
/* if start > end then subtree will be empty so returning NULL
in the list */
if (start > end)
{
list.push_back(NULL);
return list;
}
/* iterating through all values from start to end for constructing\\
left and right subtree recursively */
for (int i = start; i <= end; i++)
{
/* constructing left subtree */
vector leftSubtree = constructTrees(start, i - 1);
/* constructing right subtree */
vector rightSubtree = constructTrees(i + 1, end);
/* now looping through all left and right subtrees and connecting
them to ith root below */
for (int j = 0; j < leftSubtree.size(); j++)
{
struct node* left = leftSubtree[j];
for (int k = 0; k < rightSubtree.size(); k++)
{
struct node * right = rightSubtree[k];
struct node * node = newNode(i);// making value i as root
node->left = left; // connect left subtree
node->right = right; // connect right subtree
list.push_back(node); // add this tree to list
}
}
}
return list;
}
// Driver Program to test above functions
int main()
{
// Construct all possible BSTs
vector totalTreesFrom1toN = constructTrees(1, 3);
/* Printing preorder traversal of all constructed BSTs */
cout << \"Preorder traversals of all constructed BSTs are \ \";
for (int i = 0; i < totalTreesFrom1toN.size(); i++)
{
preorder(totalTreesFrom1toN[i]);
cout << endl;
}
return 0;
}
Output:.
DATASTRUCTURES PPTS PREPARED BY M V BRAHMANANDA REDDY
This document discusses binary search trees and provides source code to implement binary search tree traversal operations. It explains that a binary search tree is a binary tree where the left child of a node is less than the parent and the right child is greater. It provides code for preorder, inorder, and postorder traversals of the binary search tree and outputs the traversal order for a sample tree.
Lab-2.4 101.pdf
The document contains C program code to implement three data structures using linked lists:
1) A stack using a singly linked list with push, pop, and display functions.
2) A queue using a singly linked list with enqueue, dequeue, and display functions.
3) A program to merge two sorted linked lists by comparing nodes and appending to the merged list.
Pseudocode and sample test cases are provided for each problem.
include ltiostreamgt include ltfstreamgt in.pdf
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
using namespace std;
/* A binary tree node has data,pointer to left child and apointer to right child */
struct Node
{
int data;
Node* left, * right;
};
/*Function for creating a new Node structure */
Node* newNode(int data)
{
Node* node = new Node;
//Node* node = (Node*)malloc(sizeof(Node)); //will also work.
node->data = data;
node->left = node->right = NULL;
return (node);
}
// Function to insert nodes in level order. This function takes an array-based treerepresentation as
inputand
// convert it into a linked list-based tree representationNode* insertLevelOrder(vector<int>
tree_vec,
//tree_vec: array implementation,
create node for position i.
int i, int n)
{
Node* root = nullptr;
// Base case for recursion
if (i < n)
{
root = newNode(tree_vec[i]);
// insert left child
root->left = insertLevelOrder(tree_vec,
2 * i + 1, n);
// insert right child
root->right = insertLevelOrder(tree_vec,
2 * i + 2, n);
}
return root;
}
// Example code for InOrder traversal
void inOrder(Node * root)
{
if (root != NULL)
{
inOrder(root->left);
cout << root->data << " ";
inOrder(root->right);
}
}
int main()
{
vector<int> tree_vec;
string file_name;
int temp_data;
cout << "Please input the file name of a complete binary tree:";
cin >> file_name;
ifstream tree_file(file_name, ios::in);
if (tree_file.fail())
{
cout << "Fail to open the tree file.";
return 0;
}
while (!tree_file.fail() && !tree_file.eof())
{
tree_file >> temp_data;
tree_vec.push_back(temp_data);
}
/*Transform the array-based tree into linked-list in level-order.*/
Node* root = insertLevelOrder(tree_vec, 0, tree_vec.size());
/*Task 1, to be implemented*/
cout << "The Preorder Traversal result is: " << endl;
/*Example implementation*/
cout << "The Inorder Traversal result is: " << endl;
inOrder(root);
/*Task 2, to be implemented*/
cout << "The Postorder Traversal result is: " << endl;
/*Task 3, to be implemented*/
cout << "The number of leaf nodes is: " << endl;
return 0;
}
please help me to finish the code with the task using c++
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
using namespace std;
/* A binary tree node has data,pointer to left child and apointer to right child */
struct Node
{
int data;
Node* left, * right;
};
/*Function for creating a new Node structure */
Node* newNode(int data)
{
Node* node = new Node;
//Node* node = (Node*)malloc(sizeof(Node)); //will also work.
node->data = data;
node->left = node->right = NULL;
return (node);
}
// Function to insert nodes in level order. This function takes an array-based treerepresentation as
inputand
// convert it into a linked list-based tree representationNode* insertLevelOrder(vector<int>
tree_vec,
//tree_vec: array implementation,
create node for position i.
int i, int n)
{
Node* root = nullptr;
// Base case for recursion
if (i < n)
{
root = newNode(tree_vec[i]);
// insert left child
root->left = inse.
Please write in C++ and should be able to compile and debug.Thank yo.pdf
Please write in C++ and should be able to compile and debug.Thank you
Create a class called BinaryTreeDeque. This binary tree implements all of the functionality of
the BinaryTree class, but instead of storing its values in a tree structure, the element values are
stored in a deque, using pointers to maintain the relationship between the binary tree and its node
values. Additionally: deque * getValues() - returns a copy of the deque the current array of
values (which should be in insertion order).
Solution
Following are steps to insert a new node in Complete Binary Tree.
1. If the tree is empty, initialize the root with new node.
2. Else, get the front node of the queue.
…….If the left child of this front node doesn’t exist, set the left child as the new node.
…….else if the right child of this front node doesn’t exist, set the right child as the new node.
3. If the front node has both the left child and right child, Dequeue() it.
4. Enqueue() the new node.
Code :-
-------------------------
binarytreedequeue.h
#ifndef BINARYTREEDEQUE_H
#define BINARYTREEDEQUE_H
// Program for linked implementation of complete binary tree
#include
#include
// For Queue Size
#define SIZE 50
// A tree node
struct node
{
int data;
struct node *right,*left;
};
// A queue node
struct Queue
{
int front, rear;
int size;
struct node* *array;
};
class BinaryTreeDeque
{
public:
BinaryTreeDeque();
struct node* newNode(int data);
struct Queue* createQueue(int size);
int isEmpty(struct Queue* queue);
int isFull(struct Queue* queue);
int hasOnlyOneItem(struct Queue* queue);
void Enqueue(struct node *root, struct Queue* queue);
struct node* Dequeue(struct Queue* queue);
struct node* getFront(struct Queue* queue);
int hasBothChild(struct node* temp);
void insert(struct node **root, int data, struct Queue* queue);
void display(struct Queue* queue);
node * getValues(struct Queue* queue);
};
#endif // BINARYTREEDEQUE_H
binarydequeue.cpp
---------------------------------------
#include \"binarytreedeque.h\"
BinaryTreeDeque::BinaryTreeDeque()
{
}
// A utility function to create a new tree node
struct node* BinaryTreeDeque::newNode(int data)
{
struct node* temp = (struct node*) malloc(sizeof( struct node ));
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to create a new Queue
struct Queue* BinaryTreeDeque::createQueue(int size)
{
struct Queue* queue = (struct Queue*) malloc(sizeof( struct Queue ));
queue->front = queue->rear = -1;
queue->size = size;
queue->array = (struct node**) malloc(queue->size * sizeof( struct node* ));
int i;
for (i = 0; i < size; ++i)
queue->array[i] = NULL;
return queue;
}
// Standard Queue Functions
int BinaryTreeDeque::isEmpty(struct Queue* queue)
{
return queue->front == -1;
}
int BinaryTreeDeque::isFull(struct Queue* queue)
{ return queue->rear == queue->size - 1; }
int BinaryTreeDeque::hasOnlyOneItem(struct Queue* queue)
{ return queue->front == queue->rear; }
void BinaryTreeDeque::Enqueue(struct node *root, s.
#include <stdio.h> #include <malloc.h> #define ISEMP.pdf
#include <stdio.h>
#include <malloc.h>
#define ISEMPTY printf(\"\ EMPTY LIST:\");
/*
* Node Declaration
*/
struct node
;
snode* create_node(int);
void insert_node_first();
void insert_node_last();
void insert_node_pos();
void sorted_ascend();
void delete_pos();
void search();
void update_val();
void display();
void rev_display(snode *);
typedef struct node snode;
snode *newnode, *ptr, *prev, *temp;
snode *first = NULL, *last = NULL;
/*
* Main :contains menu
*/
int main()
whereas (ans == \'Y\'||ans == \'y\')
value = val;
newnode->next = NULL;
{return|come back|come\" id=\"tip_27\">come newnode;
}
}
/*
* Inserting Node initially
*/
void insert_node_first()
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node eventually
*/
void insert_node_last()
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node at position
*/
void insert_node_pos()
if (pos == 1)
{
if (first == last && initial == NULL)
{
initial = last = newnode;
first->next = NULL;
last->next = NULL;
}
else
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ Inserted\");
}
else if (pos>1 && pos<=cnt)
prev->next = newnode;
newnode->next = ptr;
printf(\"\ ----INSERTED----\");
}
else
}
}
printf(\"\ ---Sorted List---\");
for (ptr = first;ptr != NULL;ptr = ptr->next)
if (
Solution
#include <stdio.h>
#include <malloc.h>
#define ISEMPTY printf(\"\ EMPTY LIST:\");
/*
* Node Declaration
*/
struct node
;
snode* create_node(int);
void insert_node_first();
void insert_node_last();
void insert_node_pos();
void sorted_ascend();
void delete_pos();
void search();
void update_val();
void display();
void rev_display(snode *);
typedef struct node snode;
snode *newnode, *ptr, *prev, *temp;
snode *first = NULL, *last = NULL;
/*
* Main :contains menu
*/
int main()
whereas (ans == \'Y\'||ans == \'y\')
value = val;
newnode->next = NULL;
{return|come back|come\" id=\"tip_27\">come newnode;
}
}
/*
* Inserting Node initially
*/
void insert_node_first()
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node eventually
*/
void insert_node_last()
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node at position
*/
void insert_node_pos()
if (pos == 1)
{
if (first == last && initial == NULL)
{
initial = last = newnode;
first->next = NULL;
last->next = NULL;
}
else
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ Inserted\");
}
else if (pos>1 && pos<=cnt)
prev->next = newnode;
newnode->next = ptr;
printf(\"\ ----INSERTED----\");
}
else
}
}
printf(\"\ ---Sorted List---\");
for (ptr = first;ptr != NULL;ptr = ptr->next)
if (.
#include stdafx.h using namespace std; #include stdlib.h.docx
This document contains C++ code for performing various shellsort algorithms. It defines functions for generating test data, sorting the data using different increment strategies, and outputting the results to a file for graphing operations counts against sample size. The code provides examples for students to write their own shellsort functions with custom increment strategies.
C program
This document contains code snippets for various operations on linked lists and polynomials in C programming language. It includes 9 questions covering topics like:
1. Counting characters, words, digits in a string
2. Squeezing a string by removing spaces
3. Swapping values using pointers
4. Comparing two strings
5. Concatenating two strings
6. Multiplying two matrices
7. Reversing a string
8. Performing insertion, deletion and traversal on singly linked lists
9. Implementing polynomial addition and multiplication by representing polynomials as linked lists
For each question, the C code to implement the operation is provided along with sample input/output.
Recommended
Write a function in C++ to generate an N-node random binary search t.pdf
Write a function in C++ to generate an N-node random binary search tree with distinct keys 1
through N.
Assume that you have available a function, randInt(lower,upper), that generates a uniform
random integer in the appropriate closed interval.
What is the running time of your routine?
Solution
/ A C++ prgroam to contrcut all unique BSTs for keys from 1 to n
#include
#include
using namespace std;
// node structure
struct node
{
int key;
struct node *left, *right;
};
// A utility function to create a new BST node
struct node *newNode(int item)
{
struct node *temp = new node;
temp->key = item;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to do preorder traversal of BST
void preorder(struct node *root)
{
if (root != NULL)
{
cout << root->key << \" \";
preorder(root->left);
preorder(root->right);
}
}
// function for constructing trees
vector constructTrees(int start, int end)
{
vector list;
/* if start > end then subtree will be empty so returning NULL
in the list */
if (start > end)
{
list.push_back(NULL);
return list;
}
/* iterating through all values from start to end for constructing\\
left and right subtree recursively */
for (int i = start; i <= end; i++)
{
/* constructing left subtree */
vector leftSubtree = constructTrees(start, i - 1);
/* constructing right subtree */
vector rightSubtree = constructTrees(i + 1, end);
/* now looping through all left and right subtrees and connecting
them to ith root below */
for (int j = 0; j < leftSubtree.size(); j++)
{
struct node* left = leftSubtree[j];
for (int k = 0; k < rightSubtree.size(); k++)
{
struct node * right = rightSubtree[k];
struct node * node = newNode(i);// making value i as root
node->left = left; // connect left subtree
node->right = right; // connect right subtree
list.push_back(node); // add this tree to list
}
}
}
return list;
}
// Driver Program to test above functions
int main()
{
// Construct all possible BSTs
vector totalTreesFrom1toN = constructTrees(1, 3);
/* Printing preorder traversal of all constructed BSTs */
cout << \"Preorder traversals of all constructed BSTs are \ \";
for (int i = 0; i < totalTreesFrom1toN.size(); i++)
{
preorder(totalTreesFrom1toN[i]);
cout << endl;
}
return 0;
}
Output:.
DATASTRUCTURES PPTS PREPARED BY M V BRAHMANANDA REDDY
This document discusses binary search trees and provides source code to implement binary search tree traversal operations. It explains that a binary search tree is a binary tree where the left child of a node is less than the parent and the right child is greater. It provides code for preorder, inorder, and postorder traversals of the binary search tree and outputs the traversal order for a sample tree.
Lab-2.4 101.pdf
The document contains C program code to implement three data structures using linked lists:
1) A stack using a singly linked list with push, pop, and display functions.
2) A queue using a singly linked list with enqueue, dequeue, and display functions.
3) A program to merge two sorted linked lists by comparing nodes and appending to the merged list.
Pseudocode and sample test cases are provided for each problem.
include ltiostreamgt include ltfstreamgt in.pdf
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
using namespace std;
/* A binary tree node has data,pointer to left child and apointer to right child */
struct Node
{
int data;
Node* left, * right;
};
/*Function for creating a new Node structure */
Node* newNode(int data)
{
Node* node = new Node;
//Node* node = (Node*)malloc(sizeof(Node)); //will also work.
node->data = data;
node->left = node->right = NULL;
return (node);
}
// Function to insert nodes in level order. This function takes an array-based treerepresentation as
inputand
// convert it into a linked list-based tree representationNode* insertLevelOrder(vector<int>
tree_vec,
//tree_vec: array implementation,
create node for position i.
int i, int n)
{
Node* root = nullptr;
// Base case for recursion
if (i < n)
{
root = newNode(tree_vec[i]);
// insert left child
root->left = insertLevelOrder(tree_vec,
2 * i + 1, n);
// insert right child
root->right = insertLevelOrder(tree_vec,
2 * i + 2, n);
}
return root;
}
// Example code for InOrder traversal
void inOrder(Node * root)
{
if (root != NULL)
{
inOrder(root->left);
cout << root->data << " ";
inOrder(root->right);
}
}
int main()
{
vector<int> tree_vec;
string file_name;
int temp_data;
cout << "Please input the file name of a complete binary tree:";
cin >> file_name;
ifstream tree_file(file_name, ios::in);
if (tree_file.fail())
{
cout << "Fail to open the tree file.";
return 0;
}
while (!tree_file.fail() && !tree_file.eof())
{
tree_file >> temp_data;
tree_vec.push_back(temp_data);
}
/*Transform the array-based tree into linked-list in level-order.*/
Node* root = insertLevelOrder(tree_vec, 0, tree_vec.size());
/*Task 1, to be implemented*/
cout << "The Preorder Traversal result is: " << endl;
/*Example implementation*/
cout << "The Inorder Traversal result is: " << endl;
inOrder(root);
/*Task 2, to be implemented*/
cout << "The Postorder Traversal result is: " << endl;
/*Task 3, to be implemented*/
cout << "The number of leaf nodes is: " << endl;
return 0;
}
please help me to finish the code with the task using c++
#include <iostream>
#include <fstream>
#include <sstream>
#include <vector>
#include <string>
using namespace std;
/* A binary tree node has data,pointer to left child and apointer to right child */
struct Node
{
int data;
Node* left, * right;
};
/*Function for creating a new Node structure */
Node* newNode(int data)
{
Node* node = new Node;
//Node* node = (Node*)malloc(sizeof(Node)); //will also work.
node->data = data;
node->left = node->right = NULL;
return (node);
}
// Function to insert nodes in level order. This function takes an array-based treerepresentation as
inputand
// convert it into a linked list-based tree representationNode* insertLevelOrder(vector<int>
tree_vec,
//tree_vec: array implementation,
create node for position i.
int i, int n)
{
Node* root = nullptr;
// Base case for recursion
if (i < n)
{
root = newNode(tree_vec[i]);
// insert left child
root->left = inse.
Please write in C++ and should be able to compile and debug.Thank yo.pdf
Please write in C++ and should be able to compile and debug.Thank you
Create a class called BinaryTreeDeque. This binary tree implements all of the functionality of
the BinaryTree class, but instead of storing its values in a tree structure, the element values are
stored in a deque, using pointers to maintain the relationship between the binary tree and its node
values. Additionally: deque * getValues() - returns a copy of the deque the current array of
values (which should be in insertion order).
Solution
Following are steps to insert a new node in Complete Binary Tree.
1. If the tree is empty, initialize the root with new node.
2. Else, get the front node of the queue.
…….If the left child of this front node doesn’t exist, set the left child as the new node.
…….else if the right child of this front node doesn’t exist, set the right child as the new node.
3. If the front node has both the left child and right child, Dequeue() it.
4. Enqueue() the new node.
Code :-
-------------------------
binarytreedequeue.h
#ifndef BINARYTREEDEQUE_H
#define BINARYTREEDEQUE_H
// Program for linked implementation of complete binary tree
#include
#include
// For Queue Size
#define SIZE 50
// A tree node
struct node
{
int data;
struct node *right,*left;
};
// A queue node
struct Queue
{
int front, rear;
int size;
struct node* *array;
};
class BinaryTreeDeque
{
public:
BinaryTreeDeque();
struct node* newNode(int data);
struct Queue* createQueue(int size);
int isEmpty(struct Queue* queue);
int isFull(struct Queue* queue);
int hasOnlyOneItem(struct Queue* queue);
void Enqueue(struct node *root, struct Queue* queue);
struct node* Dequeue(struct Queue* queue);
struct node* getFront(struct Queue* queue);
int hasBothChild(struct node* temp);
void insert(struct node **root, int data, struct Queue* queue);
void display(struct Queue* queue);
node * getValues(struct Queue* queue);
};
#endif // BINARYTREEDEQUE_H
binarydequeue.cpp
---------------------------------------
#include \"binarytreedeque.h\"
BinaryTreeDeque::BinaryTreeDeque()
{
}
// A utility function to create a new tree node
struct node* BinaryTreeDeque::newNode(int data)
{
struct node* temp = (struct node*) malloc(sizeof( struct node ));
temp->data = data;
temp->left = temp->right = NULL;
return temp;
}
// A utility function to create a new Queue
struct Queue* BinaryTreeDeque::createQueue(int size)
{
struct Queue* queue = (struct Queue*) malloc(sizeof( struct Queue ));
queue->front = queue->rear = -1;
queue->size = size;
queue->array = (struct node**) malloc(queue->size * sizeof( struct node* ));
int i;
for (i = 0; i < size; ++i)
queue->array[i] = NULL;
return queue;
}
// Standard Queue Functions
int BinaryTreeDeque::isEmpty(struct Queue* queue)
{
return queue->front == -1;
}
int BinaryTreeDeque::isFull(struct Queue* queue)
{ return queue->rear == queue->size - 1; }
int BinaryTreeDeque::hasOnlyOneItem(struct Queue* queue)
{ return queue->front == queue->rear; }
void BinaryTreeDeque::Enqueue(struct node *root, s.
#include <stdio.h> #include <malloc.h> #define ISEMP.pdf
#include <stdio.h>
#include <malloc.h>
#define ISEMPTY printf(\"\ EMPTY LIST:\");
/*
* Node Declaration
*/
struct node
;
snode* create_node(int);
void insert_node_first();
void insert_node_last();
void insert_node_pos();
void sorted_ascend();
void delete_pos();
void search();
void update_val();
void display();
void rev_display(snode *);
typedef struct node snode;
snode *newnode, *ptr, *prev, *temp;
snode *first = NULL, *last = NULL;
/*
* Main :contains menu
*/
int main()
whereas (ans == \'Y\'||ans == \'y\')
value = val;
newnode->next = NULL;
{return|come back|come\" id=\"tip_27\">come newnode;
}
}
/*
* Inserting Node initially
*/
void insert_node_first()
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node eventually
*/
void insert_node_last()
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node at position
*/
void insert_node_pos()
if (pos == 1)
{
if (first == last && initial == NULL)
{
initial = last = newnode;
first->next = NULL;
last->next = NULL;
}
else
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ Inserted\");
}
else if (pos>1 && pos<=cnt)
prev->next = newnode;
newnode->next = ptr;
printf(\"\ ----INSERTED----\");
}
else
}
}
printf(\"\ ---Sorted List---\");
for (ptr = first;ptr != NULL;ptr = ptr->next)
if (
Solution
#include <stdio.h>
#include <malloc.h>
#define ISEMPTY printf(\"\ EMPTY LIST:\");
/*
* Node Declaration
*/
struct node
;
snode* create_node(int);
void insert_node_first();
void insert_node_last();
void insert_node_pos();
void sorted_ascend();
void delete_pos();
void search();
void update_val();
void display();
void rev_display(snode *);
typedef struct node snode;
snode *newnode, *ptr, *prev, *temp;
snode *first = NULL, *last = NULL;
/*
* Main :contains menu
*/
int main()
whereas (ans == \'Y\'||ans == \'y\')
value = val;
newnode->next = NULL;
{return|come back|come\" id=\"tip_27\">come newnode;
}
}
/*
* Inserting Node initially
*/
void insert_node_first()
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node eventually
*/
void insert_node_last()
printf(\"\ ----INSERTED----\");
}
/*
* Inserting Node at position
*/
void insert_node_pos()
if (pos == 1)
{
if (first == last && initial == NULL)
{
initial = last = newnode;
first->next = NULL;
last->next = NULL;
}
else
worker = first;
initial = newnode;
first->next = temp;
}
printf(\"\ Inserted\");
}
else if (pos>1 && pos<=cnt)
prev->next = newnode;
newnode->next = ptr;
printf(\"\ ----INSERTED----\");
}
else
}
}
printf(\"\ ---Sorted List---\");
for (ptr = first;ptr != NULL;ptr = ptr->next)
if (.
#include stdafx.h using namespace std; #include stdlib.h.docx
This document contains C++ code for performing various shellsort algorithms. It defines functions for generating test data, sorting the data using different increment strategies, and outputting the results to a file for graphing operations counts against sample size. The code provides examples for students to write their own shellsort functions with custom increment strategies.
C program
This document contains code snippets for various operations on linked lists and polynomials in C programming language. It includes 9 questions covering topics like:
1. Counting characters, words, digits in a string
2. Squeezing a string by removing spaces
3. Swapping values using pointers
4. Comparing two strings
5. Concatenating two strings
6. Multiplying two matrices
7. Reversing a string
8. Performing insertion, deletion and traversal on singly linked lists
9. Implementing polynomial addition and multiplication by representing polynomials as linked lists
For each question, the C code to implement the operation is provided along with sample input/output.
Write a C program that reads the words the user types at the command.pdf
Write a C program that reads the words the user types at the command prompt (using the \'int
argc, char * argv[] and store each unique letter in a Binary Search Tree. When a duplicate is
encountered do not store the letter again and instead keep track of the count in the tree. Once the
Binary Search tree has been created print out the tree both inorder and reverse order. Also print
the highest and lowest alphabetically letter in the tree if any.
Solution
# include
# include
# include
typedef struct BST {
int data;
struct BST *lchild, *rchild;
} node;
void insert(node *, node *);
void preorder(node *);
findMinimum(struct node* root)
findMaximum(struct node* root)
void reverseLevelOrder(struct node* root)
void main(int argc,char argv) {
char argv = \'N\';
int key;
node *new_node, *root, *tmp, *parent;
node *get_node();
root = NULL;
clrscr();
printf(\"\ Program For Binary Search Tree \");
do {
printf(\"\ 1.Create\");
printf(\"\ 2.Search\");
printf(\"\ 3.Recursive Traversals\");
printf(\"\ 4.Exit\");
printf(\"\ Enter your choice :\");
scanf(\"%d\", &argc);
switch (argc) {
case 1:
do {
new_node = get_node();
printf(\"\ Enter The Element \");
scanf(\"%d\", &new_node->data);
if (root == NULL) /* Tree is not Created */
root = new_node;
else
insert(root, new_node);
printf(\"\ Want To enter More Elements?(y/n)\");
argv= getch();
} while (argv == \'y\');
break;
case 2:
if (root == NULL)
printf(\"Tree Is Not Created\");
else {
printf(\"\ The Preorder display : \");
preorder(root);
}
break;
}
} while (argv != 4);
}
/*
Get new Node
*/
node *get_node() {
node *temp;
temp = (node *) malloc(sizeof(node));
temp->lchild = NULL;
temp->rchild = NULL;
return temp;
}
/*
This function is for creating a binary search tree
*/
void insert(node *root, node *new_node) {
if (new_node->data < root->data) {
if (root->lchild == NULL)
root->lchild = new_node;
return newNode(key);
else
insert(root->lchild, new_node);
}
if (new_node->data > root->data) {
if (root->rchild == NULL)
root->rchild = new_node;
return newNode(key);
else
insert(root->rchild, new_node);
}
}
if (key == node->key)
{
(node->count)++;
return node;
}
/*
This function displays the tree in preorder fashion
*/
void preorder(node *temp) {
if (temp != NULL) {
printf(\"%d\", temp->data);
preorder(temp->lchild);
preorder(temp->rchild);
}
}
// Returns maximum value in a given Binary Tree
int findMaximum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MAXIMUM;
// Return maximum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMaximum (root->lchild);
int rres = findMaximum (root->rchild);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// Returns minimum value in a given Binary Tree
int findMinimum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MINIMUM;
// Return minimum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMinimum(r.
Task4output.txt 2 5 9 13 15 10 1 0 3 7 11 14 1.docx
Task4/output.txt
2 5 9 13
15 10 1 0
3 7 11 14
12 8 6 4
2 5 1 0
3 7 6 4
12 8 9 13
15 10 11 14
0 1 2 5
7 6 4 3
8 9 12 13
15 14 11 10
0 1 2 3
7 6 4 5
8 9 11 10
15 14 12 13
0 1 2 3
7 6 5 4
8 9 10 11
15 14 13 12
Task4/task4.cpp
#include <cstdio>
#include <iostream>
using namespace std;
#define MAXROW 4
#define MAXCOL 4
void bidirection_bbsort(int a[], int n, bool ascending)
{
int i,j, temp;
//This is the original bubble sort
// Make SMALL change such that it handles descending sorting too
for (i = n-1; i >= 1; i--) {
for (j = 1; j <= i; j++) {
if (a[j-1] > a[j]) {
temp = a[j-1] ;
a[j-1] = a[j] ;
a[j] = temp ;
}
}
}
}
void column_sort(int m[][MAXCOL], int col)
{
//Use the bidirection_bbsort() once it is implemented
// No need to invent / write a new sorting logic
}
void print_matrix(int m[][MAXCOL], int nRow, int nCol)
{
int i, j;
for (i = 0; i < nRow; i++){
for (j = 0; j < nCol; j++){
printf("%2d ", m[i][j]); //use printf for easier formatting
//cout << setw(2) << m[i][j] << " "; //equivalent c++ output formatting
}
cout << endl;
}
cout << endl;
}
void phase_A(int mat[][MAXCOL], int nRow, int nCol)
{
int i;
bool order = true;
for (i = 0; i < nRow; i++, order = !order){
bidirection_bbsort(mat[i], nCol, order);
}
}
void phase_B(int mat[][MAXCOL], int nRow, int nCol)
{
int i;
for (i = 0; i < nCol; i++){
column_sort(mat, i);
}
}
void magic_sort(int mat[][MAXCOL], int nRow, int nCol)
{
int i;
for (i = 1; i < nRow; i *= 2){
phase_A(mat, nRow, nCol);
print_matrix(mat, nRow, nCol);
phase_B(mat, nRow, nCol);
print_matrix(mat, nRow, nCol);
}
phase_A(mat, nRow, nCol);
print_matrix(mat, nRow, nCol);
}
int main()
{
int arr[] = { 5, 12, 6, 7, 9, 6, 1};
int i;
int mat[MAXROW][MAXCOL] = {
{5, 2, 13, 9},
{10, 1, 15, 0},
{7, 3, 11, 14},
{12, 8, 4, 6}
};
magic_sort(mat, 4, 4);
return 0;
}
Task3/task3.cpp
#include <cstdio>
#include <iostream>
using namespace std;
struct Point {
int X, Y;
};
void sort(Point a[], int n)
{
//You can adapt any of the insertion / selection / bubble sort
}
int main()
{
int i;
Point ptArray[5] = { {11, 34}, {5, 73}, {11, 19}, {13, 5}, {11,
68}};
sort(ptArray, 5);
//The output should match the order given in question
for (i = 0; i < 5; i++){
printf("(%d, %d)\n", ptArray[i].X, ptArray[i].Y);
}
return 0;
}
Task2/sample_length_3.txt
***
%%%
%##
%$$
##%
$$%
Task2/sample_length_5.txt
***%%
***##
***$$
%***%
%%***
%%%%%
%%%##
%%%$$
%%##%
%%$$%
%##%%
%####
%##$$
%$$%%
%$$##
%$$$$
##***
##%%%
##%##
##%$$
####%
##$$%
$$***
$$%%%
$$%.
pleaase I want manual solution forData Structures and Algorithm An.pdf
pleaase I want manual solution for
Data Structures and Algorithm Analysis in C++, Third Edition
By Clifford A. Shaffer
because my question from this book.page270 ,question 7.4
The implementation for Mergesort given in Section 7.4 takes an array as input and sorts that
array. At the beginning of Section 7.4 there is a simple pseudocode implementation for sorting a
linked list using Mergesort. Implement both a linked list-based version of Mergesort and the
array-based version of Mergesort, and compare and analyze their running times.
Solution
Linked list:
#include
#include
struct node
{
int data;
struct node* next;
};
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef);
void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a;
struct node* b;
if ((head == NULL) || (head->next == NULL))
{
return;
}
FrontBackSplit(head, &a, &b);
MergeSort(&a);
MergeSort(&b);
*headRef = SortedMerge(a, b);
}
struct node* SortedMerge(struct node* a, struct node* b)
{
struct node* result = NULL;
if (a == NULL)
return(b);
else if (b==NULL)
return(a);
if (a->data <= b->data)
{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return(result);
}
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef)
{
struct node* fast;
struct node* slow;
if (source==NULL || source->next==NULL)
{
*frontRef = source;
*backRef = NULL;
}
else
{
slow = source;
fast = source->next;
while (fast != NULL)
{
fast = fast->next;
if (fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
}
*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
void push(struct node** head_ref, int new_data)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
int main()
{
struct node* res = NULL;
struct node* a = NULL;
push(&a, 15);
push(&a, 10);
push(&a, 5);
push(&a, 20);
push(&a, 3);
push(&a, 2);
MergeSort(&a);
printf(\"\ Sorted Linked List is: \ \");
printList(a);
getchar();
return 0;
}
Time complexity:o(nlogn)
Array :
#include
#include
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0; // Initial index of first subarray
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l+(r-l)/2;
// Sort first and second halves
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
void printArray(int A[], i.
#include iostream using namespace std; const int nil = 0; cl.docx
The program implements a binary search tree to store 20 integers input by the user. It performs level order, preorder, inorder and postorder traversals of the tree, printing the value and level of each node. It also outputs the number of leaf nodes, nodes with one child, and nodes with two children. Finally, it calculates and prints the maximum and minimum leaf levels and checks if the tree is balanced.
I have C++ question that I do not know how to do, Can you teach me t.pdf
I have C++ question that I do not know how to do, Can you teach me this question:
Draw a CLASS diagram for Binary Search Tree (BTS) :
can you explain me each step, thank you
Solution
//program to convert Binary Tree to Binary Search Tree
#include
#include
// A binary tree node structure
struct node
{
int data;
struct node *left;
struct node *right;
};
void storeInorder (struct node* node, int inorder[], int *index_ptr)
{
// Base Case
if (node == NULL)
return;
// first store the left subtree
storeInorder (node->left, inorder, index_ptr);
// Copy the root\'s data
inorder[*index_ptr] = node->data;
(*index_ptr)++; // increase index for next entry
// finally store the right subtree
storeInorder (node->right, inorder, index_ptr);
}
/* A helper function to count nodes in a Binary Tree */
int countNodes (struct node* root)
{
if (root == NULL)
return 0;
return countNodes (root->left) +
countNodes (root->right) + 1;
}
// Following function is needed for library function qsort()
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
/* A helper function that copies contents of arr[] to Binary Tree.
This functon basically does Inorder traversal of Binary Tree and
one by one copy arr[] elements to Binary Tree nodes */
void arrayToBST (int *arr, struct node* root, int *index_ptr)
{
// Base Case
if (root == NULL)
return;
/* first update the left subtree */
arrayToBST (arr, root->left, index_ptr);
/* Now update root\'s data and increment index */
root->data = arr[*index_ptr];
(*index_ptr)++;
/* finally update the right subtree */
arrayToBST (arr, root->right, index_ptr);
}
// This function converts a given Binary Tree to BST
void binaryTreeToBST (struct node *root)
{
// base case: tree is empty
if(root == NULL)
return;
/* Count the number of nodes in Binary Tree so that
we know the size of temporary array to be created */
int n = countNodes (root);
// Create a temp array arr[] and store inorder traversal of tree in arr[]
int *arr = new int[n];
int i = 0;
storeInorder (root, arr, &i);
// Sort the array using library function for quick sort
qsort (arr, n, sizeof(arr[0]), compare);
// Copy array elements back to Binary Tree
i = 0;
arrayToBST (arr, root, &i);
// delete dynamically allocated memory to avoid meory leak
delete [] arr;
}
/* Utility function to create a new Binary Tree node */
struct node* newNode (int data)
{
struct node *temp = new struct node;
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* Utility function to print inorder traversal of Binary Tree */
void printInorder (struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */
printInorder (node->left);
/* then print the data of node */
printf(\"%d \", node->data);
/* now recur on right child */
printInorder (node->right);
}
/* Driver function to test above functions */
int main()
{
struct node *root = NULL;
/* Constructing tree given in the above figure
10
/ \\
30 15
/ \\
20 5 */
root = newNode(10);
root->left = newNode(30.
Compiler Design Unit 3
The document discusses code generation from intermediate code represented as a directed acyclic graph (DAG). It describes algorithms for constructing a DAG from basic blocks of code and generating optimal machine code from the DAG. Specifically:
1) It presents an algorithm to construct a DAG from basic blocks by creating nodes for variables, operators, and constants and connecting them based on the operations.
2) It explains that the DAG can be used to detect common subexpressions and eliminate unnecessary assignments.
3) An algorithm is provided to generate machine code from the DAG by rearranging operations to obtain an optimal computation sequence.
4) Labeling algorithms are introduced to number nodes in a tree to minimize register usage during code generation
How to build a Linked List that can insert any type of data. For exa.pdf
How to build a Linked List that can insert any type of data. For example: SLinkedList abc1;
SLinkedList abc2; SLinkedlist abc3; Please answer in C plus plus, you don\'t need to develop all
function, just insert data is enough.
Thank you.
Solution
#include
#include
#define LEFT 2
#define RIGHT 3
typedef struct linked_list
{
double data;
struct linked_list *next;
}node;//node declaration for single linked list
/*function prototype declaration*/
void insertion(node **,double);
void erase(node **,node **);
//void left_or_right(node **,node **,int);
node *makenode(double);
void show(node **,node **);
/*main*/
int main()
{
system(\"clear\");
char choice;
double item;
node *start=NULL,*prev=NULL;
do
{
printf(\"\ ===========================\ \\tMENU\
===========================\ \\t1.Insert\ \\t2.Exit\ Enter your choice :: \");
scanf(\"\ %c\",&choice);
switch(choice)
{
case \'1\':
printf(\"\ Enter item :: \");
scanf(\"%lf\",&item);
insertion(&start,item);//insert function calling
show(&start,&prev);
break;
case \'2\':
erase(&prev,&start);
printf(\"\ You are exited from the whole program.\ \ \");
exit(1);
default:
printf(\"\ \\tWrong Choice\ \");
}
}
while(choice!=\'2\');
return 0;
}
void show(node **start,node **prev)/*this function displays the whole linked list*/
{
if((*start)!=NULL)
{
printf(\"\ \ X <- \");
node *temp=NULL,*p=*prev,*q=NULL;
while(p!=NULL)
{
if(temp==NULL)
{
temp=makenode(p->data);
}
else
{
q=makenode(p->data);
q->next=temp;
temp=q;
}
p=p->next;
}
while(temp!=NULL)
{
printf(\"%.0lf <- \",temp->data);
q=temp;
temp=temp->next;
free(q);
q=NULL;
}
printf(\"\\b| \");
p=*start;
while(p!=NULL)
{
if(p==*start)
{
printf(\"%.0lf |-> \",p->data);
}
else
{
printf(\"%.0lf -> \",p->data);
}
p=p->next;
}
printf(\" X \ \ \");
}
else
{
printf(\"\ \ \\tEmpty Linked List\ \ \");
}
}
void insertion(node **start,double item)//this function inserts a new node in the linked list
{
node *temp=makenode(item),*p=NULL;
if(*start==NULL)
{
*start=temp;
}
else
{
p=*start;
while(p->next!=NULL)
{
p=p->next;
}
p->next=temp;
}
}
node *makenode(double item)
{
node *temp=NULL;
temp=(node *)malloc(sizeof(node));
if(temp==NULL)
{
printf(\"\ Dynamic memory allocation failed.\ \");
exit(0);
}
temp->data=item;
temp->next=NULL;
}
void erase(node **prev,node **start)//this function deletes all nodes of the linked list when the
program terminates
{
node *p=NULL;
while(*start!=NULL)
{
p=*start;
*start=(*start)->next;
free(p);
p=NULL;
}
while(*prev!=NULL)
{
p=*prev;
*prev=(*prev)->next;
free(p);
p=NULL;
}
}.
Please write the C++ code that would display the exact same output a.pdf
Please write the C++ code that would display the exact same output as provided. Thank you.
main.cpp
#include "TreeNode.h"
//GIVEN
void inorderTraversal(TreeNode * root);
//TODO
TreeNode * search(TreeNode * node,int data);
//GIVEN
void insert(TreeNode * node,int data);
//GIVEN
bool isNull(TreeNode * node){
return node==nullptr;
}
int main() {
// create the root, gets set to null
TreeNode * root;
// create the roor and set the data of root to 5
root= new TreeNode(5);
//create two additional nodes with data values 10 and 3
// these will go to the right and left of root respectively
TreeNode * ten= new TreeNode(10);
TreeNode * three= new TreeNode(3);
//connect ten to the right of root (which has data 5)
root->setRight(ten);
//connect three to the left of root (which has data 5)
root->setLeft(three);
// note this can also be done as
//root.setRight(new TreeNode(10));
//root.setLeft(new TreeNode(3);)
// add two more nodes
//the first has data value 7. So to keep the tree in insorted order, it should get attached as the
left node of ten
// the second has data value 4. So to keep the tree in insorted order, it should get attached as the
right node of three
ten->addLeft(7);
three->addRight(4);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
std::cout<<"**************************************\n";
std::cout<<"Searching for Node \n";
TreeNode* result = search(root,4);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<4<<"\n";
result = search(root,1);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<1<<"\n";
std::cout<<"**************************************\n";
std::cout<<"Inserting 6\n";
insert(root,6);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
}
// uses recursion
void inorderTraversal(TreeNode * node){
// exit case
if (isNull(node)) return;
if (node->isLeaf()){
std::cout<<"Printing Leaf Node "<getData()<<"\n";
return;}
// reached a node with no left, so print the node and travel right
if (!isNull(node->getLeft()))
// if there is a left path, then travel further on that
inorderTraversal(node->getLeft());
std::cout<<"Printing Node "<getData()<<"\n";
// save and travel the right path of the current node being processed
inorderTraversal(node->getRight());
}
// uses recursion
//TODO
TreeNode * search(TreeNode * node, int data){
// if the node is null return the null ptr
//if this nodes data equals the search date return found
// if not, if the left tree exists and search data less than
//this nodes data return the result of recursive all to search with left pointer
// if no left tree, but right tree exists and search data greater than
//this nodes data return the result of recursive all to search with right pointer
// if both above conditions not true return null ptr
}
//uses recursion
void insert(TreeNode * node,int .
Please read the comment ins codeExpressionTree.java-------------.pdf
Please read the comment ins code
ExpressionTree.java
----------------------------------
/**
* This is the class for Expression Tree.
* Used to create Expression Tree and Evaluate it
*/
/**
* Following logic is used to construct a Tree
* Here we use stack for Preparing Tree
* Loop through given Expression String
* If Character is Operand , Create node and push to stack
* If Character is Operator then
* 1)Create Node for Operator
* 2)Pop 2 nodes from Stack and Made
* OpretorNode--> left == first node pop
* OpretorNode--> right == second node pop
* At the end of creation of Expression Tree, Stack have only one node , which is root of
Expression tree
*/
/** Class ExpressionTree **/
class ExpressionTree
{
/** class TreeNode
* Stored Character ==> Digit(0..9) or a Operator +,-,*,/
* Left Node and Right Node
*
* **/
class TreeNode
{
char data;
TreeNode left, right;
/** constructor **/
public TreeNode(char data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
/** class StackNode **/
class StackNode
{
TreeNode treeNode;
StackNode next;
/** constructor **/
public StackNode(TreeNode treeNode)
{
this.treeNode = treeNode;
next = null;
}
}
private static StackNode top;
/** constructor
* Constructor takes input string like \"+-+7*935*82*625\"
* Input should be in Prefix notation
* **/
public ExpressionTree(String expression)
{
top = null;
//Call Method for prepare expression tree
buildTree(expression);
}
/** function to clear tree **/
public void clear()
{
top = null;
}
/** function to push a node **/
private void push(TreeNode ptr)
{
if (top == null)
top = new StackNode(ptr);
else
{
StackNode nptr = new StackNode(ptr);
nptr.next = top;
top = nptr;
}
}
/** function to pop a node
* When it find operator pop 2 elements from Stack
*
* **/
private TreeNode pop()
{
if (top == null)
throw new RuntimeException(\"Underflow\");
else
{
TreeNode ptr = top.treeNode;
top = top.next;
return ptr;
}
}
/** function to get top node **/
private TreeNode peek()
{
return top.treeNode;
}
/** function to insert character **/
private void insert(char val)
{
try
{
//If Operand , Create node and push to Stack
if (isDigit(val))
{
TreeNode nptr = new TreeNode(val);
push(nptr);
}
//If Operator , Create node and popup 2 elements and make them its right and left
else if (isOperator(val))
{
TreeNode nptr = new TreeNode(val);
nptr.left = pop();
nptr.right = pop();
push(nptr);
}
}
catch (Exception e)
{
System.out.println(\"Invalid Expression\");
}
}
/** function to check if digit **/
private boolean isDigit(char ch)
{
return ch >= \'0\' && ch <= \'9\';
}
/** function to check if operator **/
private boolean isOperator(char ch)
{
return ch == \'+\' || ch == \'-\' || ch == \'*\' || ch == \'/\';
}
/** function to convert character to digit **/
private int toDigit(char ch)
{
return ch - \'0\';
}
/** function to build tree from input */
public void buildTree(String eqn)
{
for (int i = eqn.length() - 1; i >= 0; i--)
insert(eqn.charAt(i));
}
/** function to evaluate tree */
public dou.
pointers
This document outlines Chapter 7 on pointers from a C programming textbook. It introduces pointers, how to declare and initialize pointer variables, pointer operators like & and *, calling functions by reference using pointers, const pointers, bubble sorting using pointers, pointer arithmetic and expressions, the relationship between pointers and arrays, arrays of pointers, and a case study on simulating a card shuffling and dealing program using pointers.
-- Task 2- Debugging a program with stacks- queues- and doubly-linked.docx
/* Task 2: Debugging a program with stacks, queues, and doubly-linked lists There are a number of errors in the following program. All errors are located in main() and structure definitions. Function declarations and definitions are correct! Locate all errors, fix them (as shown below), run the program and save its output as a comment at the end of the source file. Example: int num = 10; int *ptr; num = &ptr; // <== Error: Comment the line and write the correct line below // Write a short justification where appropriate // num = &ptr; // Error #1 ptr = # Name: */ #include #include #include #include #define DUMMY_TRAILER '\177' // octal ASCII code of the // last character in the ASCII table #define NUM_CITIES 10 typedef struct { char name[12]; int temperature[5]; } CITY; // Stack and Queue Node typedef struct node NODE; struct node { CITY city; node *next; }; // Doubly Linked List Node typedef struct d_node D_NODE; struct d_node { CITY city; NODE *forw; NODE *back; }; // Stack Functions NODE *push(NODE *stack, const CITY *pStu); NODE *pop(NODE **stack); // Queue Functions void enqueue(NODE **queue, NODE **rear, const CITY *pStu); NODE *dequeue(NODE **queue, NODE **rear); // Doubly Linked List Functions D_NODE *init_list(void); int insert(D_NODE *list, const CITY *pStu); void traverse_forw(D_NODE *list); void traverse_back(D_NODE *list); // Other Functions void printCity(const CITY *pCity); int main (void) { CITY cList[NUM_CITIES] = { {"Cupertino", {88, 89, 87, 85, 89}}, {"Flagstaff", {81, 80, 88, 89, 89}}, {"Los Angeles", {87, 88, 89, 89, 90}}, {"Philadelphia", {96, 99, 99, 90, 95}}, {"Phoenix", {106, 109, 109, 100, 105}}, {"Portland", {89, 90, 85, 89, 90}}, {"Reno", {108, 105, 109, 100, 108}}, {"Salem", {85, 90, 85, 89, 90}}, {"Tucson", {107, 100, 109, 100, 108}}, {"Yreka", {101, 109, 100, 108, 109}} }; NODE *stack = NULL; NODE *top = NULL; NODE *queue = NULL, *rear = NULL; NODE *front; D_NODE *list; list = init_list(); // build stack and queue with data from an array of CITY structures srand((unsigned int)time(NULL)); int count = rand() % 10; for ( int n = 0; n < count; n++) { int i = rand() % NUM_CITIES; int duplicate = insert(list, &cList[i]); if(duplicate) { // already in the list! push(stack, &cList[i]); enqueue(&queue, &rear, cList[i]); } } // display list printf("\nLIST contents (forwards):\n"); traverse_forw(list); printf("\nLIST contents (backwards):\n"); traverse_back(list); // display stack if (top) { printf("\nSTACK contents from top to bottom:\n"); while ((top = pop(stack))) { printCity(top->city); } } else printf ("Empty Stack!\n"); // display queue if (front) { printf("\nQUEUE contents from front to rear:\n"); while ((front = dequeue( queue, rear))) { printCity(front->city); } } else printf ("Empty Queue!\n"); return 0; } /*************************************************** Displays the fileds of a CIS_CLASS structure Pre pCls - a pointer to a CIS_CLASS structure Post */ void printCity(const CITY *pCity) { printf("%-20s %3d\n",.
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
pointers
This document outlines pointers and related concepts in C programming. It begins with an introduction to pointers, noting they are powerful but difficult to master. It then covers pointer variable declarations and initialization, the pointer operators & and *, calling functions by reference using pointers, and using const with pointers. Later sections discuss pointer expressions and arithmetic, the relationship between pointers and arrays, arrays of pointers, and pointers to functions. The document provides examples to illustrate key pointer concepts.
Write a program to decipher messages encoded using a prefix code, gi.pdf
Write a program to decipher messages encoded using a prefix code, given the encoding tree.
Such codes are widely used in applications that compress data, including JPEG for images, MP3
for music, and DivX for video. using Huffman Trees (Prefix Binary Trees) c++
Solution
#include #include #include #include // for CHAR_BIT #include #include const int
UniqueSymbols = 1 << CHAR_BIT; const char* SampleString = \"this is an example for
huffman encoding\"; typedef std::vector HuffCode; typedef std::map HuffCodeMap; class
INode { public: const int f; virtual ~INode() {} protected: INode(int f) : f(f) {} };
class InternalNode : public INode { public: INode *const left; INode *const right;
InternalNode(INode* c0, INode* c1) : INode(c0->f + c1->f), left(c0), right(c1) {}
~InternalNode() { delete left; delete right; } }; class LeafNode :
public INode { public: const char c; LeafNode(int f, char c) : INode(f), c(c) {} };
struct NodeCmp { bool operator()(const INode* lhs, const INode* rhs) const { return lhs->f
> rhs->f; } }; INode* BuildTree(const int (&frequencies)[UniqueSymbols]) {
std::priority_queue, NodeCmp> trees; for (int i = 0; i < UniqueSymbols; ++i) {
if(frequencies[i] != 0) trees.push(new LeafNode(frequencies[i], (char)i)); }
while (trees.size() > 1) { INode* childR = trees.top(); trees.pop();
INode* childL = trees.top(); trees.pop(); INode* parent = new
InternalNode(childR, childL); trees.push(parent); } return trees.top(); } void
GenerateCodes(const INode* node, const HuffCode& prefix, HuffCodeMap& outCodes) {
if (const LeafNode* lf = dynamic_cast(node)) { outCodes[lf->c] = prefix; }
else if (const InternalNode* in = dynamic_cast(node)) { HuffCode leftPrefix =
prefix; leftPrefix.push_back(false); GenerateCodes(in->left, leftPrefix,
outCodes); HuffCode rightPrefix = prefix; rightPrefix.push_back(true);
GenerateCodes(in->right, rightPrefix, outCodes); } } int main() { // Build
frequency table int frequencies[UniqueSymbols] = {0}; const char* ptr =
SampleString; while (*ptr != \'\\0\') ++frequencies[*ptr++]; INode* root =
BuildTree(frequencies); HuffCodeMap codes; GenerateCodes(root, HuffCode(),
codes); delete root; for (HuffCodeMap::const_iterator it = codes.begin(); it !=
codes.end(); ++it) { std::cout << it->first << \" \"; std::copy(it-
>second.begin(), it->second.end(), std::ostream_iterator(std::cout)); std::cout
<< std::endl; } return 0; }.
Unit 1 LINEAR DATA STRUCTURES
This document discusses linear data structures and linked lists. It begins with an introduction to data structures and defines them as a way to organize and store data and relationships between data. It then discusses list abstract data types (ADTs) and their operations. The document focuses on linked list representations of lists and covers singly linked lists, doubly linked lists, and circular linked lists. It describes the nodes that make up each type of linked list and their operations like insertion, deletion, and searching. Finally, it provides an example of using linked lists to represent polynomial equations and operations like addition on polynomials.
Final ds record
The program implements operations on a stack using an array. It includes functions for push(), pop(), and display(). Push inserts an element into the stack if not full. Pop removes an element if not empty. Display prints the stack elements using a for loop. The main() uses a switch case to call the functions based on user input until exit is chosen.
take the following code and give details of what each line of code i.pdf
take the following code and give details of what each line of code is doing
#include
#include
#include
using namespace std;
/*
* Node Declaration
*/
struct node
{
int info;
struct node *next;
}*start;
/*
* Class Declaration
*/
class single_llist
{
public:
node* create_node(int);
void insert_begin();
void insert_pos();
void insert_last();
void delete_pos();
void sort();
void search();
void update();
void reverse();
void display();
single_llist()
{
start = NULL;
}
};
/*
* Main :contains menu
*/
main()
{
int choice, nodes, element, position, i;
single_llist sl;
start = NULL;
while (1)
{
cout<>choice;
switch(choice)
{
case 1:
cout<<\"Inserting Node at Beginning: \"<info = value;
temp->next = NULL;
return temp;
}
}
/*
* Inserting element in beginning
*/
void single_llist::insert_begin()
{
int value;
cout<<\"Enter the value to be inserted: \";
cin>>value;
struct node *temp, *p;
temp = create_node(value);
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
p = start;
start = temp;
start->next = p;
}
cout<<\"Element Inserted at beginning\"<>value;
struct node *temp, *s;
temp = create_node(value);
s = start;
while (s->next != NULL)
{
s = s->next;
}
temp->next = NULL;
s->next = temp;
cout<<\"Element Inserted at last\"<info<<\"->\";
temp = temp->next;
}
cout<<\"NULL\"<
Solution
ANSWER ::
ASSMUING THE TOTAL LINE IN CODE ARE 158*(INCLUDING COMMENTS)
SO...
PROGRAM STARTS WITH SPECIFING HEADER FILES AND GLOBAL VARIABLE
DECLARATION
THEN Node Declaration USING STRUCTURES,
THEN WE WANT TO DECLARE THE CLASS USING SINGLE LINKED LIST AND THE
PROTOTYPE IS PUBLIC
IN THE PUBLIC WE WANT TO CREATE THE NODE AS INTEGER DATATYPE
THE NODE CONSIST OF insert_begin();
insert_pos();-> INDICATES THE CURRENT POSSITION
insert_last();->INSERT AT LAST
delete_pos();->TO DELETE THE NUMBER AT CURRENT POSITION
sort();->START THE SORTING
search();->USED TO SEARCH
update();->UPDATE THE NODE
reverse();->REVERSE NUMBERS
display();->TO DISPLAY THE NODE
single_llist()->FIFO
WE ARE STARTING TAKING NULL VALUE
AND THEN TAKE USER DEFIND FUNCTION MAIN()
CREATE THE DATATYPES choice, nodes, element, position, i
OBJECT CREATION OF SLL IS SL
USING WHILE LOOP THE NODE INSERT AT THE BEGINING OR ENDING STAGE
WE ARE USING SWITCH CASES TO PERFORM SLL ON NODE
NODE CREATION AS
node *single_llist::create_node(int value)
ALSO DECLARE THE TEMP IS TAKEN AS NULL VALUE
INSERT THE ELEMENT AT THE BEGINING
USING IF CONDITION WE CAN INSERT THE NODE AT THE BEGINING
struct node *temp, *p;
temp = create_node(value);
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
p = start;
start = temp;
start->next = p;
AND THEN INSERT THE NODE AT THE LAST
struct node *temp, *s;
temp = create_node(value);
s = start;
while (s->next != NULL)
{
s = s->next;
}
temp->next = NULL;
s->next = temp;
USING WHILE LOOP WE ARE INSERTING THE NODE AT LAST
USING THIS BELLOW CODE WE CAN SEARCH THE ELEMENTS IN THE NODE
struct node *temp;
if (start == NULL)
{
cout<<\"The List is Empty\"<info<<\"->\";
temp = temp->next;
}
cout.
Doublylinklist
This document presents information on doubly linked lists including their representation, initialization, node creation, and various operations like insertion, deletion, and traversal. It discusses inserting and deleting nodes at the beginning or end of the list, as well as inserting before or after a specified node. Code examples are provided for initializing a doubly linked list and performing each operation.
L 17 ct1120
Class lecture of Data Structure and Algorithms and Python.
Stack, Queue, Tree, Python, Python Code, Computer Science, Data, Data Analysis, Machine Learning, Artificial Intellegence, Deep Learning, Programming, Information Technology, Psuedocide, Tree, pseudocode, Binary Tree, Binary Search Tree, implementation, Binary search, linear search, Binary search operation, real-life example of binary search, linear search operation, real-life example of linear search, example bubble sort, sorting, insertion sort example, stack implementation, queue implementation, binary tree implementation, priority queue, binary heap, binary heap implementation
Assignment-6 (2).docx
This document describes a program to implement recursive functions for a binary search tree (BST). It defines a node structure and specifies 9 recursive functions to insert, delete, find height, count leaf nodes, perform inorder traversal, find maximum/minimum elements, search, and find the kth smallest element of the BST. It provides sample code to insert 15 elements into the BST and then perform a series of operations like deletion, searching, finding heights/counts, and traversing to test the recursive functions.
Which of the following is not a high-speed Internet assess service.pdf
Which of the following is not a high-speed Internet assess service?
A. ADSL
B. G.Lite
C. PnP
D. G.DMT
Solution
Answer C is the correct answer. PnP is the Plug and Play standard developed by Microsoft for
the automatic recognition and configuration of PnP-compatible installed devices. Answers A, B,
and D are all variations of DSL types of services and are therefore valid types of high-speed
Internet access service offerings, making those answers incorrect..
Write a program to implement below operations with both singly and d.pdf
Write a program to implement below operations with both singly and doubly linked list. Use
inheritance to define singly linked list and doubly linked list. Add Node() Delete Node() Update
Node() Delete All() Size()
Solution
#include
using namespace std;
class List;
class Node
{
friend class List;
protected:
int Data;
Node *Link;
};
class List:public Node
{
friend class Node;
private:
Node *Start;
public:
List()
{
Start=NULL;
}
Node Insert(int x);
Node Delete(int &x);
void Display();
};
Node List::Insert(int x)
{
Node *New=new Node;
New->Data=x;
New->Link=Start;
Start=New;
return *this;
}
Node List::Delete(int &x)//deletes first node
{
Node *Del=Start;
Start=Start->Link;
delete Del;
return *this;
}
void List::Display()
{
Node *P=Start;
while(P!=NULL)
{
cout<Data<<\" \";
P=P->Link;
}
}
int main()
{
List L;
L.Insert(4);
L.Insert(64);
L.Insert(3);
L.Insert(90);
L.Insert(66);
L.Insert(13);
L.Display();
}
Double Linked List.
More Related Content
Similar to 1. Create the binary tree with 9 nodes (Figure 1) by using pointer-b.pdf
Write a C program that reads the words the user types at the command.pdf
Write a C program that reads the words the user types at the command prompt (using the \'int
argc, char * argv[] and store each unique letter in a Binary Search Tree. When a duplicate is
encountered do not store the letter again and instead keep track of the count in the tree. Once the
Binary Search tree has been created print out the tree both inorder and reverse order. Also print
the highest and lowest alphabetically letter in the tree if any.
Solution
# include
# include
# include
typedef struct BST {
int data;
struct BST *lchild, *rchild;
} node;
void insert(node *, node *);
void preorder(node *);
findMinimum(struct node* root)
findMaximum(struct node* root)
void reverseLevelOrder(struct node* root)
void main(int argc,char argv) {
char argv = \'N\';
int key;
node *new_node, *root, *tmp, *parent;
node *get_node();
root = NULL;
clrscr();
printf(\"\ Program For Binary Search Tree \");
do {
printf(\"\ 1.Create\");
printf(\"\ 2.Search\");
printf(\"\ 3.Recursive Traversals\");
printf(\"\ 4.Exit\");
printf(\"\ Enter your choice :\");
scanf(\"%d\", &argc);
switch (argc) {
case 1:
do {
new_node = get_node();
printf(\"\ Enter The Element \");
scanf(\"%d\", &new_node->data);
if (root == NULL) /* Tree is not Created */
root = new_node;
else
insert(root, new_node);
printf(\"\ Want To enter More Elements?(y/n)\");
argv= getch();
} while (argv == \'y\');
break;
case 2:
if (root == NULL)
printf(\"Tree Is Not Created\");
else {
printf(\"\ The Preorder display : \");
preorder(root);
}
break;
}
} while (argv != 4);
}
/*
Get new Node
*/
node *get_node() {
node *temp;
temp = (node *) malloc(sizeof(node));
temp->lchild = NULL;
temp->rchild = NULL;
return temp;
}
/*
This function is for creating a binary search tree
*/
void insert(node *root, node *new_node) {
if (new_node->data < root->data) {
if (root->lchild == NULL)
root->lchild = new_node;
return newNode(key);
else
insert(root->lchild, new_node);
}
if (new_node->data > root->data) {
if (root->rchild == NULL)
root->rchild = new_node;
return newNode(key);
else
insert(root->rchild, new_node);
}
}
if (key == node->key)
{
(node->count)++;
return node;
}
/*
This function displays the tree in preorder fashion
*/
void preorder(node *temp) {
if (temp != NULL) {
printf(\"%d\", temp->data);
preorder(temp->lchild);
preorder(temp->rchild);
}
}
// Returns maximum value in a given Binary Tree
int findMaximum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MAXIMUM;
// Return maximum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMaximum (root->lchild);
int rres = findMaximum (root->rchild);
if (lres > res)
res = lres;
if (rres > res)
res = rres;
return res;
}
// Returns minimum value in a given Binary Tree
int findMinimum(struct node* root)
{
// Base case
if (root == NULL)
return INT_MINIMUM;
// Return minimum of 3 values:
// 1) Root\'s data 2) Max in Left Subtree
// 3) Max in right subtree
int res = root->data;
int lres = findMinimum(r.
Task4output.txt 2 5 9 13 15 10 1 0 3 7 11 14 1.docx
Task4/output.txt
2 5 9 13
15 10 1 0
3 7 11 14
12 8 6 4
2 5 1 0
3 7 6 4
12 8 9 13
15 10 11 14
0 1 2 5
7 6 4 3
8 9 12 13
15 14 11 10
0 1 2 3
7 6 4 5
8 9 11 10
15 14 12 13
0 1 2 3
7 6 5 4
8 9 10 11
15 14 13 12
Task4/task4.cpp
#include <cstdio>
#include <iostream>
using namespace std;
#define MAXROW 4
#define MAXCOL 4
void bidirection_bbsort(int a[], int n, bool ascending)
{
int i,j, temp;
//This is the original bubble sort
// Make SMALL change such that it handles descending sorting too
for (i = n-1; i >= 1; i--) {
for (j = 1; j <= i; j++) {
if (a[j-1] > a[j]) {
temp = a[j-1] ;
a[j-1] = a[j] ;
a[j] = temp ;
}
}
}
}
void column_sort(int m[][MAXCOL], int col)
{
//Use the bidirection_bbsort() once it is implemented
// No need to invent / write a new sorting logic
}
void print_matrix(int m[][MAXCOL], int nRow, int nCol)
{
int i, j;
for (i = 0; i < nRow; i++){
for (j = 0; j < nCol; j++){
printf("%2d ", m[i][j]); //use printf for easier formatting
//cout << setw(2) << m[i][j] << " "; //equivalent c++ output formatting
}
cout << endl;
}
cout << endl;
}
void phase_A(int mat[][MAXCOL], int nRow, int nCol)
{
int i;
bool order = true;
for (i = 0; i < nRow; i++, order = !order){
bidirection_bbsort(mat[i], nCol, order);
}
}
void phase_B(int mat[][MAXCOL], int nRow, int nCol)
{
int i;
for (i = 0; i < nCol; i++){
column_sort(mat, i);
}
}
void magic_sort(int mat[][MAXCOL], int nRow, int nCol)
{
int i;
for (i = 1; i < nRow; i *= 2){
phase_A(mat, nRow, nCol);
print_matrix(mat, nRow, nCol);
phase_B(mat, nRow, nCol);
print_matrix(mat, nRow, nCol);
}
phase_A(mat, nRow, nCol);
print_matrix(mat, nRow, nCol);
}
int main()
{
int arr[] = { 5, 12, 6, 7, 9, 6, 1};
int i;
int mat[MAXROW][MAXCOL] = {
{5, 2, 13, 9},
{10, 1, 15, 0},
{7, 3, 11, 14},
{12, 8, 4, 6}
};
magic_sort(mat, 4, 4);
return 0;
}
Task3/task3.cpp
#include <cstdio>
#include <iostream>
using namespace std;
struct Point {
int X, Y;
};
void sort(Point a[], int n)
{
//You can adapt any of the insertion / selection / bubble sort
}
int main()
{
int i;
Point ptArray[5] = { {11, 34}, {5, 73}, {11, 19}, {13, 5}, {11,
68}};
sort(ptArray, 5);
//The output should match the order given in question
for (i = 0; i < 5; i++){
printf("(%d, %d)\n", ptArray[i].X, ptArray[i].Y);
}
return 0;
}
Task2/sample_length_3.txt
***
%%%
%##
%$$
##%
$$%
Task2/sample_length_5.txt
***%%
***##
***$$
%***%
%%***
%%%%%
%%%##
%%%$$
%%##%
%%$$%
%##%%
%####
%##$$
%$$%%
%$$##
%$$$$
##***
##%%%
##%##
##%$$
####%
##$$%
$$***
$$%%%
$$%.
pleaase I want manual solution forData Structures and Algorithm An.pdf
pleaase I want manual solution for
Data Structures and Algorithm Analysis in C++, Third Edition
By Clifford A. Shaffer
because my question from this book.page270 ,question 7.4
The implementation for Mergesort given in Section 7.4 takes an array as input and sorts that
array. At the beginning of Section 7.4 there is a simple pseudocode implementation for sorting a
linked list using Mergesort. Implement both a linked list-based version of Mergesort and the
array-based version of Mergesort, and compare and analyze their running times.
Solution
Linked list:
#include
#include
struct node
{
int data;
struct node* next;
};
struct node* SortedMerge(struct node* a, struct node* b);
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef);
void MergeSort(struct node** headRef)
{
struct node* head = *headRef;
struct node* a;
struct node* b;
if ((head == NULL) || (head->next == NULL))
{
return;
}
FrontBackSplit(head, &a, &b);
MergeSort(&a);
MergeSort(&b);
*headRef = SortedMerge(a, b);
}
struct node* SortedMerge(struct node* a, struct node* b)
{
struct node* result = NULL;
if (a == NULL)
return(b);
else if (b==NULL)
return(a);
if (a->data <= b->data)
{
result = a;
result->next = SortedMerge(a->next, b);
}
else
{
result = b;
result->next = SortedMerge(a, b->next);
}
return(result);
}
void FrontBackSplit(struct node* source,
struct node** frontRef, struct node** backRef)
{
struct node* fast;
struct node* slow;
if (source==NULL || source->next==NULL)
{
*frontRef = source;
*backRef = NULL;
}
else
{
slow = source;
fast = source->next;
while (fast != NULL)
{
fast = fast->next;
if (fast != NULL)
{
slow = slow->next;
fast = fast->next;
}
}
*frontRef = source;
*backRef = slow->next;
slow->next = NULL;
}
}
void printList(struct node *node)
{
while(node!=NULL)
{
printf(\"%d \", node->data);
node = node->next;
}
}
void push(struct node** head_ref, int new_data)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_data;
new_node->next = (*head_ref);
(*head_ref) = new_node;
}
int main()
{
struct node* res = NULL;
struct node* a = NULL;
push(&a, 15);
push(&a, 10);
push(&a, 5);
push(&a, 20);
push(&a, 3);
push(&a, 2);
MergeSort(&a);
printf(\"\ Sorted Linked List is: \ \");
printList(a);
getchar();
return 0;
}
Time complexity:o(nlogn)
Array :
#include
#include
void merge(int arr[], int l, int m, int r)
{
int i, j, k;
int n1 = m - l + 1;
int n2 = r - m;
int L[n1], R[n2];
for (i = 0; i < n1; i++)
L[i] = arr[l + i];
for (j = 0; j < n2; j++)
R[j] = arr[m + 1+ j];
i = 0; // Initial index of first subarray
j = 0;
k = l;
while (i < n1 && j < n2)
{
if (L[i] <= R[j])
{
arr[k] = L[i];
i++;
}
else
{
arr[k] = R[j];
j++;
}
k++;
}
while (i < n1)
{
arr[k] = L[i];
i++;
k++;
}
while (j < n2)
{
arr[k] = R[j];
j++;
k++;
}
}
void mergeSort(int arr[], int l, int r)
{
if (l < r)
{
int m = l+(r-l)/2;
// Sort first and second halves
mergeSort(arr, l, m);
mergeSort(arr, m+1, r);
merge(arr, l, m, r);
}
}
void printArray(int A[], i.
#include iostream using namespace std; const int nil = 0; cl.docx
The program implements a binary search tree to store 20 integers input by the user. It performs level order, preorder, inorder and postorder traversals of the tree, printing the value and level of each node. It also outputs the number of leaf nodes, nodes with one child, and nodes with two children. Finally, it calculates and prints the maximum and minimum leaf levels and checks if the tree is balanced.
I have C++ question that I do not know how to do, Can you teach me t.pdf
I have C++ question that I do not know how to do, Can you teach me this question:
Draw a CLASS diagram for Binary Search Tree (BTS) :
can you explain me each step, thank you
Solution
//program to convert Binary Tree to Binary Search Tree
#include
#include
// A binary tree node structure
struct node
{
int data;
struct node *left;
struct node *right;
};
void storeInorder (struct node* node, int inorder[], int *index_ptr)
{
// Base Case
if (node == NULL)
return;
// first store the left subtree
storeInorder (node->left, inorder, index_ptr);
// Copy the root\'s data
inorder[*index_ptr] = node->data;
(*index_ptr)++; // increase index for next entry
// finally store the right subtree
storeInorder (node->right, inorder, index_ptr);
}
/* A helper function to count nodes in a Binary Tree */
int countNodes (struct node* root)
{
if (root == NULL)
return 0;
return countNodes (root->left) +
countNodes (root->right) + 1;
}
// Following function is needed for library function qsort()
int compare (const void * a, const void * b)
{
return ( *(int*)a - *(int*)b );
}
/* A helper function that copies contents of arr[] to Binary Tree.
This functon basically does Inorder traversal of Binary Tree and
one by one copy arr[] elements to Binary Tree nodes */
void arrayToBST (int *arr, struct node* root, int *index_ptr)
{
// Base Case
if (root == NULL)
return;
/* first update the left subtree */
arrayToBST (arr, root->left, index_ptr);
/* Now update root\'s data and increment index */
root->data = arr[*index_ptr];
(*index_ptr)++;
/* finally update the right subtree */
arrayToBST (arr, root->right, index_ptr);
}
// This function converts a given Binary Tree to BST
void binaryTreeToBST (struct node *root)
{
// base case: tree is empty
if(root == NULL)
return;
/* Count the number of nodes in Binary Tree so that
we know the size of temporary array to be created */
int n = countNodes (root);
// Create a temp array arr[] and store inorder traversal of tree in arr[]
int *arr = new int[n];
int i = 0;
storeInorder (root, arr, &i);
// Sort the array using library function for quick sort
qsort (arr, n, sizeof(arr[0]), compare);
// Copy array elements back to Binary Tree
i = 0;
arrayToBST (arr, root, &i);
// delete dynamically allocated memory to avoid meory leak
delete [] arr;
}
/* Utility function to create a new Binary Tree node */
struct node* newNode (int data)
{
struct node *temp = new struct node;
temp->data = data;
temp->left = NULL;
temp->right = NULL;
return temp;
}
/* Utility function to print inorder traversal of Binary Tree */
void printInorder (struct node* node)
{
if (node == NULL)
return;
/* first recur on left child */
printInorder (node->left);
/* then print the data of node */
printf(\"%d \", node->data);
/* now recur on right child */
printInorder (node->right);
}
/* Driver function to test above functions */
int main()
{
struct node *root = NULL;
/* Constructing tree given in the above figure
10
/ \\
30 15
/ \\
20 5 */
root = newNode(10);
root->left = newNode(30.
Compiler Design Unit 3
The document discusses code generation from intermediate code represented as a directed acyclic graph (DAG). It describes algorithms for constructing a DAG from basic blocks of code and generating optimal machine code from the DAG. Specifically:
1) It presents an algorithm to construct a DAG from basic blocks by creating nodes for variables, operators, and constants and connecting them based on the operations.
2) It explains that the DAG can be used to detect common subexpressions and eliminate unnecessary assignments.
3) An algorithm is provided to generate machine code from the DAG by rearranging operations to obtain an optimal computation sequence.
4) Labeling algorithms are introduced to number nodes in a tree to minimize register usage during code generation
How to build a Linked List that can insert any type of data. For exa.pdf
How to build a Linked List that can insert any type of data. For example: SLinkedList abc1;
SLinkedList abc2; SLinkedlist abc3; Please answer in C plus plus, you don\'t need to develop all
function, just insert data is enough.
Thank you.
Solution
#include
#include
#define LEFT 2
#define RIGHT 3
typedef struct linked_list
{
double data;
struct linked_list *next;
}node;//node declaration for single linked list
/*function prototype declaration*/
void insertion(node **,double);
void erase(node **,node **);
//void left_or_right(node **,node **,int);
node *makenode(double);
void show(node **,node **);
/*main*/
int main()
{
system(\"clear\");
char choice;
double item;
node *start=NULL,*prev=NULL;
do
{
printf(\"\ ===========================\ \\tMENU\
===========================\ \\t1.Insert\ \\t2.Exit\ Enter your choice :: \");
scanf(\"\ %c\",&choice);
switch(choice)
{
case \'1\':
printf(\"\ Enter item :: \");
scanf(\"%lf\",&item);
insertion(&start,item);//insert function calling
show(&start,&prev);
break;
case \'2\':
erase(&prev,&start);
printf(\"\ You are exited from the whole program.\ \ \");
exit(1);
default:
printf(\"\ \\tWrong Choice\ \");
}
}
while(choice!=\'2\');
return 0;
}
void show(node **start,node **prev)/*this function displays the whole linked list*/
{
if((*start)!=NULL)
{
printf(\"\ \ X <- \");
node *temp=NULL,*p=*prev,*q=NULL;
while(p!=NULL)
{
if(temp==NULL)
{
temp=makenode(p->data);
}
else
{
q=makenode(p->data);
q->next=temp;
temp=q;
}
p=p->next;
}
while(temp!=NULL)
{
printf(\"%.0lf <- \",temp->data);
q=temp;
temp=temp->next;
free(q);
q=NULL;
}
printf(\"\\b| \");
p=*start;
while(p!=NULL)
{
if(p==*start)
{
printf(\"%.0lf |-> \",p->data);
}
else
{
printf(\"%.0lf -> \",p->data);
}
p=p->next;
}
printf(\" X \ \ \");
}
else
{
printf(\"\ \ \\tEmpty Linked List\ \ \");
}
}
void insertion(node **start,double item)//this function inserts a new node in the linked list
{
node *temp=makenode(item),*p=NULL;
if(*start==NULL)
{
*start=temp;
}
else
{
p=*start;
while(p->next!=NULL)
{
p=p->next;
}
p->next=temp;
}
}
node *makenode(double item)
{
node *temp=NULL;
temp=(node *)malloc(sizeof(node));
if(temp==NULL)
{
printf(\"\ Dynamic memory allocation failed.\ \");
exit(0);
}
temp->data=item;
temp->next=NULL;
}
void erase(node **prev,node **start)//this function deletes all nodes of the linked list when the
program terminates
{
node *p=NULL;
while(*start!=NULL)
{
p=*start;
*start=(*start)->next;
free(p);
p=NULL;
}
while(*prev!=NULL)
{
p=*prev;
*prev=(*prev)->next;
free(p);
p=NULL;
}
}.
Please write the C++ code that would display the exact same output a.pdf
Please write the C++ code that would display the exact same output as provided. Thank you.
main.cpp
#include "TreeNode.h"
//GIVEN
void inorderTraversal(TreeNode * root);
//TODO
TreeNode * search(TreeNode * node,int data);
//GIVEN
void insert(TreeNode * node,int data);
//GIVEN
bool isNull(TreeNode * node){
return node==nullptr;
}
int main() {
// create the root, gets set to null
TreeNode * root;
// create the roor and set the data of root to 5
root= new TreeNode(5);
//create two additional nodes with data values 10 and 3
// these will go to the right and left of root respectively
TreeNode * ten= new TreeNode(10);
TreeNode * three= new TreeNode(3);
//connect ten to the right of root (which has data 5)
root->setRight(ten);
//connect three to the left of root (which has data 5)
root->setLeft(three);
// note this can also be done as
//root.setRight(new TreeNode(10));
//root.setLeft(new TreeNode(3);)
// add two more nodes
//the first has data value 7. So to keep the tree in insorted order, it should get attached as the
left node of ten
// the second has data value 4. So to keep the tree in insorted order, it should get attached as the
right node of three
ten->addLeft(7);
three->addRight(4);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
std::cout<<"**************************************\n";
std::cout<<"Searching for Node \n";
TreeNode* result = search(root,4);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<4<<"\n";
result = search(root,1);
if (result!=nullptr){
std::cout<<"Found "<getData()<<"\n";
}
else
std::cout<<"Not Found "<<1<<"\n";
std::cout<<"**************************************\n";
std::cout<<"Inserting 6\n";
insert(root,6);
std::cout<<"**************************************\n";
std::cout<<"Printing the Inorder Traversal\n";
inorderTraversal(root);
}
// uses recursion
void inorderTraversal(TreeNode * node){
// exit case
if (isNull(node)) return;
if (node->isLeaf()){
std::cout<<"Printing Leaf Node "<getData()<<"\n";
return;}
// reached a node with no left, so print the node and travel right
if (!isNull(node->getLeft()))
// if there is a left path, then travel further on that
inorderTraversal(node->getLeft());
std::cout<<"Printing Node "<getData()<<"\n";
// save and travel the right path of the current node being processed
inorderTraversal(node->getRight());
}
// uses recursion
//TODO
TreeNode * search(TreeNode * node, int data){
// if the node is null return the null ptr
//if this nodes data equals the search date return found
// if not, if the left tree exists and search data less than
//this nodes data return the result of recursive all to search with left pointer
// if no left tree, but right tree exists and search data greater than
//this nodes data return the result of recursive all to search with right pointer
// if both above conditions not true return null ptr
}
//uses recursion
void insert(TreeNode * node,int .
Please read the comment ins codeExpressionTree.java-------------.pdf
Please read the comment ins code
ExpressionTree.java
----------------------------------
/**
* This is the class for Expression Tree.
* Used to create Expression Tree and Evaluate it
*/
/**
* Following logic is used to construct a Tree
* Here we use stack for Preparing Tree
* Loop through given Expression String
* If Character is Operand , Create node and push to stack
* If Character is Operator then
* 1)Create Node for Operator
* 2)Pop 2 nodes from Stack and Made
* OpretorNode--> left == first node pop
* OpretorNode--> right == second node pop
* At the end of creation of Expression Tree, Stack have only one node , which is root of
Expression tree
*/
/** Class ExpressionTree **/
class ExpressionTree
{
/** class TreeNode
* Stored Character ==> Digit(0..9) or a Operator +,-,*,/
* Left Node and Right Node
*
* **/
class TreeNode
{
char data;
TreeNode left, right;
/** constructor **/
public TreeNode(char data)
{
this.data = data;
this.left = null;
this.right = null;
}
}
/** class StackNode **/
class StackNode
{
TreeNode treeNode;
StackNode next;
/** constructor **/
public StackNode(TreeNode treeNode)
{
this.treeNode = treeNode;
next = null;
}
}
private static StackNode top;
/** constructor
* Constructor takes input string like \"+-+7*935*82*625\"
* Input should be in Prefix notation
* **/
public ExpressionTree(String expression)
{
top = null;
//Call Method for prepare expression tree
buildTree(expression);
}
/** function to clear tree **/
public void clear()
{
top = null;
}
/** function to push a node **/
private void push(TreeNode ptr)
{
if (top == null)
top = new StackNode(ptr);
else
{
StackNode nptr = new StackNode(ptr);
nptr.next = top;
top = nptr;
}
}
/** function to pop a node
* When it find operator pop 2 elements from Stack
*
* **/
private TreeNode pop()
{
if (top == null)
throw new RuntimeException(\"Underflow\");
else
{
TreeNode ptr = top.treeNode;
top = top.next;
return ptr;
}
}
/** function to get top node **/
private TreeNode peek()
{
return top.treeNode;
}
/** function to insert character **/
private void insert(char val)
{
try
{
//If Operand , Create node and push to Stack
if (isDigit(val))
{
TreeNode nptr = new TreeNode(val);
push(nptr);
}
//If Operator , Create node and popup 2 elements and make them its right and left
else if (isOperator(val))
{
TreeNode nptr = new TreeNode(val);
nptr.left = pop();
nptr.right = pop();
push(nptr);
}
}
catch (Exception e)
{
System.out.println(\"Invalid Expression\");
}
}
/** function to check if digit **/
private boolean isDigit(char ch)
{
return ch >= \'0\' && ch <= \'9\';
}
/** function to check if operator **/
private boolean isOperator(char ch)
{
return ch == \'+\' || ch == \'-\' || ch == \'*\' || ch == \'/\';
}
/** function to convert character to digit **/
private int toDigit(char ch)
{
return ch - \'0\';
}
/** function to build tree from input */
public void buildTree(String eqn)
{
for (int i = eqn.length() - 1; i >= 0; i--)
insert(eqn.charAt(i));
}
/** function to evaluate tree */
public dou.
pointers
This document outlines Chapter 7 on pointers from a C programming textbook. It introduces pointers, how to declare and initialize pointer variables, pointer operators like & and *, calling functions by reference using pointers, const pointers, bubble sorting using pointers, pointer arithmetic and expressions, the relationship between pointers and arrays, arrays of pointers, and a case study on simulating a card shuffling and dealing program using pointers.
-- Task 2- Debugging a program with stacks- queues- and doubly-linked.docx
/* Task 2: Debugging a program with stacks, queues, and doubly-linked lists There are a number of errors in the following program. All errors are located in main() and structure definitions. Function declarations and definitions are correct! Locate all errors, fix them (as shown below), run the program and save its output as a comment at the end of the source file. Example: int num = 10; int *ptr; num = &ptr; // <== Error: Comment the line and write the correct line below // Write a short justification where appropriate // num = &ptr; // Error #1 ptr = # Name: */ #include #include #include #include #define DUMMY_TRAILER '\177' // octal ASCII code of the // last character in the ASCII table #define NUM_CITIES 10 typedef struct { char name[12]; int temperature[5]; } CITY; // Stack and Queue Node typedef struct node NODE; struct node { CITY city; node *next; }; // Doubly Linked List Node typedef struct d_node D_NODE; struct d_node { CITY city; NODE *forw; NODE *back; }; // Stack Functions NODE *push(NODE *stack, const CITY *pStu); NODE *pop(NODE **stack); // Queue Functions void enqueue(NODE **queue, NODE **rear, const CITY *pStu); NODE *dequeue(NODE **queue, NODE **rear); // Doubly Linked List Functions D_NODE *init_list(void); int insert(D_NODE *list, const CITY *pStu); void traverse_forw(D_NODE *list); void traverse_back(D_NODE *list); // Other Functions void printCity(const CITY *pCity); int main (void) { CITY cList[NUM_CITIES] = { {"Cupertino", {88, 89, 87, 85, 89}}, {"Flagstaff", {81, 80, 88, 89, 89}}, {"Los Angeles", {87, 88, 89, 89, 90}}, {"Philadelphia", {96, 99, 99, 90, 95}}, {"Phoenix", {106, 109, 109, 100, 105}}, {"Portland", {89, 90, 85, 89, 90}}, {"Reno", {108, 105, 109, 100, 108}}, {"Salem", {85, 90, 85, 89, 90}}, {"Tucson", {107, 100, 109, 100, 108}}, {"Yreka", {101, 109, 100, 108, 109}} }; NODE *stack = NULL; NODE *top = NULL; NODE *queue = NULL, *rear = NULL; NODE *front; D_NODE *list; list = init_list(); // build stack and queue with data from an array of CITY structures srand((unsigned int)time(NULL)); int count = rand() % 10; for ( int n = 0; n < count; n++) { int i = rand() % NUM_CITIES; int duplicate = insert(list, &cList[i]); if(duplicate) { // already in the list! push(stack, &cList[i]); enqueue(&queue, &rear, cList[i]); } } // display list printf("\nLIST contents (forwards):\n"); traverse_forw(list); printf("\nLIST contents (backwards):\n"); traverse_back(list); // display stack if (top) { printf("\nSTACK contents from top to bottom:\n"); while ((top = pop(stack))) { printCity(top->city); } } else printf ("Empty Stack!\n"); // display queue if (front) { printf("\nQUEUE contents from front to rear:\n"); while ((front = dequeue( queue, rear))) { printCity(front->city); } } else printf ("Empty Queue!\n"); return 0; } /*************************************************** Displays the fileds of a CIS_CLASS structure Pre pCls - a pointer to a CIS_CLASS structure Post */ void printCity(const CITY *pCity) { printf("%-20s %3d\n",.
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
pointers
This document outlines pointers and related concepts in C programming. It begins with an introduction to pointers, noting they are powerful but difficult to master. It then covers pointer variable declarations and initialization, the pointer operators & and *, calling functions by reference using pointers, and using const with pointers. Later sections discuss pointer expressions and arithmetic, the relationship between pointers and arrays, arrays of pointers, and pointers to functions. The document provides examples to illustrate key pointer concepts.
Write a program to decipher messages encoded using a prefix code, gi.pdf
Write a program to decipher messages encoded using a prefix code, given the encoding tree.
Such codes are widely used in applications that compress data, including JPEG for images, MP3
for music, and DivX for video. using Huffman Trees (Prefix Binary Trees) c++
Solution
#include #include #include #include // for CHAR_BIT #include #include const int
UniqueSymbols = 1 << CHAR_BIT; const char* SampleString = \"this is an example for
huffman encoding\"; typedef std::vector HuffCode; typedef std::map HuffCodeMap; class
INode { public: const int f; virtual ~INode() {} protected: INode(int f) : f(f) {} };
class InternalNode : public INode { public: INode *const left; INode *const right;
InternalNode(INode* c0, INode* c1) : INode(c0->f + c1->f), left(c0), right(c1) {}
~InternalNode() { delete left; delete right; } }; class LeafNode :
public INode { public: const char c; LeafNode(int f, char c) : INode(f), c(c) {} };
struct NodeCmp { bool operator()(const INode* lhs, const INode* rhs) const { return lhs->f
> rhs->f; } }; INode* BuildTree(const int (&frequencies)[UniqueSymbols]) {
std::priority_queue, NodeCmp> trees; for (int i = 0; i < UniqueSymbols; ++i) {
if(frequencies[i] != 0) trees.push(new LeafNode(frequencies[i], (char)i)); }
while (trees.size() > 1) { INode* childR = trees.top(); trees.pop();
INode* childL = trees.top(); trees.pop(); INode* parent = new
InternalNode(childR, childL); trees.push(parent); } return trees.top(); } void
GenerateCodes(const INode* node, const HuffCode& prefix, HuffCodeMap& outCodes) {
if (const LeafNode* lf = dynamic_cast(node)) { outCodes[lf->c] = prefix; }
else if (const InternalNode* in = dynamic_cast(node)) { HuffCode leftPrefix =
prefix; leftPrefix.push_back(false); GenerateCodes(in->left, leftPrefix,
outCodes); HuffCode rightPrefix = prefix; rightPrefix.push_back(true);
GenerateCodes(in->right, rightPrefix, outCodes); } } int main() { // Build
frequency table int frequencies[UniqueSymbols] = {0}; const char* ptr =
SampleString; while (*ptr != \'\\0\') ++frequencies[*ptr++]; INode* root =
BuildTree(frequencies); HuffCodeMap codes; GenerateCodes(root, HuffCode(),
codes); delete root; for (HuffCodeMap::const_iterator it = codes.begin(); it !=
codes.end(); ++it) { std::cout << it->first << \" \"; std::copy(it-
>second.begin(), it->second.end(), std::ostream_iterator(std::cout)); std::cout
<< std::endl; } return 0; }.
Unit 1 LINEAR DATA STRUCTURES
This document discusses linear data structures and linked lists. It begins with an introduction to data structures and defines them as a way to organize and store data and relationships between data. It then discusses list abstract data types (ADTs) and their operations. The document focuses on linked list representations of lists and covers singly linked lists, doubly linked lists, and circular linked lists. It describes the nodes that make up each type of linked list and their operations like insertion, deletion, and searching. Finally, it provides an example of using linked lists to represent polynomial equations and operations like addition on polynomials.
Final ds record
The program implements operations on a stack using an array. It includes functions for push(), pop(), and display(). Push inserts an element into the stack if not full. Pop removes an element if not empty. Display prints the stack elements using a for loop. The main() uses a switch case to call the functions based on user input until exit is chosen.
take the following code and give details of what each line of code i.pdf
take the following code and give details of what each line of code is doing
#include
#include
#include
using namespace std;
/*
* Node Declaration
*/
struct node
{
int info;
struct node *next;
}*start;
/*
* Class Declaration
*/
class single_llist
{
public:
node* create_node(int);
void insert_begin();
void insert_pos();
void insert_last();
void delete_pos();
void sort();
void search();
void update();
void reverse();
void display();
single_llist()
{
start = NULL;
}
};
/*
* Main :contains menu
*/
main()
{
int choice, nodes, element, position, i;
single_llist sl;
start = NULL;
while (1)
{
cout<>choice;
switch(choice)
{
case 1:
cout<<\"Inserting Node at Beginning: \"<info = value;
temp->next = NULL;
return temp;
}
}
/*
* Inserting element in beginning
*/
void single_llist::insert_begin()
{
int value;
cout<<\"Enter the value to be inserted: \";
cin>>value;
struct node *temp, *p;
temp = create_node(value);
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
p = start;
start = temp;
start->next = p;
}
cout<<\"Element Inserted at beginning\"<>value;
struct node *temp, *s;
temp = create_node(value);
s = start;
while (s->next != NULL)
{
s = s->next;
}
temp->next = NULL;
s->next = temp;
cout<<\"Element Inserted at last\"<info<<\"->\";
temp = temp->next;
}
cout<<\"NULL\"<
Solution
ANSWER ::
ASSMUING THE TOTAL LINE IN CODE ARE 158*(INCLUDING COMMENTS)
SO...
PROGRAM STARTS WITH SPECIFING HEADER FILES AND GLOBAL VARIABLE
DECLARATION
THEN Node Declaration USING STRUCTURES,
THEN WE WANT TO DECLARE THE CLASS USING SINGLE LINKED LIST AND THE
PROTOTYPE IS PUBLIC
IN THE PUBLIC WE WANT TO CREATE THE NODE AS INTEGER DATATYPE
THE NODE CONSIST OF insert_begin();
insert_pos();-> INDICATES THE CURRENT POSSITION
insert_last();->INSERT AT LAST
delete_pos();->TO DELETE THE NUMBER AT CURRENT POSITION
sort();->START THE SORTING
search();->USED TO SEARCH
update();->UPDATE THE NODE
reverse();->REVERSE NUMBERS
display();->TO DISPLAY THE NODE
single_llist()->FIFO
WE ARE STARTING TAKING NULL VALUE
AND THEN TAKE USER DEFIND FUNCTION MAIN()
CREATE THE DATATYPES choice, nodes, element, position, i
OBJECT CREATION OF SLL IS SL
USING WHILE LOOP THE NODE INSERT AT THE BEGINING OR ENDING STAGE
WE ARE USING SWITCH CASES TO PERFORM SLL ON NODE
NODE CREATION AS
node *single_llist::create_node(int value)
ALSO DECLARE THE TEMP IS TAKEN AS NULL VALUE
INSERT THE ELEMENT AT THE BEGINING
USING IF CONDITION WE CAN INSERT THE NODE AT THE BEGINING
struct node *temp, *p;
temp = create_node(value);
if (start == NULL)
{
start = temp;
start->next = NULL;
}
else
{
p = start;
start = temp;
start->next = p;
AND THEN INSERT THE NODE AT THE LAST
struct node *temp, *s;
temp = create_node(value);
s = start;
while (s->next != NULL)
{
s = s->next;
}
temp->next = NULL;
s->next = temp;
USING WHILE LOOP WE ARE INSERTING THE NODE AT LAST
USING THIS BELLOW CODE WE CAN SEARCH THE ELEMENTS IN THE NODE
struct node *temp;
if (start == NULL)
{
cout<<\"The List is Empty\"<info<<\"->\";
temp = temp->next;
}
cout.
Doublylinklist
This document presents information on doubly linked lists including their representation, initialization, node creation, and various operations like insertion, deletion, and traversal. It discusses inserting and deleting nodes at the beginning or end of the list, as well as inserting before or after a specified node. Code examples are provided for initializing a doubly linked list and performing each operation.
L 17 ct1120
Class lecture of Data Structure and Algorithms and Python.
Stack, Queue, Tree, Python, Python Code, Computer Science, Data, Data Analysis, Machine Learning, Artificial Intellegence, Deep Learning, Programming, Information Technology, Psuedocide, Tree, pseudocode, Binary Tree, Binary Search Tree, implementation, Binary search, linear search, Binary search operation, real-life example of binary search, linear search operation, real-life example of linear search, example bubble sort, sorting, insertion sort example, stack implementation, queue implementation, binary tree implementation, priority queue, binary heap, binary heap implementation
Assignment-6 (2).docx
This document describes a program to implement recursive functions for a binary search tree (BST). It defines a node structure and specifies 9 recursive functions to insert, delete, find height, count leaf nodes, perform inorder traversal, find maximum/minimum elements, search, and find the kth smallest element of the BST. It provides sample code to insert 15 elements into the BST and then perform a series of operations like deletion, searching, finding heights/counts, and traversing to test the recursive functions.
Similar to 1. Create the binary tree with 9 nodes (Figure 1) by using pointer-b.pdf (20)
Write a C program that reads the words the user types at the command.pdf
Write a C program that reads the words the user types at the command.pdf
Task4output.txt 2 5 9 13 15 10 1 0 3 7 11 14 1.docx
Task4output.txt 2 5 9 13 15 10 1 0 3 7 11 14 1.docx
pleaase I want manual solution forData Structures and Algorithm An.pdf
pleaase I want manual solution forData Structures and Algorithm An.pdf
#include iostream using namespace std; const int nil = 0; cl.docx
#include iostream using namespace std; const int nil = 0; cl.docx
I have C++ question that I do not know how to do, Can you teach me t.pdf
I have C++ question that I do not know how to do, Can you teach me t.pdf
How to build a Linked List that can insert any type of data. For exa.pdf
How to build a Linked List that can insert any type of data. For exa.pdf
Please write the C++ code that would display the exact same output a.pdf
Please write the C++ code that would display the exact same output a.pdf
Please read the comment ins codeExpressionTree.java-------------.pdf
Please read the comment ins codeExpressionTree.java-------------.pdf
-- Task 2- Debugging a program with stacks- queues- and doubly-linked.docx
-- Task 2- Debugging a program with stacks- queues- and doubly-linked.docx
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
Data Structures and Agorithm: DS 14 Binary Expression Tree.pptx
Write a program to decipher messages encoded using a prefix code, gi.pdf
Write a program to decipher messages encoded using a prefix code, gi.pdf
take the following code and give details of what each line of code i.pdf
take the following code and give details of what each line of code i.pdf
More from thangarajarivukadal
Which of the following is not a high-speed Internet assess service.pdf
Which of the following is not a high-speed Internet assess service?
A. ADSL
B. G.Lite
C. PnP
D. G.DMT
Solution
Answer C is the correct answer. PnP is the Plug and Play standard developed by Microsoft for
the automatic recognition and configuration of PnP-compatible installed devices. Answers A, B,
and D are all variations of DSL types of services and are therefore valid types of high-speed
Internet access service offerings, making those answers incorrect..
Write a program to implement below operations with both singly and d.pdf
Write a program to implement below operations with both singly and doubly linked list. Use
inheritance to define singly linked list and doubly linked list. Add Node() Delete Node() Update
Node() Delete All() Size()
Solution
#include
using namespace std;
class List;
class Node
{
friend class List;
protected:
int Data;
Node *Link;
};
class List:public Node
{
friend class Node;
private:
Node *Start;
public:
List()
{
Start=NULL;
}
Node Insert(int x);
Node Delete(int &x);
void Display();
};
Node List::Insert(int x)
{
Node *New=new Node;
New->Data=x;
New->Link=Start;
Start=New;
return *this;
}
Node List::Delete(int &x)//deletes first node
{
Node *Del=Start;
Start=Start->Link;
delete Del;
return *this;
}
void List::Display()
{
Node *P=Start;
while(P!=NULL)
{
cout<Data<<\" \";
P=P->Link;
}
}
int main()
{
List L;
L.Insert(4);
L.Insert(64);
L.Insert(3);
L.Insert(90);
L.Insert(66);
L.Insert(13);
L.Display();
}
Double Linked List.
Which of the following describes silver A material that has a low r.pdf
Which of the following describes silver? A material that has a low resistance and allows
charges to move freely A material that has a high resistance and allows charges to move freely
A material that has a low resistance and prevents charges from moving freely A material that
has a high resistance and prevents charges from moving freely
Solution
silver is good conductor of heat
so it has low resistance and high conductivity and allows changes to move freely
so option a is correct.
why dont most other types of bacteria produce ulcers ( like helico.pdf
why don\'t most other types of bacteria produce ulcers ( like helicobacter pylori bacteria)
Solution
helicobacter is a chronic inhabitant usually persists for lifelong(unless treated) in gastric mucosa.
Helicobacter can capable of staying for longer in host so it can able to modulate the localized
host tissue by producing cytokinines. these cytokinines are plays important role in ulcer
pathogenesis. bacterial virulence factors cytotoxin-associated gene pathogenecity island encoded
protein CagA and cytotoxin Vac A are could be responsible of ulcer pathogenesis. unlike other
bacteria helicobacter can able to produce cytotoxins which can cause immune mediated tissue
damage leads to ulcer formation.
You will construct a manual for your company that defines the Risk M.pdf
You will construct a manual for your company that defines the Risk Management Policy for all
future projects. For this, you can adopt the perspective of either a: - Option 1: o For Profit
Company that develops new products, and each product might be considered a project. For this
you will adopt the perspective of a Project Management Office (PMO) and you are developing
the manual that is used by all Project Managers (PM) who will be conducted a risk assessment
for all future projects. - Option 2: o City or town that has many projects in development or
underway, such as park operations, traffic operations, public works, etc… For this you will adopt
the perspective of a risk manager for a production facility or city/town, and you are drafting
policy for risk assessments of worker safety Whether you select Option 1 or Option 2, you will
draft the manual using the tools and materials that we have reviewed in Weeks 1 through 4 of
this class. The manual should be in a form such that a reasonably educated and informed
individual is able to pick the manual up, and have enough guidance for implementing the policy.
If you think about some of the documents we have reviewed thus far, they are a mix of policy,
guidance and specific methodologies. Your manual should follow the same general form: - What
is the general purpose of the manual - What is the interaction between policy and implementation
- What specific method are employed to assess the risk so that it can be managed It is expected
that - you will select two or more (but certainly not all) of the methods from the ISO and USCG
documents as the official method used to assess risk within your organization. - Offer guidance
as to when some specific method should be employed. Notice that this format follows the USCG
Risk-based Decision Making (RBDM) wherein they offer substantive guidance as to which
method should be used for which situation. This is compared to the ISO document which offers
generalities as to risk management policy, but offer limited guidance as to when to use specific
methods. Therefore, the project is NOT expected to be 27 pages of text (for example), but it IS
expected to be more than 5. Maybe 10? It all depends on what is necessary to get the job done. -
It is up to you, the student, to determine what is required based on your understanding of the
material thus far, and to draft a manual that is robust enough that you would feel comfortable
submitting to your supervisor if that supervisor asked for a risk management manual to be
drafted. The basic question is: what do you think this manual would look like? - What is you
organizational process for answering the 5 questions for any new project that is being considered
- There should be enough procedure and guidance information that the user is able to open the
document and leverage it towards a robust risk assessment that can be applied to the 90%
situation - Submit this as a ‘professional’ manual that you might find in the risk ma.
Which of the following statements about DNA and RNA are true, and wh.pdf
Which of the following statements about DNA and RNA are true, and which are false?
DNA is usually a double-stranded molecule, and RNA is usually single-stranded.
The nitrogenous base thymine is present in DNA and RNA, while uracil is present only in RNA.
A hydrogen atom is present on the 3? carbon in the ribose of DNA nucleotides, whereas a
hydroxyl group is present at the same position on RNA nucleotides.
The DNA and RNA molecules in a cell are copied by replication before a cell divides.
RNA is the primary long-term storage molecule for genetic information in eukaryotic cells.
DNA is usually a double-stranded molecule, and RNA is usually single-stranded.
The nitrogenous base thymine is present in DNA and RNA, while uracil is present only in RNA.
A hydrogen atom is present on the 3? carbon in the ribose of DNA nucleotides, whereas a
hydroxyl group is present at the same position on RNA nucleotides.
The DNA and RNA molecules in a cell are copied by replication before a cell divides.
RNA is the primary long-term storage molecule for genetic information in eukaryotic cells.
Solution
DNA is usually a double-stranded molecule, and RNA is usually single-stranded - True.
The nitrogenous base thymine is present in DNA and RNA, while uracil is present only in RNA -
False
A hydrogen atom is present on the 3? carbon in the ribose of DNA nucleotides, whereas a
hydroxyl group is present at the same position on RNA nucleotides - False
The DNA and RNA molecules in a cell are copied by replication before a cell divides - False
RNA is the primary long-term storage molecule for genetic information in eukaryotic cells -
False.
You observe a cell switch from performing cellular respiration to per.pdf
You observe a cell switch from performing cellular respiration to performing lactic acid
fermentation. Why would a cell make this switch? because there isn\'t enough glucose available
because there is too much carbon dioxide in the cell because the cell needs lactic acid to obtain
the extra ATP from fermentation because there isn\'t enough oxygen for cellular respiration
Solution
because there isn\'t enough oxygen for cellular respiration
Explanation: In the absence of oxygen as the terminal electron acceptor the reduced coenzymes -
NADH accumulate. Cell needs NAD+ to keep the glycolysis running. So the cell switches to
lactic acid fermentation to regenerate NAD+..
You are speaking to a group of high school students in a technology .pdf
You are speaking to a group of high school students in a technology workshop about network
security. You are describing a protocol that uses public-key cryptography to authenticate
between a local computer and a remote computer. Of the following, what security protocol are
you describing?
A. FTP
B. HTML
C. SSH
D. TCP/IP
Solution
C. SSH, or Secure Shell, is a network protocol that allows data to be exchanged using a secure
channel between two network hosts..
Who might use financial statements List at least 3 examples of like.pdf
Who might use financial statements? List at least 3 examples of likely users/stakeholders and the
types of decisions they might employ financial statements to aid them in making?
Solution
Following are the 3 users of financial statements:
1. Banks , they use financial statements so as to estimate the financial health of the company and
take decision of lending loan to the company or not.
2. New investors , they perform ratio analysis and other parameters and then take decision to
invest in that company or not.
3. Regulators , they keep eye on accounting representation and check accounting manipulation if
any.
What could be the rational for IRC exempting income from bonds issue.pdf
What could be the rational for IRC exempting income from bonds issued by States and other
municipalities from being taxable?
Solution
Municipal Bonds- These are issued by local and state Government for financing a project. These
bonds provide less but fixed return.
Rational behind exempting the income from municipal bonds from being taxable-
Municipal bonds are issued to finance for the Government projects. These provide very less
return to the public and provide no addional income except the interest, that is the reason most of
the municipal bonds\' interest is tax exempt from all federal income taxes..
Tropical forests are extremely important ecosystems on the planet. Ho.pdf
Tropical forests are extremely important ecosystems on the planet. However, humans are
destroying millions of acres of rainforests every year. Discuss 1why are they important and 2 do
you think it is possible to slow down the global distruction and if so how!
Solution
It is possible to slow down the global destruction by implying the follwoing steps:.
We learn of the the black dwarf, the final stage in a death of a low.pdf
We learn of the the black dwarf, the final stage in a death of a low mass star. What happens to a
black dwarf after it cools to nearly zero Kelvin over trillions of years? Is there any other stage, or
does it just remain as an Earth sized burned out ember for eternity?
Solution
It needs to be understood here that black dwarfs are essentially theoretical. The age of the
universe is around 14 billion years which happens to be too short a time for a white dwarf to emit
all of its heat out.
However, theoretically when this would happen, the white dwarf would reach a stage when its
temperature would be down to a level that the radiation coming out of it would become same as
the background cosmic radiation and will become invisible to us. That is, it will continue to cool
down until it reaches the temperature of its surrounding, a cold mass with nothing to emit or
absorb, and would remain so..
What are the main responsibilities of the Network Layer What are th.pdf
What are the main responsibilities of the Network Layer? What are the main services provided
by the Network Layer to the Transport Layer?
Solution
The main responsibilities of the Network Layer :-
* Network Layer provides Logical Network Address which is also called as IP Address.
* Network Layer translates Logical Network Address into Physical Address.
* Network Layer provides Routing and Message Forwarding.
The main services provided by the Network Layer to the Transport Layer :-
* The Network Layer responds to service requests from the Transport Layer which provides
Logical Address.
* The Network Layer issues service requests to the Data Link Layer which provides Physical
Address..
These organs in spiders produce with In this kind of circulato.pdf
These organs in spiders produce with In this kind of circulatory system blood is carried This
organ is both and endocrine and exocrine gland This group includes platypus and spiny anteaters
Solution
Answer to Question NO. 5.6
Bile is a dark green to yellowish brown fluid, produced in the liver of most vertebrates by special
cells called hepatocytes. It is temporarly stored in the gallbladder and aids the digestion of lipids
in the small intestine..
Ensign Danielle Anderson returned from a Qualified Hazardous Duty Ar.pdf
Ensign Danielle Anderson returned from a Qualified Hazardous Duty Area(GHDA) on May 15,
2017 She entered the GHDA on June 16, 2015. How many days after her return will she have to
file her 2016 California taxes without penalty?
180
175
298
286
Solution
Ensign will not be required to pay any penality or intrest if she files return in 180days from
return of qualified hazardous duty area..
Oxidation and reduction states are relatively easy to determine for m.pdf
Oxidation and reduction states are relatively easy to determine for metal ions, because there is a
measurable net charge. In the case of carbon compounds, oxidation and reduction depend on the
nature of polar covalent bonds. Which of the following is the best way to describe these types of
bond? hydrogen bonds in a nonpolar solution covalent bonds in an aqueous solution unequal
sharing of electrons across a covalent bond equal sharing of electrons across a covalent bond
Solution
The best way to describe these type of bond is option b i.e. covalent bonds in an aqueous
solution. In general, we know that bonds between carbon or hydrogen atom and N2, O2, F or Cl
atoms are polar covalent..
Question 9 (1 point) What is data visualization O Making a mental no.pdf
Question 9 (1 point) What is data visualization? O Making a mental note of data O Graphical
reporting O Using descriptive language O None of the above Save Question 10 (1 point) What
are the two components of metadata? O ATTRIBUTE : Value KEYWORD : Description
CHARACTERISTIC Attribute DESCRIPTOR Example Save Save All Responses Go to Submit
Quiz
Solution
Q 9- Graphical reporting- It is used as data visualization tool for better understanding of data.
Q10- Keyword is the correct answer..
Q i.Why is it, in general the fracture toughness of ductile material.pdf
Q i.Why is it, in general the fracture toughness of ductile materials greater than materials with
high hardness?
Q ii. Explain why BCC metals exhibit a Ductile - Brittle Transition Temperature while FCC
metals do not.
Solution
1)Ductility is more commonly defined as the ability of a material to deform easily upon the
application of a tensile force, or as the ability of a material to withstand plastic deformation
without rupture. Ductility may also be thought of in terms of bendability and crushability.
Ductile materials show large deformation before fracture. The lack
of ductility is often termed brittleness. Usually, if two materials have the same strength and
hardness, the one that has the higher ductility is more desirable. The ductility of many metals can
change if conditions are altered. An increase in temperature will increase ductility. A decrease in
temperature will cause a decrease in ductility and a change from ductile to brittle behavior.
As the hardness of a material increases the ductility propertry decreases and brittlness increses
therefore toughness dcreases.
2)
The ductile-brittle transition is exhibited in bcc metals, such as low carbon steel, which become
brittle at low temperature or at very high strain rates. Fcc metals, however, generally remain
ductile at low temperatures.
In metals, plastic deformation at room temperature occurs by dislocation motion. The stress
required to move a dislocation depends on the atomic bonding, crystal structure, and obstacles
such as solute atoms, grain boundaries, precipitate particles and other dislocations. If the stress
required to move the dislocation is too high, the metal will fail instead by the propagation of
cracks and the failure will be brittle.
Thus, either plastic flow (ductile failure) or crack propagation (brittle failure) will occur,
depending on which process requires the smaller applied stress.
In fcc metals, the flow stress, i.e. the force required to move dislocations, is not strongly
temperature dependent. Therefore, dislocation movement remains high even at low temperatures
and the material remains relatively ductile.
In contrast to fcc metal crystals, the yield stress or critical resolved shear stress of bcc single
crystals is markedly temperature dependent, in particular at low temperatures. The temperature
sensitivity of the yield stress of bcc crystals has been attributed to the presence of interstitial
impurities on the one hand, and to a temperature dependent Peierls-Nabarro force on the other.
However, the crack propagation stress is relatively independent of temperature. Thus the mode
of failure changes from plastic flow at high temperature to brittle fracture at low temperature..
Problem 1. Think about an individual that you are investigating from .pdf
Problem 1. Think about an individual that you are investigating from engineering analysis
perspective. A few years back, when he first visited DC, the price for a 7-day unlimited pass
MetroRail ticket was $10. Without knowing the spurt in rail ticket price, he moved to DC very
recently without purchasing a vehicle and planned to take Metro to museums and restaurants and
for commuting trips, too. Then, he found out the price for Metro tickets tripled. Use your
engineering knowledge to forecast or predict which of the following travel plan decisions would
change for this person? 1. The total number of trips made in DC; 2. The mode of transportation
he uses for travel; 3. Any other perspective of trips he makes. Can you also identify the possible
rationale behind all these changes? Problem 2. Name three simplifying assumptions that are used
in the mode choice and route choice steps. Pick one of them, and then explain how you could
change the procedure to relax this assumption and make the process more realistic.
Solution.
Junior collects baseball cards. He owns one Felix Hernandez card tha.pdf
Junior collects baseball cards. He owns one Felix Hernandez card that sells in most shops for
$15. He is interested in buying a different Felix card that also sells for $15. According to
behavioral economics:
A. Junior should value the two cards equally and be willing to trade one for the other.
B. the availability heuristic will cause Junior to value more highly the card he doesn\'t have.
C. the endowment effect would suggest that Junior would not be willing to trade the card he has
for the card he doesn\'t have.
D. prospect theory says he will buy the second card as both have the potential to appreciate in
value.
Solution
The rational behavior would suggest that the individual should value both the cards equally and
be willing to trade one for the other in order to obatin felix card, he does not have. The value of
both the card should be same in order for the individual to attain optimal level of utility,
otherwsie he will be worse off at sub-optimal level.
Assume, his felix hernandes card worth more than what is being sold in the market, then by
exchanging the card he will be worse off buy the difference in amount. If on ther otherhand, the
card he hold worth less in the market, and if he wish to exchange then it would be not possible
for him to do so, as the other party wont accept it. Again, in this circumstances he would still be
worse off.
Hence, the card should be equally worth and parties in contract should be willing to exchange.
The correct answer is A..
More from thangarajarivukadal (20)
Which of the following is not a high-speed Internet assess service.pdf
Which of the following is not a high-speed Internet assess service.pdf
Write a program to implement below operations with both singly and d.pdf
Write a program to implement below operations with both singly and d.pdf
Which of the following describes silver A material that has a low r.pdf
Which of the following describes silver A material that has a low r.pdf
why dont most other types of bacteria produce ulcers ( like helico.pdf
why dont most other types of bacteria produce ulcers ( like helico.pdf
You will construct a manual for your company that defines the Risk M.pdf
You will construct a manual for your company that defines the Risk M.pdf
Which of the following statements about DNA and RNA are true, and wh.pdf
Which of the following statements about DNA and RNA are true, and wh.pdf
You observe a cell switch from performing cellular respiration to per.pdf
You observe a cell switch from performing cellular respiration to per.pdf
You are speaking to a group of high school students in a technology .pdf
You are speaking to a group of high school students in a technology .pdf
Who might use financial statements List at least 3 examples of like.pdf
Who might use financial statements List at least 3 examples of like.pdf
What could be the rational for IRC exempting income from bonds issue.pdf
What could be the rational for IRC exempting income from bonds issue.pdf
Tropical forests are extremely important ecosystems on the planet. Ho.pdf
Tropical forests are extremely important ecosystems on the planet. Ho.pdf
We learn of the the black dwarf, the final stage in a death of a low.pdf
We learn of the the black dwarf, the final stage in a death of a low.pdf
What are the main responsibilities of the Network Layer What are th.pdf
What are the main responsibilities of the Network Layer What are th.pdf
These organs in spiders produce with In this kind of circulato.pdf
These organs in spiders produce with In this kind of circulato.pdf
Ensign Danielle Anderson returned from a Qualified Hazardous Duty Ar.pdf
Ensign Danielle Anderson returned from a Qualified Hazardous Duty Ar.pdf
Oxidation and reduction states are relatively easy to determine for m.pdf
Oxidation and reduction states are relatively easy to determine for m.pdf
Question 9 (1 point) What is data visualization O Making a mental no.pdf
Question 9 (1 point) What is data visualization O Making a mental no.pdf
Q i.Why is it, in general the fracture toughness of ductile material.pdf
Q i.Why is it, in general the fracture toughness of ductile material.pdf
Problem 1. Think about an individual that you are investigating from .pdf
Problem 1. Think about an individual that you are investigating from .pdf
Junior collects baseball cards. He owns one Felix Hernandez card tha.pdf
Junior collects baseball cards. He owns one Felix Hernandez card tha.pdf
Recently uploaded
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.Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Let’s explore the intersection of technology and equity in the final session of our DEI series. Discover how AI tools, like ChatGPT, can be used to support and enhance your nonprofit's DEI initiatives. Participants will gain insights into practical AI applications and get tips for leveraging technology to advance their DEI goals.
Digital Artifact 1 - 10VCD Environments Unit
Digital Artifact 1 - 10VCD Environments Unit - NGV Pavilion Concept Design
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.Main Java[All of the Base Concepts}.docx
This is part 1 of my Java Learning Journey. This Contains Custom methods, classes, constructors, packages, multithreading , try- catch block, finally block and more.
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.
PCOS corelations and management through Ayurveda.
This presentation includes basic of PCOS their pathology and treatment and also Ayurveda correlation of PCOS and Ayurvedic line of treatment mentioned in classics.
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Discover the Simplified Electron and Muon Model: A New Wave-Based Approach to Understanding Particles delves into a groundbreaking theory that presents electrons and muons as rotating soliton waves within oscillating spacetime. Geared towards students, researchers, and science buffs, this book breaks down complex ideas into simple explanations. It covers topics such as electron waves, temporal dynamics, and the implications of this model on particle physics. With clear illustrations and easy-to-follow explanations, readers will gain a new outlook on the universe's fundamental nature.
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.
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.
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS Template 2023-2024 by: Irene S. Rueco
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama UniversityAkanksha trivedi rama nursing college kanpur.
Natural birth techniques are various type such as/ water birth , alexender method, hypnosis, bradley method, lamaze method etcTop 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!
Types of Herbal Cosmetics its standardization.
Physiology and chemistry of skin and pigmentation, hairs, scalp, lips and nail, Cleansing cream, Lotions, Face powders, Face packs, Lipsticks, Bath products, soaps and baby product,
Preparation and standardization of the following : Tonic, Bleaches, Dentifrices and Mouth washes & Tooth Pastes, Cosmetics for Nails.
Recently 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
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
Executive Directors Chat Leveraging AI for Diversity, Equity, and Inclusion
South African Journal of Science: Writing with integrity workshop (2024)
South African Journal of Science: Writing with integrity workshop (2024)
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
The simplified electron and muon model, Oscillating Spacetime: The Foundation...
Liberal Approach to the Study of Indian Politics.pdf
Liberal Approach to the Study of Indian Politics.pdf
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
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
RPMS TEMPLATE FOR SCHOOL YEAR 2023-2024 FOR TEACHER 1 TO TEACHER 3
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
Natural birth techniques - Mrs.Akanksha Trivedi Rama University
1. Create the binary tree with 9 nodes (Figure 1) by using pointer-b.pdf
- 1. 1. Create the binary tree with 9 nodes (Figure 1) by using pointer-based representation. struct TreeNode { int info; TreeNode * left; TreeNode * right; } 2. Implement pre-order, in-order, and post-order traversals, and print the results of the tree The pre-order transversal looks like this: 2 7 2 6 5 11 5 9 4 The in-order transversal looks like this: 2 7 5 6 11 2 5 4 9 The post-order transversal looks like this: 2 5 11 6 7 4 9 5 2 Solution Here is the code for you: #include #include #include typedef struct node { int info; struct node *left; struct node *right; } node; void insert(node **,int); void preorder(node *); void postorder(node *); void inorder(node *); int main() { node *root; int ch,ele; root=NULL; while(1)
- 2. { printf("TREE OPERATIONS "); printf("1.INSERT "); printf("2.INORDER "); printf("3.PREORDER "); printf("4.POSTORDER "); printf("5.EXIT "); printf("Enter your choice: "); scanf("%d",&ch); switch(ch) { case 1: printf("Enter the element you want to insert: "); scanf("%d",&ele); insert(&root,ele); break; case 2: inorder(root); break; case 3: preorder(root); break; case 4: postorder(root); break; case 5: exit(0); default: printf("Invalid Choice. Please enter a valid choice. "); } } } void insert(node **root, int ele) { node *temp,*x,*y; x=y=*root; temp= (node *)malloc(sizeof(node)); temp->info=ele; temp->left = temp->right = NULL; while(x!=NULL) { y=x;
- 3. if(ele < x->info) x = x->left; else x = x->right; } if(y == NULL) *root=temp; else if(ele < y->info) y->left = temp; else y->right = temp; } void inorder(node *root) { if(root != NULL) { inorder(root->left); printf("%d ",root->info); inorder(root->right); } } void preorder(node *root) { if(root != NULL) { printf("%d ",root->info); inorder(root->left); inorder(root->right); } } void postorder(node *root) { if(root != NULL) { inorder(root->left); inorder(root->right);