Home



Github link           : Source Code Repositories (github.com)
Design programs  : https://github.com/krishnaKSA/design_programs_in_c-
Design patterns    : https://github.com/krishnaKSA/design_patterns_cplusplus
Data structures     : https://github.com/krishnaKSA/datastructures
Multithreading     : https://github.com/krishnaKSA/Multithreading


Popular posts from this blog

Binary Heap in C++

Image
Implementation Binary heap data structure in C++.  This class implemeted for MAX HEAP data structure.  Github:  sourcecode/binaryheap.h #include <iostream> #include <vector> using namespace std; /* class binary heap (priority queue) */ /* This class implemented for MAX_HEAP */ template <typename T> class binaryheap { private: int heaptype; //Max heap or min heap. This class implemented for MAX_HEAP vector<T> heap; //heap datastructure public: //constructor binaryheap(int type) :heaptype(type) {} //parameterised constructor binaryheap(T *arr, int _size) { if (_size != 0) { for (int i=0; i<_size;i++) { //push all the elements to the vector heap.push_back(arr[i]); } } //heapify for (int i = (_size / 2) - 1; i >= 0; i--) { sink(i); } } //add the element void add(T elem) { int m_size = (int)heap.size(); //add element at the back heap.push_back(elem); if (m_size != 0) { //hea...
Read more

AVL Balance Binary Search Tree in C++

Image
Implementation of AVL Balance binary search tree in C++.  Github:  sourcecode/AVLbalancedtree.h #include <iostream> #include "queueusinglinkedlist.h" using namespace std; /* AVL balanced binary search tree class*/ template <typename T> class avlbalancedbst { private: /* node */ template <typename T>class Node { public: Node<T>* left; //left tree Node<T>* right; //right tree T data; //data int height; //height of the tree int bf; //balance factor //constructor Node<T>() :left(nullptr), right(nullptr) { } }; //root node Node<T>* root; public: //constructor avlbalancedbst() :root(nullptr) { } //add element void addrecursive(T elem) { //if the element is already found, return if (findelement(root, elem)) { return; } //add element root = addrecursive(root, elem); } //recursive call to add the element to the tree Node<T>* addrecursive(Node<T>* node, T elem) { //...
Read more

Trie in C++

Image
 Implementation of Trie data structure in C++. GitHub:  sourcecode/trie.h #include <iostream> #include <unordered_map> #include <string> using namespace std; /* trie class */ class trie { public: //trienode class class trienode { public: char m_ch; //char which node holds it bool m_endofstring; //end of string //trie class should have 26 pointers (characters in alphabets) to point the child nodes, //as it takes more memory also not all the child nodes are used, instead of creating the 26 pointer nodes //used unordered_map to hold child nodes. //unorderemap is based on hash table, it doesn't store sorted values. unordered_map<char, trienode*> child; int count; //num of shared prefix for different words //constructor trienode() : m_ch{ '\0' }, m_endofstring(false), count(0) { } trienode(char ch) :m_ch(ch), m_endofstring(false),count(0) { } //add character as child of the current node...
Read more

Generic Circular Queue / Circular Buffer / Ring buffer in C++

Image
Circular queue / Circular buffer / Ring buffer: Introduction:     The intention of this design to provide the generic circular buffer which can be used for any data types. What is circular buffer ?           Circular buffer/queue is a liner data structure which has fixed size of array where both the ends are connected. This data structure works as FIFO(First In First Out) model.  That means old data is read first.  If the buffer is full or reached max size, it will start overwriting the old data from the beginning.  Circular/ring buffer is used in producer consumer problem, where consumer is not meeting the speed of the producer, Producer produces the new data and overwrite with the old data , if the buffer reached maximum size. Circular buffer is the good choice for implementing queue that has fixed maximum size. All the operation happens at constant time (push, pop).      Implementation: Source code :    source...
Read more

Template method

Image
Introduction: Template method is a behavioral design pattern that defines the skeleton of an algorithm in the super class. Subclasses override specific steps of the algorithm without changing its structure or order. The parent class maintains the algorithm's basic framework as well as sequencing. Template method is based on inheritance, and its works in class level. So its static. When to use,  Different components have  significant similarities, but demonstrate no reuse of common interface or implementation. If a change common to both components becomes necessary, duplicate effort must be expended. How to use,  Examine the algorithm, and decide which steps are standard and which steps are peculiar to each of the current classes. Define a new abstract base class. Move the shell of the algorithm (now called the "template method") and the definition of all standard steps to the new base class. Define a placeholder or "hook" method in the base class for each step t...
Read more

Stack using array in C++

Implemenation of stack class using array in c++.  GitHub :  sourcecode/stackusingarray.h #ifndef _STACK_USING_ARRAY_H #define _STACK_USING_ARRAY_H #include <iostream> using namespace std; #define MAX_ARRAY_SIZE 10 /* stack class usign array */ template <typename T> class stackarr { private: T arr[10]; //static array int size; int index; //helper functions inline void increaseSize() { ++size; } inline void decreaseSize() { --size; } public: //constructor stackarr() :size(MAX_ARRAY_SIZE),index(-1) { } //push element to the stack void push(T elem) { //when max size reached if (MAX_ARRAY_SIZE == size) { cerr << "stack reached max size" << endl; } else { arr[++index] = elem; increaseSize(); } } //Get the top element of the stack T top() { if (!isEmpty()) { //return the data from the array return arr[index]; } else { //if stack is empty cerr << "Top(): empty stack"...
Read more

Observer pattern

Image
 Introduction: Observer  is a behavioral design pattern that lets you define a subscription mechanism to notify multiple objects about any events that happen to the object they’re observing. How to use, Differentiate between the core (or independent) functionality and the optional (or dependent) functionality. Model the independent functionality with a "publisher/subject" abstraction. Model the dependent functionality with an "observer/listener" hierarchy. The publisher is coupled only to the Observer base class. The client configures the number and type of Observers. Observers register themselves with the publisher. The publisher broadcasts events to all registered Observers. The publisher may "push" information at the Observers, or, the Observers may "pull" the information they need from the Subject. UML class diagram: Example, Design a travel agency system to inform the passenger about bus arrival or delay notification system. There are two di...
Read more

Abstract Factory Pattern

Image
 Introduction: Abstract factory pattern is a creational pattern that provides interface to produce family of related products without specifying their (product) concrete classes. If an application is to be portable, it needs to encapsulate platform dependencies. i.e. operating system, DB. Provide a level of indirection that abstracts the creation of families of related or dependent objects without directly specifying their concrete classes. The "factory" object has the responsibility for providing creation services for the entire platform family. Clients never create platform objects directly, they ask the factory to do that for them. This mechanism makes exchanging product families easy because the specific class of the factory object appears only once in the application - where it is instantiated. The application can wholesale replace the entire family of products simply by instantiating a different concrete instance of the abstract factory. UML diagram: When to use,  Use a...
Read more

Stack using Linkedlist in C++

Implementation of stack datastructure using linkedlist. Here, I have used Linkedlist class which I have implemented https://learnprogrammingconcepts2023.blogspot.com/2023/06/linkedlist-implementation-in-c.html.  GitHub : sourcecode/stacksinglelinkedlist.h #ifndef _STACK_SINGLE_LINKEDLIST_H #define _STACK_SINGLE_LINKEDLIST_H /* Stack class using linked list */ template <typename T> class liststack { linkedList<T>* stack; //linkedlist public: //constructor liststack() { stack = new linkedList<T>(); } //push the data to the stack void push(T elem) { //add the data as last element in the stack. stack->addlast(elem); } //Get the top element in the stack. T top() { if (stack->isEmpty()) { cout << "empty list" << endl; //return -1; } //get the last element of the linked list return stack->peeklast(); } //pop the last element in the stack void pop() { if (stack->isEmpty()) { cout << ...
Read more

Strategy Pattern

Image
 Introduction: Strategy pattern is a behavioral design pattern that lets you define a family of algorithms, put them into separate classes, and make their objects interchangeable.  Scenario,  We are building the navigation app for travelers. The functionality of the app is to provide the fastest route from source to designation. Initially decided to provide the support only for four wheelers. Later customer requested to add support for public transport, pedestrians (by walk), and so on.  The technical part of maintain the code became very difficult since we keep adding the new routing algorithms into the main navigation class. Navigation class size increased , also became difficult to extend further for new algorithms. Strategy pattern helps to resolve this issue by creating a new strategy abstract class and define all these algorithms into separate derived class from abstract strategy class.  Context class holds the object of the strategy class. Context class d...
Read more