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.
Rainer Grimm, “Functional Programming in C++11”Platonov Sergey
C++ это мультипарадигменный язык, поэтому программист сам может выбирать и совмещать структурный, объектно-ориентированный, обобщенный и функциональный подходы. Функциональный аспект C++ особенно расширился стандартом C++11: лямбда-функции, variadic templates, std::function, std::bind. (язык доклада: английский).
Bartosz Milewski, “Re-discovering Monads in C++”Platonov Sergey
Once you know what a monad is, you start seeing them everywhere. The std::future library of C++11 was an example of an incomplete design, which stopped short of recognizing the monadic nature of futures. This is now being remedied in C++17, and there are new library additions, like std::expected and the range library, that are much more monad-conscious. I’ll explain what a monad is using copious C++ examples.
Rainer Grimm, “Functional Programming in C++11”Platonov Sergey
C++ это мультипарадигменный язык, поэтому программист сам может выбирать и совмещать структурный, объектно-ориентированный, обобщенный и функциональный подходы. Функциональный аспект C++ особенно расширился стандартом C++11: лямбда-функции, variadic templates, std::function, std::bind. (язык доклада: английский).
Bartosz Milewski, “Re-discovering Monads in C++”Platonov Sergey
Once you know what a monad is, you start seeing them everywhere. The std::future library of C++11 was an example of an incomplete design, which stopped short of recognizing the monadic nature of futures. This is now being remedied in C++17, and there are new library additions, like std::expected and the range library, that are much more monad-conscious. I’ll explain what a monad is using copious C++ examples.
The python interpreter converts programs to bytecodes before beginning execution. Execution itself consist of looping over these bytecodes and performing specific operations over each one. This talk gives a very brief overview of the main classes of bytecodes.
This presentation was given as a lightning talk at the Boston Python Meetup group on July 24th, 2012.
Bob Tiernay explores the fascinating world of jq, "the JSON Processor”. Starting with a motivation, he then covers the language, provides helpful tips, showcases a real world example, cautions some things to avoid and finishes with a discussion of the ecosystem.
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
JSON is a well-known, lightweight format for data exchange around the web. It’s a structured data format used in modern APIs and goes really well with web applications. But how do you work with these JSON files directly and perform operations on it? This is where JQ comes into play.
JQ is a flexible, lightweight, command-line processor that is like ‘sed’ for JSON data. JQ gets along well with UNIX pipes and offers rich functionality to interrogate, manipulate, and work with JSON files.
In this webinar, you will be introduced to JQ and you will learn how to work with basic filters, operators & functions, conditionals & comparisons. You will also learn how to define functions, work with Regex, and use streaming JSON data in JQ.
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
The python interpreter converts programs to bytecodes before beginning execution. Execution itself consist of looping over these bytecodes and performing specific operations over each one. This talk gives a very brief overview of the main classes of bytecodes.
This presentation was given as a lightning talk at the Boston Python Meetup group on July 24th, 2012.
Bob Tiernay explores the fascinating world of jq, "the JSON Processor”. Starting with a motivation, he then covers the language, provides helpful tips, showcases a real world example, cautions some things to avoid and finishes with a discussion of the ecosystem.
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
JSON is a well-known, lightweight format for data exchange around the web. It’s a structured data format used in modern APIs and goes really well with web applications. But how do you work with these JSON files directly and perform operations on it? This is where JQ comes into play.
JQ is a flexible, lightweight, command-line processor that is like ‘sed’ for JSON data. JQ gets along well with UNIX pipes and offers rich functionality to interrogate, manipulate, and work with JSON files.
In this webinar, you will be introduced to JQ and you will learn how to work with basic filters, operators & functions, conditionals & comparisons. You will also learn how to define functions, work with Regex, and use streaming JSON data in JQ.
Pratik Bakane C++ programs...............This are programs desingedby sy diploma student from Governement Polytecnic Thane.....programsare very easy alongwith coding andscreen shot of the output
This is a c++ binary search program I worked so far but still cant g.pdfkostikjaylonshaewe47
This is a c++ binary search program I worked so far but still cant get it right.
Can anyone help me? Big thanks!!
the client should not be modified
/*
*File: client.cpp
*Author: Yingwu Zhu
*Warning: do not change this file and use it as is.
*Last Modififcation: 10/21/2016
*/
#include
#include
#include
#include
#include
#include \"bst.h\"
using namespace std;
int main(int argc, char* argv[]) {
if (argc != 2) {
cout << \"Format: \" << argv[0] << \" [data file]\" << endl;
return 0;
}
ifstream fin(argv[1]);
int cases;
fin >> cases;
int passed = 0;
for (int i = 1; i <= cases; i++) {
cout << \"Checking test case #\" << i << \" ... \";
BST T;
set S;
int n, x;
fin >> n;
bool ok = true;
vector tmp;
int rem = 0;
for (int j = 0; j < n; j++) {
fin >> x;
T.Insert(x);
S.insert(x);
ok &= (T.Search(x) && T.RecurSearch(x));
if (tmp.empty())
tmp.push_back(x);
if (rand()%10 < 3) {
T.Erase(tmp[0]);
S.erase(tmp[0]);
ok &= (T.Search(tmp[0]) == false);
tmp.pop_back();
rem++;
}
}
if (rem
ok &= (T.MaxElement() == *S.rbegin());
while (!S.empty() && !T.Empty()) {
int x = T.MinElement();
ok &= (x == *S.begin());
T.Erase(x);
S.erase(S.begin());
}
cout << (ok ? \"Passed!\" : \"Failed\") << endl;
passed += ok;
}
cout << passed << \" of \" << cases << \" test cases have passed!\ \";
if (passed == cases)
cout << endl << \"Congratulations! Good to Submit Your Code\ \";
else if ((double)passed/cases >= 0.95)
cout << endl << \"You are almost there, but need to fix some bugs.\ \";
else
cout << endl << \"Your code needs a lot of fixes for submission\ \";
return 0;
}
=====================================================================
=======
//bst.h
#ifndef _BST_H_
#define _BST_H_
#include
using namespace std;
class BST {
private:
class Node {
public:
int data;
Node* left;
Node* right;
};
Node* root; //root node pointer
//you may add your auxiliary functions here!
public:
BST(); //constructor
~BST(); //destructor
bool Empty() const;
void Insert(int val);
int MinElement() const;
int MaxElement() const;
bool Search(int val) const;
bool RecurSearch(int val) const;
void Erase(int val);
};
#endif
=====================================================================
=======
/*
bst.cpp
Subject: Binary Seach Tree
Modification Time:10/26/2016
*/
#include
#include\"bst.h\"
using namespace std;
BST::BST(){
root= NULL;
}
BST::~BST(){
delete root;
delete root->left;
delete root->right;
}
bool BST::Empty() const {
return data;
}
void BST::Insert(int val){
Node* p= new Node;
p->data= val;
Node* cur = root;
if(val < cur->data){
cur = cur -> left;
}
else{
right->next=val;
}
}
int BST::MinElement() const {
Node* cur;
while(cur->left != NULL){
cur = cur->left;
}
return(cur->data);
}
int BST::MaxElement() const{
if(root==NULL){
return 0;
}
if(root->left>root->data){
root->data=root->right;
}
else if(root->right>root->data){
root->data=root->right;
}
return root->data;
}
bool BST:: Search(int val) const{
Node* cur;
cur = root;
while(cur!=NULL){
if(cur->data == val){
return true;
}
else if(cur->data .
How do you stop infinite loop Because I believe that it is making a.pdffeelinggift
How do you stop infinite loop? Because I believe that it is making an infinite circular list.
c++ code:
Here is the list class:
#ifndef LIN_J_LIST
#define LIN_J_LIST
typedef unsigned int uint;
#include
#include
using namespace std;
/**
* a simplified generic singly linked list class to illustrate C++ concepts
* @author Jerry Lin
* @version 2/17/17
*/
template< typename Object >
class List
{
private:
/**
* A class to store data and provide a link to the next node in the list
*/
class Node
{
public:
/**
* The constructor
* @param data the data to be stored in this node
*/
explicit Node( const Object & data )
: data{ data }, next{ nullptr } {}
Object data;
Node * next;
};
public:
/**
* The constructor for an empty list
*/
List()
: size{ 0 }, first{ nullptr }, last{ nullptr } {}
/**
* the copy constructor-creates and copy the list
*/
List( List && rhs ) = delete;
List( const List & rhs )
{
count = 0;
size = 0;
if(rhs.size != 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first;
size++;
while(current->next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op.
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode->next;
size++;
}
}
// you document and implement this method
}
/**
* the operator= method-copies the list
*/
List & operator=( List && rhs) = delete;
List & operator=( const List & rhs )
{
count = 0;
size = 0;
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
if(rhs.size!= 0)
{
push_front(rhs.front());
Node * current = rhs.first;
Node * tempNode = first; //create a temporary to store
size++;
while(current -> next != nullptr)
{
current = current->next;
Node *newNode = new Node(current->data); //transfer the data. basic op
count++;
tempNode->next = newNode;
last = newNode;
tempNode = tempNode -> next;
size++;
}
}
return *this;
// you document and implement this method
}
/**
* accessor
* @return count
*/
int get_count() const
{
return count;
}
/**
* The destructor that gets rid of everything that\'s in the list and
* resets it to empty. If the list is already empty, do nothing.
*/
~List()
{
if( size != 0 )
{
Node * current = first;
Node * temp;
while( current != nullptr )
{
temp = current;
current = current->next;
delete temp;
}
}
}
/**
* Put a new element onto the beginning of the list
* @param item the data the new element will contain
*/
void push_front( const Object& item )
{
Node * new_node = new Node( item );//basic op.
if(is_empty())
{
last = new_node;
}
else
{
new_node->next = first;
}
first = new_node;
size++;
/* you complete the rest */
}
/**
* Remove the element that\'s at the front of the list. Causes an
* assertion error if the list is empty.
*/
void pop_front()
{
assert( !is_empty() );
Node * temp = first;
if( first == last )
{
first = last = nullptr;
}
else
{
first = first->next;
}
delete temp;
size--;
}
/**
* Accessor to return the da.
Write a C program that reads the words the user types at the command.pdfSANDEEPARIHANT
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.
files/Heap.h
#ifndef HEAP_H
#define HEAP_H
#include <vector>
#include <stdexcept> // std::out_of_range
#include <math.h> // pow()
using namespace std;
template<typename T>
class Heap
{
private:
vector<T> _items; // Main vector of elements for heap storage
/**
* Used to take unsorted data and heapify it
*/
void buildHeap()
{
for (int i = _items.size() / 2; i >= 0; i--)
{
percolateDown(i);
}
}
/*********************************************************************/
/********************* Microassignment zone *************************/
/**
* Percolates the item specified at by index down
* into its proper location within a heap.
* Used for dequeue operations and array to heap conversions
* MA TODO: Implement percolateDown!
*/
void percolateDown(int index)
{
}
/**
* Percolate up from a given index to fix heap property
* Used in inserting new nodes into the heap
* MA TODO: Implement percolateUp
*/
void percolateUp( int current_position )
{
}
/************************** Microassigment zone DONE *********************/
public:
/**
* Default empty constructor
*/
Heap()
{
}
/**
* Constructor with a vector of elements
*/
Heap(const vector<T> &unsorted)
{
for (int i = 0; i < unsorted.size(); i++)
{
_items.push_back(unsorted[i]);
}
buildHeap();
}
/**
* Adds a new item to the heap
*/
void insert(T item)
{
int current_position = size(); // Get index location
_items.push_back(item); // Add data to end
percolateUp( current_position ); // Adjust up, as needed
}
/**
* Returns the top-most item in our heap without
* actually removing the item from the heap
*/
T& getFirst()
{
if( size() > 0 )
return _items[0];
else
throw std::out_of_range("No elements in Heap.");
}
/**
* Removes minimum value from heap and returns it to the caller
*/
T deleteMin()
{
int last_index = size() - 1; // Calc last item index
int root_index = 0; // Root index (for readability)
T min_item = _items[root_index]; // Keep item to return
_items[root_index] = _items[last_index]; // Move last item to root
_items.erase(_items.end() - 1); // Erase last element entry
percolateDown(0); // Fix heap property
return min_item;
}
/**
* Returns true if heap is empty, else false
*/
bool isEmpty() const
{
return _items.size() == 0;
}
/**
* Returns current quantity of elements in heap (N)
*/
int size() const
{
return _items.size();
}
/**
* Return heap data in order from the _items vector
*/
string to_s() const
{
string ret = "";
for(int i = 0; i < _items.size(); i++)
{
ret += to_string(_items[i]) + " ";
}
return ret;
}
/**
...
I want help in the following C++ programming task. Please do coding .pdfbermanbeancolungak45
I want help in the following C++ programming task. Please do coding in C++.
Persistent Data Structures
A persistent data structure is one in which we can make changes (such as inserting and removing
elements) while still preserving the original data structure Of course, an easy way to do this is to
create a new copy of the entire data structure every time we perform an operation that changes
the data structure, but it is much more efficient to only make a copy of the smallest possible
portion of the data structure.
First, let\'s look at one of the easiest possible data structures — a stack, implemented using a
linked list.
Persistent Stack
Let\'s say that we have a stack S1, and we want to create a new stack S2, which is the result of
pushing a new element X onto S1, without changing S1 at all. This is easy — we just add a new
element that points to S1:
Starting with the stack S1:
We push X on S1, to get S2, leaving S1 as it was. So after the operation we have two versions of
the stack S1 the older version with elements A, B and C and S2 the newer version with elements
X, A, B and C.
What about popping? That works in the same way. Starting with our original S1 (elements A, B
and C), we can pop off the first element (A), to get S2:
What if we want to push something on to this new stack? It works in the same was as before – if
we push an X onto S2 above to get S3, we have
So for every operation you make a new version of the stack while reusing any existing stack
elements.
You will have to make a linked list of pointers that will point to the head of the different stack
versions.
Also each stack is also implemented as a linked list of elements SAB
Solution
#include #include #include #include #include #include #include #include #include
#include #include namespace dts { template > class PersistentSet { public:
PersistentSet(); PersistentSet(Func); bool add(const T&); bool add(T&&);
bool remove(const T& key); bool empty() const; size_t history_size() const;
class TreeIterator : public std::iterator, std::ptrdiff_t, const T*,
const T&> { using node = typename dts::PersistentSet< std::remove_cv_t,
Func>::Nodeptr; node itr; node nil; std::stack path; node
find_successor(node n) { n = n->rigth; if (n != nil) {
while (n->left != nil) { path.push(n); n = n->left;
} } else { n = path.top();
path.pop(); } return n; } public: explicit
TreeIterator(node n, node pnil) : nil(pnil) //begin { if (n == nil) itr
= nil; else { path.push(nil); while (n->left != nil)
{ path.push(n); n = n->left; } itr =
n; } } explicit TreeIterator(node pnil) // end : itr(pnil),
nil(pnil) { } TreeIterator& operator++ () { itr =
find_successor(itr); return *this; } TreeIterator operator++ (int)
{ TreeIterator tmp(*this); itr = find_successor(itr); return tmp;
} bool operator == (const TreeIterator& rhs) const { return itr ==
rhs.itr; } bool operator != (const TreeIterator& rhs) const {
return itr != rhs.itr; } const T& operator* () const { return itr-
>key; } const T& operator-> () c.
coding in C- Create a function called reverseList that takes the head.docxtienlivick
coding in C;
Create a function called reverseList that takes the head of a linked list, reverses the order of all the nodes. For example, if the list contained 1, 2, 3, 4 in its nodes, the list will now contain 4, 3, 2, 1.
please add a main test.
Solution
Please find the required program below:
#include<stdio.h>
#include<stdlib.h>
struct node
{
int data;
struct node* next;
};
void push(struct node** head, int new_element)
{
struct node* new_node =
(struct node*) malloc(sizeof(struct node));
new_node->data = new_element;
new_node->next = (*head);
(*head) = new_node;
}
void printList(struct node *head)
{
struct node *temp = head;
while(temp != NULL)
{
printf(\"%d \", temp->data);
temp = temp->next;
}
}
void reverseList(struct node** head)
{
struct node* prev = NULL;
struct node* current = *head;
struct node* next;
while (current != NULL)
{
next = current->next;
current->next = prev;
prev = current;
current = next;
}
*head = prev;
}
int main()
{
struct node* head = NULL;
push(&head, 12);
push(&head, 14);
push(&head, 5);
push(&head, 8);
printf(\"\ Linked list Before Reversing :\ \");
printList(head);
reverseList(&head);
printf(\"\ Linked list After Reversing :\ \");
printList(head);
}
--------------------------------------------------------------------------------
OUTPUT:
Linked list Before Reversing :
8Â Â 5Â Â 14Â Â 12
Linked list After Reversing :
12Â Â 14Â Â 5Â Â 8
.
Similar to DATASTRUCTURES PPTS PREPARED BY M V BRAHMANANDA REDDY (20)
A Strategic Approach: GenAI in EducationPeter Windle
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.
Synthetic Fiber Construction in lab .pptxPavel ( NSTU)
Synthetic fiber production is a fascinating and complex field that blends chemistry, engineering, and environmental science. By understanding these aspects, students can gain a comprehensive view of synthetic fiber production, its impact on society and the environment, and the potential for future innovations. Synthetic fibers play a crucial role in modern society, impacting various aspects of daily life, industry, and the environment. ynthetic fibers are integral to modern life, offering a range of benefits from cost-effectiveness and versatility to innovative applications and performance characteristics. While they pose environmental challenges, ongoing research and development aim to create more sustainable and eco-friendly alternatives. Understanding the importance of synthetic fibers helps in appreciating their role in the economy, industry, and daily life, while also emphasizing the need for sustainable practices and innovation.
Model Attribute Check Company Auto PropertyCeline George
In Odoo, the multi-company feature allows you to manage multiple companies within a single Odoo database instance. Each company can have its own configurations while still sharing common resources such as products, customers, and suppliers.
Welcome to TechSoup New Member Orientation and Q&A (May 2024).pdfTechSoup
In this webinar you will learn how your organization can access TechSoup's wide variety of product discount and donation programs. From hardware to software, we'll give you a tour of the tools available to help your nonprofit with productivity, collaboration, financial management, donor tracking, security, and more.
How to Make a Field invisible in Odoo 17Celine George
It is possible to hide or invisible some fields in odoo. Commonly using “invisible” attribute in the field definition to invisible the fields. This slide will show how to make a field invisible in odoo 17.
Operation “Blue Star” is the only event in the history of Independent India where the state went into war with its own people. Even after about 40 years it is not clear if it was culmination of states anger over people of the region, a political game of power or start of dictatorial chapter in the democratic setup.
The people of Punjab felt alienated from main stream due to denial of their just demands during a long democratic struggle since independence. As it happen all over the word, it led to militant struggle with great loss of lives of military, police and civilian personnel. Killing of Indira Gandhi and massacre of innocent Sikhs in Delhi and other India cities was also associated with this movement.
Acetabularia Information For Class 9 .docxvaibhavrinwa19
Acetabularia acetabulum is a single-celled green alga that in its vegetative state is morphologically differentiated into a basal rhizoid and an axially elongated stalk, which bears whorls of branching hairs. The single diploid nucleus resides in the rhizoid.
The French Revolution, which began in 1789, was a period of radical social and political upheaval in France. It marked the decline of absolute monarchies, the rise of secular and democratic republics, and the eventual rise of Napoleon Bonaparte. This revolutionary period is crucial in understanding the transition from feudalism to modernity in Europe.
For more information, visit-www.vavaclasses.com
The French Revolution Class 9 Study Material pdf free download
DATASTRUCTURES PPTS PREPARED BY M V BRAHMANANDA REDDY
1. DATA STRUCTURES ( C++ )
DATASTRUCTURES PROGRAMMING CONCEPTS
Developed by,
M.V.B.REDDY,CSE
Associate professor,
Dept. of CSE, GST,
GITAM UNIVERSITY.
Email ID : bramhareddy999@gmail.com
2. Let us take an array a[5] and take a variable top points to -1.
PUSH:
To INSERT the element in to stack using top.
Here we check for the OVERFLOW condition.
STACK USING ARRAYS
POP:
To RETRIEVE elements from the stack using top.
Here we check for the UNDERFLOW condition.
This concept is nothing but LIFO.
SOURCE CODE:
/* Program To Implement Stack using Array */
#include < iostream.h >
#include < conio.h >
#include < stdlib.h >
#define MAX 10
3. class stack
{
private : int sp, a [ MAX ];
public :
void init ( );
void push ( int );
void pop ( );
void display ( );
void count ( );
};
void stack :: init ( )
{
sp = - 1;
}
void stack :: push ( int data)
{
if (sp = = ( MAX – 1 ) )
{
cout<<"n STACK OVERFLOW.......n";
return;
}
4. sp + + ;
a [ sp ] = data;
}
void stack :: pop ( )
{i
f ( sp < 0 )
{
cout<<"n STACK UNDERFLOW.....n";
return;
}
cout<<"n POPED DATA IS ::: "<<a[sp];
sp - - ;
}
void stack :: display ( )
{
cout << "n DATA PRESENT IN A STACK IS ::: n";
for ( int i = sp ; i > = 0 ; i - -)
cout << a [ i ] <<"t";
}
void stack :: count ( )
{
cout<<"n NUMBER OF ELEMENTS IN A STACK ARE ::: "<<(sp+1);
};
5. void main ( )
{
stack ob;
int data,ch;
clrscr ( );
ob.init ( );
cout<<"n**********STACK OPERATIONS**********n";
cout<<"n1.Push Operation";
cout<<"n2.Pop Operation";
cout<<"n3.Display Operation";
cout<<"n4.Count Operation";
cout<<"n5.Exit Operation";
cout<<"n*************************************n";
do
{
cout<<"n ENTER YOUR CHOICE :: ";
cin>>ch;
switch ( ch )
{
case 1:cout<<"n ENTER ELEMENT TO BE INSERTED :::";
cin>>data;
ob.push ( data ); break;
case 2: ob.pop ( ); break;
case 3: ob.display ( ); break;
case 4:ob.count ( ); break;
case 5: exit ( 0 );
defualt: cout<<"nINVALID CHOICE ";
}}
while ( ch ! = 5 );
getch ( );
}
7. We will create a linked list and insert an element ‘10’ and address as ‘0’.using top for
the first node.
For second node insert data element ‘20’ and insert first node address at second
STACK node address USING field.
LINKED LIST
For third node insert data element ‘30’ and insert second node address at third node
address field . after thirty we will stop the process .
If we want to print the elements 30,20,10 will be displayed, Thiss follows LIFO
conceot.
8. Source code:
#include<conio.h>
#include<iostream.h>
class st
{
public:
struct node
{
int data;
struct node *next;
}*start,*temp,*top;
st()
{
start=temp=top=NULL;
}
void create()
{
int d;
cout<<"Enter data";
cin>>d;
if(start==NULL)
{
start=new node;
start->data=d;
11. Here we will take an array a[5],and two variables front, rear points to -1.
WRITE:
QUEUE USING ARRAYS
Here will insert the element into the queue using rear variable.
Here check for the Overflow condition.
READ:
Here we will retrieve the elements from the queue using front variable.
Here check for the Underflow condition.
This follows the FIFO concept.
rear
-1 0 1 2 3 4
front
12. SOURCE CODE:
/* Program To Implement Queue using Array */
#include< iostream.h >
#include< conio.h >
#include< process.h >
#define MAX 10
class queue
{
private : int front, rear, a [ MAX ];
public :
void init ( );
void write ( int );
void read ( );
void count ( );
void display ( );
};
void queue :: init ( )
{f
ront = rear = - 1;
}
void queue :: write ( int data)
{ if ( rear = = ( MAX - 1 ) )
cout<<"n QUEUE IS OVERFLOW......";
else
a [ + + rear ] = data;
}
void queue :: read ( )
{ if( front = = rear )
cout<<"n QUEUE IS UNDERFLOW.....";
else
cout<<"n DELETED ELEMENT IN QUEUE IS :: "<<a[++front];
}
13. void queue :: count ( )
{
cout<<"n NUMBER OF ELEMENTS IN A QUEUE ARE ::
"<<(rear-front);
}
void queue :: display ( )
{
cout<<"n ELEMENTS IN A QUEUE ARE:: ";
for( int i = (front + 1); i < = rear; i + + )
cout<< a [ i ]<<"t";
}
void main ( )
{
queue ob;
int ch,data;
clrscr ( );
ob.init ( );
cout<<"n*****QUEUE OPERATIONS****n";
cout<<"n1.Write ";
cout<<"n2.Read ";
cout<<"n3.Count";
cout<<"n4.Display";
cout<<"n5.Exit";
cout<<"**************************n";
14. do
{
cout<<"n ENTER YOUR CHOICE :: ";
cin>>ch;
switch ( ch )
{
case 1:cout<<"n ENTER ELEMENT TO BE INSERTED IN QUEUE :: ";
cin>>data;
ob.write ( data );
break;
case 2:ob.read ( );
break;
case 3:ob.count ( );
break;
case 4:ob.display ( );
break;
case 5:exit ( 0 );
break;
default :cout<<"n INVALID CHOICE...";
}}
while( ch ! = 5 );
getch ( );
}
16. Here we will create linked list with ‘n’ nodes one after another 10,20,30 etc.
If we try to print the elements it will display as 10,20,30. which follows FIFO
Queue concept.
using linked list
17. SOURCE CODE:
/* Program To Implement Queue using Linked List */
#include < iostream.h >
#include< conio.h >
#include < alloc.h >
#define NULL 0
class node
{i
nt data;
node *next;
public:
void create ( node *);
void print ( node *);
};
void node :: create (node *list)
{
cout<<"n ENTER THE INPUT NO :: ";
cout<<"n TYPE 999 AT THE END :: ";
cin>>list->data;
if(list -> data = = 999)
list->next = NULL;
else
{l
ist -> next = new node;
create( list -> next);
} return;
}
18. void node :: print (node *list)
{i
f( list -> next ! = 0)
{
cout<< list->data;
cout<<"->";
}
else
return;
print( list -> next);
}
void main ( )
{
node *head, ob;
clrscr ( );
head = new node;
ob.create ( head );
cout<<"n QUEUE ELEMENTS ARE:: ";
ob.print( head );
cout<<"999";
getch ( );
}
20. A binary tree is a tree data structure in which each node has at most two children. Typically
the child nodes are called left and right. Binary trees are commonly used to implement binary
search trees and binary heaps.
Starting at the root of a binary tree, there are three main steps that can be performed and the
order in which they are performed define the traversal type.
BINARY TREE USING RECURSION
There are 3 types of traversals:
1. Pre-Order
2. In-Order
3. Post-Order
To traverse a non-empty binary tree in preorder, perform the following operations
recursively at each node, starting with the root node:
1. Visit the root.
2. Traverse the left sub tree.
3. Traverse the right sub tree.
To traverse a non-empty binary tree in in order, perform the following operations recursively
at each node, starting with the root node:
1. Traverse the left sub tree.
2. Visit the root.
3. Traverse the right sub tree.
To traverse a non-empty binary tree in post order, perform the following operations
recursively at each node, starting with the root node:
1. Traverse the left sub tree.
2. Traverse the right sub tree.
3. Visit the root.
21. 15
7 22
BINARY TREE:
Preorder:- 15,7,22 will be displayed .
Post order:- 7,22,15 will be displayed .
In order:- 7,15,22 will be displayed .
22. SOURCE CODE:
/* Program To Implement Binary Tree Traversing */
#include < iostream.h >
#include < conio.h >
class bstree
{
public:
struct node
{
int data;
node *left;
node *right;
}*head;
void create (node *);
void inorder (node *);
void preorder (node *);
void postorder (node *);
};
void* bstree:: create(node *list)
{
node *temp1,*temp2;
int val;
if(list = = NULL)
{
list = new node;
cout<<"nEnter Data Element:: ";
cin>>list->data;
list -> left = list -> right = NULL;
}
else
23. {
cout<<"n enter the data element";
cin>>val;
temp1 = list;
while( temp1 ! = NULL )
{
temp2 = temp1;
if(temp1 -> data > val)
temp1 = temp1 -> left;
else
temp1 = temp1 -> right;
}
if(temp2 -> data > val)
{
temp2 -> left = new node;
temp2 = temp2 -> left;
temp2 -> data = val;
temp2 -> left = temp2 -> right = NULL;
}
else
{
temp2 -> right = new node;
temp2 = temp2 -> right;
temp2 -> data = val;
temp2 -> left = temp2 -> right = NULL;
}
}
return (list);
}
25. void main ( )
{
node n,*head;
head = NULL;
clrscr ( );
cout<<"nCreate A Binary Treen";
head=n.create ( head );
cout<<"n the inorder traversal gives the
following nodes";
n.inorder ( head );
getch ( );
}
OUTPUT:
26.
27. BINARY SEARCH TREE
15
7 22
A tree having left child less than parent and right child grater than the parent.
Traversals are same as binary tree.
28. SOURCE CODE:
/* Program to implement Binary search tree */
#include < iostream.h >
#include < conio.h >
class btree
{
private :
struct btreenode
{
btreenode *leftchild ;
int data ;
btreenode *rightchild ;
} *root;
public:
btree ( ) ;
void buildtree ( int num ) ;
static void insert ( btreenode **sr, int num ) ;
void traverse ( ) ;
static void inorder ( btreenode *sr ) ;
static void preorder ( btreenode *sr ) ;
static void postorder ( btreenode *sr ) ;
static void del ( btreenode *sr ) ;
~btree ( ) ;
} ;
29. btree :: btree ( )
{
root = NULL ;
}
void btree :: buildtree ( int num )
{
insert ( &root, num ) ;
}
void btree :: insert ( btreenode **sr, int num )
{
if ( *sr == NULL )
{
*sr = new btreenode ;
( *sr ) -> leftchild = NULL ;
( *sr ) -> data = num ;
( *sr ) -> rightchild = NULL ;
return ;
}
else // search the node to which new node will be attached
{
// if new data is less, traverse to left
if ( num < ( *sr ) -> data )
insert ( & ( ( *sr ) -> leftchild ), num ) ;
else
// else traverse to right
insert ( & ( ( *sr ) -> rightchild ), num ) ;
}r
eturn ;
}
30. void btree :: traverse( )
{
cout << "nIN - ORDER TRAVERSAL :: " ;
inorder ( root ) ;
cout << "nPRE - ORDER TRAVERSAL :: " ;
preorder ( root ) ;
cout << "nPOST - ORDER TRAVERSAL :: " ;
postorder ( root ) ;
}
void btree :: inorder ( btreenode *sr )
{
if ( sr != NULL )
{
inorder ( sr -> leftchild ) ;
cout << "t" << sr -> data ;
inorder ( sr -> rightchild ) ;
}
else
return ;
}
void btree :: preorder ( btreenode *sr )
{
if ( sr != NULL )
{
// print the data of a node
cout << "t" << sr -> data ;
// traverse till leftchild is not NULL
preorder ( sr -> leftchild ) ;
// traverse till rightchild is not NULL
preorder ( sr -> rightchild ) ;
}
31. else
return ;
}
void btree :: postorder ( btreenode *sr )
{
if ( sr != NULL )
{
postorder ( sr -> leftchild ) ;
postorder ( sr -> rightchild ) ;
cout << "t" << sr -> data ;
}
else
return ;
}
btree :: ~btree( )
{
del ( root ) ;
}
void btree :: del ( btreenode *sr )
{
if ( sr != NULL )
{
del ( sr -> leftchild ) ;
del ( sr -> rightchild ) ;
}
delete sr ;
}
32. void main( )
{
btree bt ;
int req, i = 1, num ;
clrscr();
cout << "n SPECIFY THE NUMBER OF ITEMS TO BE INSERTED :: " ;
cin >> req ;
while ( i + + <= req )
{
cout << "n ENTER THE DATA :: " ;
cin >> num ;
bt.buildtree ( num ) ;
}
bt.traverse( ) ;
getch();
}
OUTPUT:
33. SPARSE MATRIX
AIM: Write a program in C++ to implement ADDITION and MULTIPLICTION of two SPARSE
matrixes.
THEORY:
If a lot of elements from a matrix have a value 0 then the matrix is known as
SPARSE MATRIX. If the matrix is sparse we must consider an alternate way of representing it
rather the normal row major or column major arrangement. This is because if majority of elements
of the matrix are 0 then an alternative through which we can store only the non-zero elements and
keep intact the functionality of the matrix can save a lot of memory space.
Example:
Sparse matrix of dimension 7 x 7.
COLUMNS
0 1 2 3 4 5 6
0 0 0 0 -5 0 0 0
1 0 4 0 0 0 0 7
2 0 0 0 0 9 0 0
ROWS 3 0 3 0 2 0 0 0
4 1 0 2 0 0 0 0
5 0 0 0 0 0 0 0
6 0 0 8 0 0 0 0
34.
35. SOURCE CODE:
/*Program to demonstrate addition and multiplication of Two Sparse Matrix */
#include < iostream.h >
#include < conio.h >
#define x 25
class sparce
{
private:
int a [ x ] [ x ], b [ x ] [ x ], c [ x ] [ x ], m, n, p, q;
public:
void init ( );
void input ( );
void add ( );
void mul ( );
void display ( int [25][25], int, int );
void convert( int [25][25], int, int );
};
void sparce :: init ( )
{
int i, j;
for(i = 0; i < x;i + + )
for( j = 0; j < x; j + +)
c [ i ] [ j ] = 0;
}
36. void sparce :: input()
{
int i,j;
cout<<"nEnter order Of First matrix::";
cin>>m>>n;
cout<<"nEnter order Of Second matrix::";
cin>>p>>q;
cout<<"nEnter"<<m*n<<"Elements Into First Matrixn";
for(i=0;i<m;i++)
for( j = 0; j < n; j + + )
cin>> a[ i ] [ j ];
cout<<"nEnter"<<p*q<<"Elements Into Second Matrixn";
for(i = 0; i < p ; i + + )
for ( j = 0; j < q ; j + + )
cin>>b [ i ] [ j ];
}
void sparce :: add ( )
{
int i, j;
if( m = = p && n = = q )
{
for( i = 0 ; i < m ; i + + )
for( j = 0; j < n; j + + )
c[ i ] [ j ] = a [ i ][ j ] + b [ i ] [ j ];
convert( c, m, n);
}
else
cout<<"nAddition Is Not Possible";
}
37. void sparce :: mul ( )
{
int i, j, k;
if(n = = p)
{
for( i = 0; i < m; i + +)
for( j = 0; j < q; j + + )
for( k = 0; k < n; k + + )
c[ I ] [ j ] + = a [ I ] [ k ] * b [ k ] [ j ];
convert(c, m, n);
}
else
cout<<"n Multiplecation Is Not Possible";
}
void sparce :: display(int c[25][25], int m, int n)
{
int i,j;
for( i = 0 ;i < m; i + + )
{
for( j = 0 ; j < n ; j + + )
cout<<c [ i ] [ j ]<<"t";
cout<<"n";
}
}
38. void sparce :: convert(int c[25][25], int m, int n)
{
int i, j, k = 1,t = 0;
int sp[25][25];
for( i = 0 ; i < m ; i + +)
for( j = 0 ; j < n ; j + + )
if(c [ i ] [ j ] ! = 0 )
{
sp [ k ] [ 0 ] = i;
sp [ k ] [ 1 ] = j;
sp [ k ] [ 2 ] = c [ i ] [ j ];
k + + ;
t + + ;
}
sp[ 0 ] [ 0 ] = m;
sp[ 0 ] [ 1 ] = n;
sp[ 0 ] [ 2 ] = t;
display( sp, k, 3);
}
void main ( )
{
sparce ob;
clrscr ( );
ob.init ( );
ob.input ( );
cout<<"nAddition of Two Sparce Matrixn";
ob.add ( );
ob.init ( );
cout<<"nMultiplecation Of Two Sparce Matrixn";
ob.mul ( );
getch ( );
}
40. INFIX TO POSTFIX CONVERTIONic
Suppose Q is an arithmetic expression written in infix notation. This algorithm finds the
equivalent postfix expression P.
Step 1. Push “(“ onto stack and add “)” to the end of Q.
2. Scan Q from left to right and repeat step 3 to 6 for each element of Q until the
stack is empty.
3. If an operand is encountered , add it to p.
4. If a left parenthesis is encountered ,push it onto stack.
5 If an operator * is encountered , then:
a. repeatedly pop from stack and top each operator (on the top of stack ) which
has the same precedence or higher precedence than * .
b. Add * to stack.
6. If a right parenthesis is encountered , then:
a. repeatedly from stack and add to P each operator (on the top of stack) until a left
parenthesis is encountered.
b. remove the left parenthesis [ Do not add the left parenthesis top] [End of if
structure] [End of step 2 loop]
7. Exit
41. Symbol scanned stack Expression P
1 A ( A
2 + ( + A
3 ( ( + ( A
4 B ( + ( AB
5 * ( + ( * AB
6 C ( + ( * ABC
7 - ( + ( - ABC*
8 ( ( + ( - ( ABC*
9 D ( + ( - ( ABC*D
10 / ( + ( - ( / ABC*D
11 E ( + ( - ( / ABC*DE
12 ^ ( + ( - ( / ^ ABC*DE
13 F ( + ( - ( / ^ ABC*DEF
14 ) ( + ( - ABC*DEF^/
15 * ( + ( - * ABC*DEF^/
16 G ( + ( - * ABC*DEF^/G
17 ) ( + ABC*DEF^/G*-
18 * ( + * ABC*DEF^/G*-
19 H ( + * ABC*DEF^/G*-H
20 ) ABC*DEF^/G*-H*+
(A+(B*C-(D/E^F)*G)*H)
42. SOURCE CODE:
/* Program To implement infix to postfix Expression */
#include < iostream.h >
#include< process.h >
#include < conio.h >
char stack[30], postfix[30], infix[30];
int top = - 1;
int pri( char x )
{i
nt value;
switch ( x )
{
case ')': value=0; break;
case '+': case '-': value=1; break;
case '*': case '/': case '%': value=2; break;
case '^': value=3; break;
case '(': value=4; break;
default: cout<<"INVALID EXPRESSION !!!!!!";
exit(1);
} return value;
}
46. POSTFIX EVALUATION
THEORY:
Reverse Polish notation is a mathematical notation wherein every operator
follows all of its operands. It is also known as Postfix notation and is parenthesis free.
In Reverse Polish notation the operators follow their operands; for instance, to add three
and four, one would write “3 4 +” rather than “3 + 4”. If there are multiple operations, the operator
is given immediately after its second operand; so the expression written “3 − 4 + 5” in
conventional infix notation would be written “3 4 − 5 +” in RPN: first subtract 4 from 3, then add 5
to that.
Infix Expression: Any expression in the standard form like "2*3-4/5" is an Infix(In order)
expression.
Postfix Expression: The Postfix(Post order) form of the above expression is "23*45/-".
Postfix Evaluation: In normal algebra we use the infix notation like a+b*c. The
corresponding postfix notation is abc*+. The algorithm for the conversion is as follows:
•Scan the Postfix string from left to right.
•Initialize an empty stack.
•If the scanned character is an operand, add it to the stack. If the scanned character is an
operator, there will be at least two operands in the stack
If the scanned character is an Operator, then we store the top most element of the
stack(topStack) in a variable temp. Pop the stack. Now evaluate
topStack(Operator)temp. Let the result of this operation be retVal. Pop the stack and
Push retVal into the stack.
Repeat this step till all the characters are scanned.
•After all characters are scanned, we will have only one element in the stack. Return
topStack.
47. Example:
Postfix String: 1 2 3 * + 4 - .
Initially the Stack is empty. Now, the first three characters scanned are 1,2 and 3, which are
operands. Thus they will be pushed into the stack in that order.
Stack Expression
Next character scanned is "*", which is an operator. Thus, we pop the top two elements from the
stack and perform the "*" operation with the two operands. The second operand will be the first
element that is popped.
Stack Expression
The value of the expression(2*3) that has been evaluated(6) is pushed into the stack.
Stack Expression
48. Next character scanned is "+", which is an operator. Thus, we pop the top two elements from the
stack and perform the "+" operation with the two operands. The second operand will be the first
element that is popped.
Stack Expression
The value of the expression(1+6) that has been evaluated(7) is pushed into the stack.
Stack Expression
Next character scanned is "4", which is added to the stack.
Stack Expression
Next character scanned is "-", which is an operator. Thus, we pop the top two elements from the
stack and perform the "-" operation with the two operands. The second operand will be the first
element that is popped.
49. The value of the expression(7-4) that has been evaluated(3) is pushed into the stack.
Stack Expression
The value of the expression(7-4) that has been evaluated(3) is pushed into the stack.
Stack Expression
Now, since all the characters are scanned, the remaining element in the stack (there will be only one End result:
Postfix String : 1 2 3 * + 4 -
Result : 3
50. SOURCE CODE:
/*Program To Evaluate Postfix Expression */
#include < iostream.h >
#include < conio.h >
#include < math.h >
#include < string.h >
class postfix
{ private:
int stack[50], len, top;
char post[50];
public:
postfix ( );
void push ( int );
int pop ( );
int pfix ( );
};
void postfix :: postfix ( )
{
top = - 1;
}i
nt postfix :: pfix ( )
{
int a, b, i, temp;
cout<<"nEnter Postfix Expression::";
cin>>post;
len = strlen ( post );
post [ len] = '#';
51. for( i = 0 ; post [ i ] ! = '#' ; i + +)
{
if( post [ i ] <= '9' && post [ i ] >= '0')
push( post [ i ] - 48);
else
{
a = pop ( );
b = pop ( );
switch ( post [ i ])
{
case '+': temp = b + a; break;
case '-': temp = b
- a; break;
case '*': temp = b * a; break;
case '/': temp =
b/a; break;
case '%': temp =
b%a; break;
case '^': temp =
pow( b, a );
}
push ( temp );
}
}
return( pop ( ) );
}
52. void postfix :: push( int x )
{
stack[ + + top ] = x;
}i
nt postfix :: pop ( )
{
int x = stack [ top ];
top- -;
return x;
}
void main ( )
{
int x;
postfix ob;
clrscr ( );
x=ob.pfix ( );
cout<<"nResult Of Postfix Expression Ist"<<x;
getch ( );
}
OUTPUT:
53. Quick Sort
11 7 21 3 46 89 2 34
right
1)When pivot is at left end,
1)Compare a[pivot] with a[right] element
if (a[pivot] < a[right]) then right--
else
swap a[pivot] and a[right]
2)When pivot is at right end,
Compare a[pivot] with a[left] element
if (a[left] < a[pivot]) then left++
else
swap a[left] and a[pivot]
pivot
left
55. STEP7: 2 7 11 3 46 89 21 34
left, pivot right
STEP8: 2 7 11 3 46 89 21 34
left, pivot right
STEP9: 2 7 3 11 46 89 21 34
left right, pivot
STEP10: 2 7 3 11 46 89 21 34
left, right, pivot
Here we will stop the main process as the left and right pointers are equal.
Now see the elements left to ‘11’ are less than ‘11’ and elements right to ‘11’ are grater than ‘11’.
Now divide the main list into 2 sub lists such as(2,7,3) and (46,89,21,34) and do the same above
process.
56. #include<stdio.h>
#include<conio.h>
#define MAXSIZE 500
Source code
void quickSort(int elements[], int maxsize);
void sort(int elements[], int left, int right);
int elements[MAXSIZE];
int main()
{ int i, maxsize;
printf(“nHow many elements you want to sort: “);
scanf(“%d”,&maxsize);
printf(“nEnter the values one by one: “);
for (i = 0; i < maxsize; i++)
{
printf (“nEnter element %i :”,i);
scanf(“%d”,&elements[i]);
}
57. printf(“nArray before sorting:n”);
for (i = 0; i < maxsize; i++)
printf(“[%i], “,elements[i]);
printf (“n”);
quickSort(elements, maxsize);
printf(“nArray after sorting:n”);
for (i = 0; i < maxsize; i++)
printf(“[%i], “, elements[i]);
}
void quickSort(int elements[], int maxsize)
{
sort(elements, 0, maxsize - 1);
}
void sort(int elements[], int left, int right)
{
int pivot, l, r;
l = left;
r = right;
pivot = elements[left];
while (left < right)
{
while ((elements[right] >= pivot) && (left < right))
right—;
58. if (left != right)
{
elements[left] = elements[right];
left++;
}
while ((elements[left] <= pivot) && (left < right))
left++;
if (left != right)
{
elements[right] = elements[left];
right—;
}}
elements[left] = pivot;
pivot = left;
left = l;
right = r;
if (left < pivot)
sort(elements, left, pivot - 1);
if (right > pivot)
sort(elements, pivot + 1, right);
}
59. Consider the elements as shown,
77 33 44 11 88 22 66 55
77 0
Selection sort
min i
Here min is compared with a[1]
as min is > a[1]
min=a[1]
33 0
min i
This min is compared with a[2] ,as this is < a[2]
min is same that is 33
This min is compared with a[3] ,as this is > a[3]
min =a[3].
11 0
min I
Now this is compared with a[4],a[5],a[6],a[7] as min is less than all of these min
remains 33
At last swap min and a[i] like this continue the process with i=1,2,3……
60. SOURCE CODE:
#include < iostream.h >
#include < conio.h >
class selsort
{public : void sort(int *, int);
};
void selsort::sort(int *a, int n)
{
int i, j, x, min, temp;
for( i = 0 ; i < ( n – 1 ) ; i + + )
{
x = i; min = a [ i ];
for( j = i + 1; j < n; j + + )
{i
f( min > a [ j ] )
{
min = a [ j ];
x = j;
}} temp = a [ i ] ; a [ i ] = a [ x ]; a [ x ] = temp;
}}
void main( )
{int a[50], n, i;
clrscr( );
61. cout<<"n ENTER THE SIZE OF THE ARRAY: nt ";
cin>>n;
cout<<"n ENTER THE ELEMENTS:nt";
for( i = 0 ;i < n ;i + + )
cin>>a [ i ];
cout<<"n ELEMENTS BEFORE SORTING:nt";
for( i = 0 ; i < n ; i + + )
cout<<a[i]<<"t";
selsort obj; obj.sort(a,n);
cout<<"n ELEMENTS AFTER SORTING ARE:nt";
for( i = 0 ; i < n ; i + + )
cout<<a[i]<<"t";
getch();
}
OUTPUT:
62. LINEAR SEARCH
10 20 30 40 50 60 70
0 1 2 3 4 5 6
•Here we want to search for ‘50’.
• So compare ’50’ with a[i] where i=0,1,2,3,….
If (a[i]==50)
Then element is found at location i that is 4
Else
i++
•Here the time complexity is O(n).
63. SOURCE CODE:
#include < iostream.h >
#include < conio.h >
class lsearch
{
private:
int a[50], n, count, key;
public:
void init ( );
void linear ( );
};
void lsearch::init ( )
{
count = 0;
}
void lsearch::linear ( )
{
int i;
clrscr ( );
cout<<"nENTER SIZE OF AN ARRAY :: ";
cin>>n;
cout<<"nnENTER "<<n<<" ELEMENTS INTO AN ARRAY ::";
for( i = 0; i < n; i + +)
cin>> a [ i ];
cout<<"nnENTER SEARCH ELEMENT :: ";
cin>>key;
cout<<"nnELEMENTS IN ARRAY ARE :n";
64. for( i = 0; i < n; i + +)
cout<< a [ i ]<<"t";
for( i = 0; i < n; i + + )
if(a [ i ] = = key)
{
count + +;
break;
}i
f( count = = 1 )
cout<<"nn ELEMENT IS FOUND IN
"<< ( i + 1)<<" LOCATION";
else
cout<<"nELEMENT IS NOT
FOUND....";
}
void main ( )
{
lsearch ob;
clrscr ( );
ob.init ();
ob.linear ( );
getch ( );
}
66. BINARY SEARCH
•Here elements must be in Ascending/Descending order.
•Consider the elements in ascending order
711 15 23 46 64 71 83
low high
here low=0 and high=7
Then calculate mid=(low+high)/2
•Let us search for k=71
•If (a[mid]==k)
then element is found at ‘mid’ location
•If(k<a[mid])
then high=mid-1
else
low=mid+1
•Repeat the previous steps tell low and high are equal.
67. SOURCE CODE:
/*Program To Implement Binary Search */
#include < iostream.h >
#include < conio.h >
class bsearch
{
private :
int a[50], n , x;
public :
void binary ( );
};
void bsearch::binary ( )
{
int i, j, temp, mid, beg, end;
beg = 0;
cout<<"nnENTER THE SIZE OF THE ARRAY :: ";
cin>>n;
end = n - 1;
cout<<"nnENTER THE ELEMENTS OF THE ARRAY :: ";
for( i = 0; i < n; i + +)
cin>>a[i];
cout<<"nnELEMENTS BEFORE BEFORE SORTING ARE :: ";
for( i = 0; i < n; i + + )
cout<< a [ i ]<<" ";
68. for( i = 0; i < n; i + + )
{
for( j = i + 1; j < n; j + +)
{
if( a[ i ] > a[ j ] )
{
temp = a [ i ];
a[ i ] = a[ j ];
a[ j ] = temp;
}
}
}
cout<<"nnELEMENTS AFTER SORTING ARE :: ";
for( i = 0; i < n; i + + )
cout<<a[ i ]<<" ";
cout<<"nnENTER THE ELEMENT TO BE SEARCHED :: ";
cin>>x;
while ( beg < = end )
{
mid = ( beg + end ) / 2;
if ( a [ mid ] = = x )
{
69. cout<<"nSEARCHING IS SUCCESSFUL AND THE ELEMENTS IS
PRESENT AT "<< ( mid + 1 )<<" LOCATION";
return;
}
else if(x<a[mid])
end = mid - 1;
else beg = mid + 1;
}
cout<<"n SEARCH IS UNSUCCESSFUL";
}
void main ( )
{
bsearch obj;
clrscr ( );
obj . binary ( );
getch ( );
}
OUTPUT:
70. POLINOMIAL ADDITION AND MULTIPLICATION
•1 expression: 3x2+2x+1
Store all the coefficients 1,2,3 into an array1.
•1 expression: 2x2+1x+2
Store all the coefficients 2,1,2 into an array2.
ADDITION:
3x2+2x+1
2x2+1x+2
5x2+3x+3
Store the result expression coefficients in array3
71. SOURCE CODE:
/*Program To Demonstrate Addition And Multiplication Of Two Polynomial Expression */
#include < iostream.h >
#include < conio.h >
#define n 100
class poly
{
private:
int a[n], b[n], add[n], mul[n], p, q, at;
public:
void init ( );
void input ( );
void process ( );
void display ( );
};
void poly :: init ( )
{
int i;
for( i = 0; i < n; i + + )
a[ i ] = b [ i ] = add[ i ] = mul[ i ] = 0;
}
72. void poly :: input ( )
{
int i;
cout<<"nEnter Degree Of First Polynomial::";
cin>>p;
cout<<"nEnter Degree Of Second
Polynomial::";
cin>>q;
cout<<"nEnter Values First
Polynomialn";
for( i = 0; i <= p; i + + )
{
cout<<"nEnter X^"<<i<<"
Th Coefficient";
cin>>a[ i ];
}
cout<<"nEnter Values First
Polynomialn";
for( i = 0; i <= q; i + + )
{
cout<<"nEnter X^"<<i<<"
Th Coefficient";
cin>>b[ i ];
}
}
73. void poly :: process ( )
{
int i, j;
if( p > q )
at = p;
else
at = q;
for ( i = 0; i <= at; i + +)
add[ i ] = a[ i ] + b[ i ];
for( i = 0; i <= p; i + + )
for( j = 0; j <= q; j + + )
mul [ i + j ] + = a [ i ] * b [ j ];
}
void poly :: display ( )
{
int i;
cout<<"Addition Of Two Polynomial Expressions Arenn";
for( i = at; i >=0 ; i - -)
cout<<add[i]<<"X^"<<i<<"+";
cout<<"nnMultiplecation Of Two Polynomial Expressions Arenn";
for( i = p + q; i > = 0; i - -)
cout<<mul[i]<<"X^"<< i <<"+";
}
75. SINGLE LINKED LIST
THEORY:
Figure shows a Linked List. Each item in the list is called a node and contain two fields, a data
field and a next address field. The data field holds the actual element on the list. The next address
field contains the address of the next node in the list. Such an address which is used to access a
particular node, is known as a pointer. The entire linked list is accesses from an external pointer list,
that points to the first node in the list. The next field of last node in the list contains a special value,
known as NULL. The null pointer is used to signal the end of the list.
The singly-linked list is the most basic of all the linked data structures. A singly-linked list
is simply a sequence of dynamically allocated objects, each of which refers to its successor in the
list. Despite this obvious simplicity, there are myriad implementation variations.
The following code inserts a node after an existing node in a singly linked list. The diagram
shows how it works. Inserting a node before an existing one cannot be done; instead, you have to
locate it while keeping track of the previous node.
76. Similarly, we have functions for removing the node after a given node, and for removing a
node from the beginning of the list. The diagram demonstrates the former. To find and
remove a particular node, one must again keep track of the previous element.
77. SOURCE CODE:
/*Program To Implement Single Linked list */
#include< stdio.h >
#include < iostream.h >
#include < conio.h >
#include < process.h >
#include< alloc.h >
class slist
{
private:
struct list
{i
nt data;
struct list *next;
}*start,*temp,*curr,*add,*tem,*addr;
public:
void init ( );
void create ( );
void disp ( );
list *search ( int );
void insert ( );
void del ( );
};
78. void slist :: init ( )
{
start = temp = curr = NULL;
}
void slist::create ( )
{
char ch;
temp = new list;
cout<<"n ENTER THE DATA TO BE STORED n";
cin>> temp->data;
temp->next = NULL;
start = curr = temp;
cout<<"n DO YOU WANT TO INSERT ANOTHER NODE (Y/N)";
cin>>ch;
while( ch = = 'y' )
{
temp = new list;
cout<<"n ENTER DATA TO BE STORED:n";
cin>>temp->data;
temp->next = NULL;
curr->next = temp;
curr = temp;
cout<<"n DO YOU WANT TO INSERT ANOTHER NODE (Y/N):";
cin>>ch;
}
}
79. void slist :: disp ( )
{
if( start = = NULL)
cout<<"n LIST IS EMPTY";
else
{
cout<<"n DATA PRESENT IN A LIST IS n";
temp = start;
while( temp -> next ! = NULL)
{
cout<<"|"<<temp->data<<"|"<<temp->next<<"|-->";
temp = temp -> next;
}
cout<<"|"<<temp->data<<"|"<<temp->next<<"|";
}
}
slist::list *slist :: search( int key)
{
temp = start;
while( temp -> next ! = NULL)
{
if( temp->data = = key )
return temp;
else
temp = temp->next;
}i
f( temp->next = = NULL )
80. if( temp->data = = key )
return temp;
else
return NULL;
}
void slist:: insert ( )
{
int key;
cout<<"n ENTER DATA AFTER WHICH WE CAN INSERT NEW NODE:";
cin>>key;
add=search(key);
if( add = = NULL )
cout<<"n NODE IS NOT FOUND";
else
{
temp = new list;
cout<<"n ENTER INSERTED ELEMENT";
cin>>temp->data;
if( add->next = = NULL)
{
temp->next = NULL;
add->next = temp;
curr = temp;
}
81. else
{
addr = add->next;
add->next = temp;
temp->next = addr;
}
}
}
void slist :: del ( )
{
int key;
cout<<"n ENTER NODE DATA SHOULD BE DELETE:n";
cin>>key;
add = search ( key );
if( add = = NULL )
cout<<"n NODE IS NOT FOUNDn";
else
if( curr = = add )
{
curr = start;
while( curr->next ! = NULL)
{
temp = curr;
curr = curr->next;
}
83. cout<<"n 1. CREATE n 2. DISPLAY n 3. INSERT n 4. DELETE n 5. SEARCH n 6.EXIT n";
cout<<"n *************************n";
do
{
cout<<"n ENTER YOUR CHOICE n";
cin>>ch;
switch ( ch )
{
case 1: ob.create ( );
break;
case 2: ob.disp ( );
break;
case 3: ob.insert ( );
break;
case 4: ob.del ( );
break;
case 5: cout<<"n ENTER THE ELEMENT TO SEARCH";
cin>>key;
temp=ob.search(key);
if( temp = = NULL)
cout<<"n ELEMENT IS NOT FOUND n";
else
cout<<"n ELEMENT IS FOUND n";
break;
case 6: exit(0);
default: cout<<"n INVALID CHOICE n";
}
}while( ch ! = 0 );
getch ( );
}
85. SINGLE CIRCULAR LINKED LIST
THEORY:
The linked list that we have seen so far is often know as linear lists. The elements of such
a linked list can be accessed, first by setting up a pointer pointing to the first node in the list and
then traversing the entire list using this pointer. Although a linear linked list is a useful data
structure, it has several shortcomings.
86. SOURCE CODE:
/* Program to implement single circular linked list */
#include<iostream.h>
#include<conio.h>
#include<process.h>
#include<alloc.h>
class clist
{
private:
struct list
{
int data;
struct list *next;
}*start,*temp,*curr,*add,*tem,*addr;
public:
void init(); void creat();
void display(); list *search(int);
void insert(); void del();
};
void clist::init()
{
start=temp=curr=NULL;
}
87. void clist::creat()
{
char ch;
temp=new list;
cout<<"n ENTER ENTER DATA TO BE STORED ::";
cin>>temp->data;
cout<<"nADDRESS OF STARTING NODE :: "<<temp;
temp->next=start;
start=curr=temp;
cout<<"nDO YOU WANT TO INSERT ANOTHER NODE (y/n) :: ";
cin>>ch;
while(ch=='y')
{
temp=new list;
cout<<"n ENTER DATA TO BE STORED :: ";
cin>>temp->data;
temp->next=start;
curr->next=temp;
curr=temp;
cout<<"nDO YOU WANT TO INSERT ANOTHER NODE (y/n) :: ";
cin>>ch;
}
}
88. void clist::display()
{
if(start==NULL)
cout<<"nLIST IS EMPTY.....";
else
cout<<"nDATA PRESENT IN A LIST IS :: n";
temp=start;
while(temp->next!=start)
{
cout<<"|"<<temp->data<<"|"<<temp->next<<"|-->";
temp=temp->next;
}
cout<<"|"<<temp->data<<"|"<<temp->next<<"|";
}
clist::list *clist::search(int key)
{
temp=start;
while(temp->next!=start)
{
if(temp->data==key)
return temp;
else
temp=temp->next;
}
89. if(temp->next==NULL)
{
if(temp->data==key)
return temp;
else
return NULL;
} return NULL;
}
void clist::insert()
{
int key;
cout<<"n ENTER DATA AFTER WHICH WE CAN INSERTED NEW NODE ::
";
cin>>key;
add=search(key);
if(add==NULL)
cout<<"n NODE IS NOT FOUND ....";
else
{
temp=new list;
cout<<"n ENTER INSERTED ELEMENT :: ";
cin>>temp->data;
90. if(add->next==start)
{
temp->next=start;
add->next=temp;
curr=temp;
}
else
{
addr=add->next;
add->next=temp;
temp->next=addr;
}
}
}
void clist::del()
{
int key;
cout<<"nEnter node to deleted:";
cin>>key;
add=search(key);
if(add==NULL)
cout<<"nNode is not found";
else if(curr==add)
92. void main()
{
clist ob;
int key,ch;
clist::list *temp;
clrscr();
cout<<"nCIRCULAR LINKED LIST n";
cout<<"n1.Createn2.Displayn3.Insertn4.Deleten5.Searchn6.Exitn";
do
{
cout<<"nEnter your choice";
cin>>ch;
switch(ch)
{
case 1:ob.creat();
break;
case 2:ob.display();
break;
case 3:ob.insert();
break;
case 4:ob.del();
break;
93. case 5:cout<<"nEnter search element";
cin>>key;
temp=ob.search(key);
if(temp==NULL)
cout<<"nElement is not found";
else
cout<<"nElement is found";
break;
case 6:exit(0);
default:cout<<"Invalid choice";
}
}while(ch!=6);
getch();
}
95. DOUBLE LINKED LIST
AIM: Write a program in C++ to implement DOUBLE LINKED LIST
THEORY:
A two-way list is a linear collection of data elements, called nodes, where each node N is
divided into three parts:
•An item data field.
•A pointer field next which contains the location of the next node in the list.
•A pointer field prev which contains the location of the previous node in the list.
The list requires two list pointer variables: FIRST, which points to the first node in the list, and
LAST, which points to the last node in the list. The figure contains a schematic diagram of such a
list. Observe that the null pointer appears in the next field of the last node in the list and also in the
prev field of the first node in the list. Observe that, using the variable FIRST and the pointer field
next, we can traverse a two-way list in the forward direction as before. On the other hand, using the
variable LAST and the pointer field prev, we can also traverse the list in the backward direction.
97. SOURCE CODE:
/* Program to implement Double linked list */
#include<iostream.h>
#include<conio.h>
#include<process.h>
#include<alloc.h>
class dlist
{
private:
struct list
{
int data;
struct list *next,*prev;
}*start,*temp,*curr,*add,*addr,*tem;
public:
void init();
void creat(); void display();
list *search(int);
void insert(); void del();
};
void dlist::init()
{
start=temp=curr=NULL;
}
98. void dlist::creat()
{
char ch;
temp=new list;
cout<<"nENTER DATA TO BE STORED :: ";
cin>>temp->data;
cout<<"n STARTING NODE ADDRESS :: "<<temp<<"n";
temp->next=NULL;
temp->prev=NULL;
start=curr=temp;
cout<<"n DO YOU WANT TO INSERT ANOTHER NODE
(y/n) :: ";
cin>>ch;
while(ch=='y')
{
temp=new list;
cout<<"nENTER DATA TO BE STORED :: ";
cin>>temp->data;
temp->next=NULL;
temp->prev=curr; curr->next=temp;
curr=temp;
cout<<"nDO YOU WANT TO INSERT ANOTHER
NODE (y/n) :: ";
cin>>ch;
}
}
99. void dlist::display()
{
if(start==NULL)
cout<<"n LIST IS EMPTY....";
else
{
cout<<"n DATA PRESENT IN A LISTn:::";
temp=start;
while(temp->next!=NULL)
{
cout<<"|"<<temp->prev<<"|"<<temp->data<<"|"<<temp->next<<"|--
>";
temp=temp->next;
}
cout<<"|"<<temp->prev<<"|"<<temp->data<<"|"<<temp->next<<"|";
}
}
dlist::list *dlist::search(int key)
{
temp=start;
while(temp->next!=NULL)
{
if(temp->data==key)
100. return temp;
else
temp=temp->next;
}i
f(temp->next==NULL)
{
if(temp->data==key)
return temp;
else
return NULL;
} return NULL;
}
void dlist::insert()
{
int key;
cout<<"nENTER DATA AFTER WHICH WE CAN INSERT A
NEW NODE :: ";
cin>>key;
add=search(key);
if(add==NULL)
cout<<"n NODE IS NOT FOUND.....";
else
tem=new list;
101. cout<<"n ENTER ELEMENT TO BE SEARCHED :: ";
cin>>tem->data;
if(add->next==NULL)
{
tem->next=NULL;
tem->prev=add;
add->next=tem;
curr=tem;
}
else
{
addr=add->next;
add->next=tem;
tem->next=addr;
tem->prev=add;
}
}
void dlist::del()
{
int key;
cout<<"n ENTER NODE DATA TO BE DELETED :: ";
cin>>key;
add=search(key);
if(add==NULL)
cout<<"n NODE IS NOT FOUND :: ";
else
103. void main()
{
dlist ob;
int key,ch;
dlist::list *temp;
clrscr();
cout<<"**********DOUBLE LINKED LIST**********";
cout<<"n1.Createn2.Displayn3.Insertn4.Deleten5.Searchn6.Exitn";
do
{
cout<<"nENTER YOUR CHOICE :: ";
cin>>ch;
switch(ch)
{
case 1:ob.creat();
break;
case 2:ob.display();
break;
case 3:ob.insert();
break;
case 4:ob.del();
break;
104. case 5:cout<<"n ENTER SEARCH ELEMENT :: ";
cin>>key;
temp=ob.search(key);
if(temp==NULL)
cout<<"n ELEMENT IS NOT FOUND....";
else
cout<<"n ELEMENT IS FOUND.....";
break;
case 6:exit(0);
default:cout<<"n INVALID CHOICE....";
}
}while(ch!=6);
getch();
}
106. GRAPH TRAVERSING: DEPTH FIRST SEARCH
THEORY:
•DFS is an uninformed search that progresses by expanding the first child node
of the search tree that appears and thus going deeper and deeper until a goal node
is found, or until it hits a node that has no children. Then the search backtracks,
returning to the most recent node it hadn't finished exploring. In a non-recursive
implementation, all freshly expanded nodes are added to a LIFO stack for
exploration.
•Space complexity of DFS is much lower than BFS (breadth-first search). It also
lends itself much better to heuristic methods of choosing a likely-looking branch.
Time complexity of both algorithms are proportional to the number of vertices plus
the number of edges in the graphs they traverse (O(|V| + |E|)).
107. SOURCE CODE:
/*Program To Implement Depth First Search */
#include < iostream.h >
#include < conio.h >
#define MAX 20
class depth
{
private: int a[MAX][MAX], visited[MAX];
int n, top;
public: void init ( );
void input ( );
void dfs ( int );
};
void depth::init ( )
{ int i, j;
for( i = 0; i < MAX; i + + )
{ visited[ i ] = 0;
for( j =0; j < MAX ; j + + )
a[ i ] [ j ] = 0;
} top = - 1;
}
void depth::input ( )
{ int i, j;
cout<<"nENTER NUMBER OF NODES IN A GRAPH :: ";
108. cin>>n;
cout<<"nENTER ADJACENCY MATRIX FOR A GRAPH :: n";
for( i = 1; i <= n; i + +)
for( j = 1; j <= n; j + + )
cin>>a[ i ][ j ];
}
void depth::dfs ( int v)
{ int i;
visited[v] = 1;
cout<<v<<"->";
for( i = 1; i <= n; iI + + )
if( a [ v ] [ i ] = = 1 && visited [ i ] = = 0)
dfs ( i );
}
void main ( )
{ depth ob;
int start;
clrscr ( );
ob.init ( );
ob.input ( );
cout<<"nSTARTING NODE FOR DFS TRAVERSING :: ";
cin>>start;
cout<<"nDEPTH FIRST SEARCH TRAVERSING IS ::nn";
ob.dfs ( start );
getch ( );
}
110. GRAPH TRAVERSING: BREADTH FIRST
THEORY:
•BFS is an uninformed search method that aims to expand and examine all nodes of
a graph or combinations of sequence by systematically searching through every solution. In other
words, it exhaustively searches the entire graph or sequence without considering the goal until it
finds it.
•From the standpoint of the algorithm, all child nodes obtained by expanding a node are added
to a FIFO queue. In typical implementations, nodes that have not yet been examined for their
neighbors are placed in some container (such as a queue or linked list) called "open" and then once
examined are placed in the container "closed".
Algorithm for Breadth First Search
1.Enqueue the root node.
2.Dequeue a node and examine it.
•If the element sought is found in this node, quit the search and return a result.
•Otherwise enqueue any successors (the direct child nodes) that have not yet been
discovered.
3.If the queue is empty, every node on the graph has been examined – quit the search and
return "not found".
4.Repeat from Step 2.
111. SOURCE CODE:
/*Program To Implement Breadth First Search */
#include < iostream.h >
#include < conio.h >
#define MAX 20
class breadth
{
private:
int a[MAX][MAX], visited[MAX], queue[50];
int n, front, rear;
public:
void init ( );
void input ( );
void bfs ( );
};
void breadth::init ( )
{
int i, j;
for( i = 0; i < MAX; i + + )
{
visited [ i ] = 0;
for( j = 0; j < MAX; j + + )
a[ i ] [ j ] = 0;
} front = rear = - 1;
}
112. void breadth::input ( )
{
int i, j;
cout<<"nENTER NUMBER OF NODES IN A GRAPH :: ";
cin>>n;
cout<<"nENTER ADJACENCY MATRIX FOR A GRAPH :: n";
for( i = 1;i <= n; i + + )
for( j = 1; j <= n; j + + )
cin>>a[ i ][ j ];
}
void breadth::bfs ( )
{
int i, start;
cout<<"nSTARTING NODE FOR BFS TRAVERSING :: ";
cin>>start;
cout<<"n BREADTH FIRST SEARCH TRAVERSING IS:: n t";
cout<<start;
visited[ start ] = 1;
rear + +;
front + +;
queue[ rear ] = start;
while(front <= rear)
{
start = queue[front];
front + +;
113. for( i =1; i <= n; i + + )
{
if(a[ start ][ i ] = =1 && visited[ i ] = = 0)
{
cout<<"->"<<i;
visited[ i ] =1;
rear + +;
queue [ rear ] = i;
}
}
}
}
void main ( )
{
breadth ob;
int start;
clrscr ( );
ob.init ( );
ob.input ( );
ob.bfs ( );
getch ( );
}
115. SHORTEST PATH FOR GRAPH
THEORY:
Shortest path is nothing but the path which lies between two nodes with the lowest cost. In a
graph contain so many paths are existed between two nodes (source node to destination node) to
choose the lowest cost path to reach from source node to destination node is nothing but shortest
path algorithm. Shortest path algorithm was first proposed by E. W. DIJKSTRA.
SOURCE CODE:
/*Program To Implement Shortest Path for Graph */
#include < iostream.h >
#include < conio.h >
#define INF 9999
class stpath
{
private:
int i, j, k;
public:
void spath(int [ ][20], int );
void display(int [ ][20], int );
};
116. void stpath::spath(int a[ ][20], int n)
{
for( i = 0 ;i < n; I + + )
for( j = 0; j < n; j + + )
if(a[ i ] [ j ] = = 0)
a[ i ][ j ] = INF;
cout<<"nADJACENCY MATRIX OF COST OF EDGES ARE ::";
display( a, n );
for( k = 0; k < n; k + + )
for( i = 0; i < n; i + + )
for( j = 0; j < n; j + + )
if( a[ i ][ j ] > a[ i ] [ k] + a[ k ][ i ])
a[ i ][ j ] = a[ i ][ k ] + a[ k ][ j ];
cout<<"nADJACENCY MATRIX OF LOWEST COST OF EDGES ARE ::n";
display(a, n);
}
void stpath::display(int a[ ] [20], int n)
{
for( i = 0; i < n; i + + )
{
for( j = 0; j < n; j + + )
cout<<a[ i ][ j ]<<"t";
cout<<"n";
}
}
117. void main()
{
int i, j , n , a[20][20];
stpath ob;
clrscr();
cout<<"nENTER NUMBER OF NODES IN A GRAPH :: ";
cin>>n;
cout<<"nENTER ADJACENCY MATRIX ::n";
for( i = 0; i < n; i + + )
for( j = 0; j < n; j + + )
{
cout<<"Enter "<<i+1<<" To "<<j+1<<" Node Distance";
cin>>a[ i ] [ j ];
}
ob.spath(a, n);
getch ( );
}