diff --git a/.github/code-of-conduct.md b/.github/code-of-conduct.md
new file mode 100644
index 00000000..f809c8b0
--- /dev/null
+++ b/.github/code-of-conduct.md
@@ -0,0 +1,40 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
+
+## Our Standards
+
+Examples of behavior that contributes to creating a positive environment include:
+
+* Using welcoming and inclusive language
+* Being respectful of differing viewpoints and experiences
+* Gracefully accepting constructive criticism
+* Focusing on what is best for the community
+* Showing empathy towards other community members
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery and unwelcome sexual attention or advances
+* Trolling, insulting/derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or electronic address, without explicit permission
+* Other conduct which could reasonably be considered inappropriate in a professional setting
+
+## Our Responsibilities
+
+Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
+
+## Scope
+
+This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/4/
diff --git a/.github/contributing.md b/.github/contributing.md
new file mode 100644
index 00000000..01f66006
--- /dev/null
+++ b/.github/contributing.md
@@ -0,0 +1,3 @@
+## Contributing
+
+> Please note that this project is released with a [Contributor Code of Conduct](code-of-conduct.md). By participating in this project you agree to abide by its terms.
\ No newline at end of file
diff --git a/.github/issue-template.md b/.github/issue-template.md
new file mode 100644
index 00000000..99764fe7
--- /dev/null
+++ b/.github/issue-template.md
@@ -0,0 +1 @@
+I am creating an issue because...
diff --git a/.github/pull-request-template.md b/.github/pull-request-template.md
new file mode 100644
index 00000000..3bc0935e
--- /dev/null
+++ b/.github/pull-request-template.md
@@ -0,0 +1,6 @@
+I am creating a pull request for...
+
+- [ ] New algorithm
+- [ ] Update to an algorithm
+- [ ] Fix an error
+- [ ] Other - *Describe below*
\ No newline at end of file
diff --git a/README.md b/README.md
deleted file mode 100644
index 6886d0f2..00000000
--- a/README.md
+++ /dev/null
@@ -1,46 +0,0 @@
-
-
-
-## Contents
-
-- [Arithmetic Analysis](arithmetic-analysis)
-- [File Transfer Protocol](file-transfer-protocol)
-- [Greedy Algorithms](greedy-algorithms)
-- [Graphs](graphs)
-- [Math](math)
-- [Neutral Network](neutral-network)
-- [Ciphers](ciphers)
-- [Data Structures](data-structures)
-- [Dynamic Programming](dynamic-programming)
-- [Hashes](hashes)
-- [Searches](searches)
-- [Sorting](sorting)
-- [Strings](strings)
-- [Traversals](traversals)
-
-## License
-
-This work is licensed under a [MIT License](https://github.com/abranhe/algorithms/blob/master/LICENSE)
-
-[![MIT IMG][mit-license]]((https://github.com/abranhe/algorithms/blob/master/LICENSE))
-
-To the extent possible under law, [Carlos Abraham](https://go.abranhe.com/github) has waived all copyright and related or neighboring rights to this work.
-
-
-[mit-license]: https://cdn.abraham.gq/projects/algorithms/mit-license.png
diff --git a/algorithms/Networks/Hamming_Code/hamming_code_reciever.cpp b/algorithms/Networks/Hamming_Code/hamming_code_reciever.cpp
new file mode 100644
index 00000000..803fbdc5
--- /dev/null
+++ b/algorithms/Networks/Hamming_Code/hamming_code_reciever.cpp
@@ -0,0 +1,167 @@
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+
+using namespace std;
+
+#define MAX 2048
+#define port 5200
+
+
+void flip(int &a) {
+ a=!a;
+}
+
+
+void revprint(int codeword[],int n) {
+ for(int i=n-1;i>=0;i--) {
+ cout<=1) {
+ cout<<"Hence flip bit "<=0;i--) {
+ if((i+1)!=1&&(i+1)!=2&&(i+1)!=4&&(i+1)!=8) {
+ message[j--]=codeword[i];
+ }
+ }
+
+ cout<<"Message : ";
+ revprint(message,8);
+
+ int x=0;
+ for(int i=0;i<8;i++) {
+ if(message[i]==1) {
+ x+=(1<>ch;
+
+ switch(ch) {
+ case 1:{
+ cout<<"Recieved Message: ";
+ revprint(codeword,12);
+ decoded(codeword);
+
+ cout<<"Meesage Recieved Successfully...!"<
+#include
+#include
+#include
+#include
+#include
+
+using namespace std;
+
+#define MAX 500
+#define port 5200
+
+
+void tobinary(int a[],char c) {
+ int x=(int)c;
+
+ cout<=0;i--) {
+ cout<=0;i--) {
+ if(a[i]==-1) {
+ a[i]=b[j];
+ j--;
+ }
+ }
+}
+
+
+int main(){
+
+ int clientSocket , serverSocket , receiveMsgSize;
+
+ clientSocket = socket(AF_INET , SOCK_STREAM , 0); // creating the socket
+
+ if(clientSocket < 0){
+ cout << "Creation of client socket failed" << endl;
+ return 0;
+ }
+
+ struct sockaddr_in serverAddr , clientAddr;
+
+ // providing socket with IP and port
+ serverAddr.sin_family = AF_INET;
+ serverAddr.sin_addr.s_addr = inet_addr("127.0.0.1");
+ serverAddr.sin_port = htons(port);
+
+ if(connect(clientSocket , (struct sockaddr*) & serverAddr , sizeof(serverAddr)) < 0){ // connecting to the receiver
+ cout << "Connection Error..!" << endl;
+ return 0;
+ }
+ else{
+ cout << "Connection Established..!" << endl;
+ }
+
+
+ char c;
+ cout<<"Enter the First letter of your name: ";
+ cin>>c;
+
+ int binary[8];
+ tobinary(binary,c);
+
+ cout<<"The entered message in binary is: ";
+ revprint(binary,8);
+
+
+ int codeword[12];
+ fillmessageintocodes(codeword,binary);
+
+
+ for(int i=0;i<4;i++) {
+ int count=0;
+ for(int j=0;j<12;j++) {
+ if((j+1)&(1<
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+using namespace std;
+
+
+
+
+void getMacAddress(char *uc_Mac)
+{
+ int fd;
+
+ struct ifreq ifr;
+ const char* iface = "enp2s0";
+ char* mac;
+
+ fd = socket(AF_INET, SOCK_DGRAM, 0);
+
+ ifr.ifr_addr.sa_family = AF_INET;
+ strncpy((char *)ifr.ifr_name , (const char *)iface , IFNAMSIZ-1);
+
+ ioctl(fd, SIOCGIFHWADDR, &ifr);
+
+ close(fd);
+
+ mac = (char *)ifr.ifr_hwaddr.sa_data;
+
+ //display mac address
+ sprintf((char *)uc_Mac,(const char *)"%.2x:%.2x:%.2x:%.2x:%.2x:%.2x\n" , mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
+
+}
+
+int main()
+{
+ char mac[32]={0};
+
+ getMacAddress(mac);
+
+ cout<
+#include
+int main()
+{
+clrscr();
+char string[100],c;
+cout<<"Enter the string:\n";
+cin.getline(string,100);
+for(int len=0;string[len]!='\0';len++);
+int i,j,flag=1;
+for(i=0,j=len-1;i
+#include
+#include
+using namespace std;
+
+struct splay
+{
+ int key;
+ splay* lchild;
+ splay* rchild;
+};
+
+class SplayTree
+{
+ public:
+ SplayTree()
+ {
+ }
+
+ // RR(Y rotates to the right)
+ splay* RR_Rotate(splay* k2)
+ {
+ splay* k1 = k2->lchild;
+ k2->lchild = k1->rchild;
+ k1->rchild = k2;
+ return k1;
+ }
+
+ // LL(Y rotates to the left)
+ splay* LL_Rotate(splay* k2)
+ {
+ splay* k1 = k2->rchild;
+ k2->rchild = k1->lchild;
+ k1->lchild = k2;
+ return k1;
+ }
+
+ // An implementation of top-down splay tree
+ splay* Splay(int key, splay* root)
+ {
+ if (!root)
+ return NULL;
+ splay header;
+ /* header.rchild points to L tree;
+ header.lchild points to R Tree */
+ header.lchild = header.rchild = NULL;
+ splay* LeftTreeMax = &header;
+ splay* RightTreeMin = &header;
+ while (1)
+ {
+ if (key < root->key)
+ {
+ if (!root->lchild)
+ break;
+ if (key < root->lchild->key)
+ {
+ root = RR_Rotate(root);
+ // only zig-zig mode need to rotate once,
+ if (!root->lchild)
+ break;
+ }
+ /* Link to R Tree */
+ RightTreeMin->lchild = root;
+ RightTreeMin = RightTreeMin->lchild;
+ root = root->lchild;
+ RightTreeMin->lchild = NULL;
+ }
+ else if (key > root->key)
+ {
+ if (!root->rchild)
+ break;
+ if (key > root->rchild->key)
+ {
+ root = LL_Rotate(root);
+ // only zag-zag mode need to rotate once,
+ if (!root->rchild)
+ break;
+ }
+ /* Link to L Tree */
+ LeftTreeMax->rchild = root;
+ LeftTreeMax = LeftTreeMax->rchild;
+ root = root->rchild;
+ LeftTreeMax->rchild = NULL;
+ }
+ else
+ break;
+ }
+ /* assemble L Tree, Middle Tree and R tree */
+ LeftTreeMax->rchild = root->lchild;
+ RightTreeMin->lchild = root->rchild;
+ root->lchild = header.rchild;
+ root->rchild = header.lchild;
+ return root;
+ }
+
+ splay* New_Node(int key)
+ {
+ splay* p_node = new splay;
+ if (!p_node)
+ {
+ fprintf(stderr, "Out of memory!\n");
+ exit(1);
+ }
+ p_node->key = key;
+ p_node->lchild = p_node->rchild = NULL;
+ return p_node;
+ }
+
+ splay* Insert(int key, splay* root)
+ {
+ static splay* p_node = NULL;
+ if (!p_node)
+ p_node = New_Node(key);
+ else
+ p_node->key = key;
+ if (!root)
+ {
+ root = p_node;
+ p_node = NULL;
+ return root;
+ }
+ root = Splay(key, root);
+ /* This is BST that, all keys <= root->key is in root->lchild, all keys >
+ root->key is in root->rchild. */
+ if (key < root->key)
+ {
+ p_node->lchild = root->lchild;
+ p_node->rchild = root;
+ root->lchild = NULL;
+ root = p_node;
+ }
+ else if (key > root->key)
+ {
+ p_node->rchild = root->rchild;
+ p_node->lchild = root;
+ root->rchild = NULL;
+ root = p_node;
+ }
+ else
+ return root;
+ p_node = NULL;
+ return root;
+ }
+
+ splay* Delete(int key, splay* root)
+ {
+ splay* temp;
+ if (!root)
+ return NULL;
+ root = Splay(key, root);
+ if (key != root->key)
+ return root;
+ else
+ {
+ if (!root->lchild)
+ {
+ temp = root;
+ root = root->rchild;
+ }
+ else
+ {
+ temp = root;
+ /*Note: Since key == root->key,
+ so after Splay(key, root->lchild),
+ the tree we get will have no right child tree.*/
+ root = Splay(key, root->lchild);
+ root->rchild = temp->rchild;
+ }
+ free(temp);
+ return root;
+ }
+ }
+
+ splay* Search(int key, splay* root)
+ {
+ return Splay(key, root);
+ }
+
+ void InOrder(splay* root)
+ {
+ if (root)
+ {
+ InOrder(root->lchild);
+ cout<< "key: " <key;
+ if(root->lchild)
+ cout<< " | left child: "<< root->lchild->key;
+ if(root->rchild)
+ cout << " | right child: " << root->rchild->key;
+ cout<< "\n";
+ InOrder(root->rchild);
+ }
+ }
+};
+
+int main()
+{
+ SplayTree st;
+ int vector[10] = {9,8,7,6,5,4,3,2,1,0};
+ splay *root;
+ root = NULL;
+ const int length = 10;
+ int i;
+ for(i = 0; i < length; i++)
+ root = st.Insert(vector[i], root);
+ cout<<"\nInOrder: \n";
+ st.InOrder(root);
+ int input, choice;
+ while(1)
+ {
+ cout<<"\nSplay Tree Operations\n";
+ cout<<"1. Insert "<>choice;
+ switch(choice)
+ {
+ case 1:
+ cout<<"Enter value to be inserted: ";
+ cin>>input;
+ root = st.Insert(input, root);
+ cout<<"\nAfter Insert: "<>input;
+ root = st.Delete(input, root);
+ cout<<"\nAfter Delete: "<>input;
+ root = st.Search(input, root);
+ cout<<"\nAfter Search "<
+using namespace std;
+
+// A Linked List node
+struct Node
+{
+ int data;
+ Node* next;
+};
+
+// Returns true if first list is present in second
+// list
+bool findList(Node* first, Node* second)
+{
+ Node* ptr1 = first, *ptr2 = second;
+
+ // If both linked lists are empty, return true
+ if (first == NULL && second == NULL)
+ return true;
+
+ // Else If one is empty and other is not return
+ // false
+ if ( first == NULL ||
+ (first != NULL && second == NULL))
+ return false;
+
+ // Traverse the second list by picking nodes
+ // one by one
+ while (second != NULL)
+ {
+ // Initialize ptr2 with current node of second
+ ptr2 = second;
+
+ // Start matching first list with second list
+ while (ptr1 != NULL)
+ {
+ // If second list becomes empty and first
+ // not then return false
+ if (ptr2 == NULL)
+ return false;
+
+ // If data part is same, go to next
+ // of both lists
+ else if (ptr1->data == ptr2->data)
+ {
+ ptr1 = ptr1->next;
+ ptr2 = ptr2->next;
+ }
+
+ // If not equal then break the loop
+ else break;
+ }
+
+ // Return true if first list gets traversed
+ // completely that means it is matched.
+ if (ptr1 == NULL)
+ return true;
+
+ // Initialize ptr1 with first again
+ ptr1 = first;
+
+ // And go to next node of second list
+ second = second->next;
+ }
+
+ return false;
+}
+
+/* Function to print nodes in a given linked list */
+void printList(Node* node)
+{
+ while (node != NULL)
+ {
+ printf("%d ", node->data);
+ node = node->next;
+ }
+}
+
+// Function to add new node to linked lists
+Node *newNode(int key)
+{
+ Node *temp = new Node;
+ temp-> data= key;
+ temp->next = NULL;
+ return temp;
+}
+
+/* Driver program to test above functions*/
+int main()
+{
+ /* Let us create two linked lists to test
+ the above functions. Created lists shall be
+ a: 1->2->3->4
+ b: 1->2->1->2->3->4*/
+ Node *a = newNode(1);
+ a->next = newNode(2);
+ a->next->next = newNode(3);
+ a->next->next->next = newNode(4);
+
+ Node *b = newNode(1);
+ b->next = newNode(2);
+ b->next->next = newNode(1);
+ b->next->next->next = newNode(2);
+ b->next->next->next->next = newNode(3);
+ b->next->next->next->next->next = newNode(4);
+
+ findList(a,b) ? cout << "LIST FOUND" :
+ cout << "LIST NOT FOUND";
+
+ return 0;
+}
diff --git a/algorithms/artificial-intelligence/TicTac(maxmin).cpp b/algorithms/artificial-intelligence/TicTac(maxmin).cpp
new file mode 100644
index 00000000..963a6659
--- /dev/null
+++ b/algorithms/artificial-intelligence/TicTac(maxmin).cpp
@@ -0,0 +1,242 @@
+#include
+#include
+using namespace std;
+const int M = 3;
+const int N = 3;
+int c=0;
+struct Move
+{
+ int row, col;
+};
+bool isMovesLeft(string Game[M][N])
+{
+ for (int i = 0; i bestVal)
+ {
+ bestMove.row = i;
+ bestMove.col = j;
+ }
+ }
+ }
+ }
+ return bestMove;
+}
+void display(string Game[M][N])
+{
+ cout << " " << Game[0][0] << " | " << Game[0][1] << " | " << Game[0][2] << " " << endl
+ << "---+---+---" << endl
+ << " " << Game[1][0] << " | " << Game[1][1] << " | " << Game[1][2] << " " << endl
+ << "---+---+---" << endl
+ << " " << Game[2][0] << " | " << Game[2][1] << " | " << Game[2][2] << " " << endl;
+}
+int main()
+{
+ string Game[M][N];
+ int l,m;
+ int b=0;
+ for(int i=0;i<3;i++)
+ {
+ for(int j=0;j<3;j++)
+ {
+ Game[i][j]=" ";
+ }
+ }
+ display(Game);
+ for(int k=0;k>=0;k++)
+ {
+ if(b==0)
+ {
+ cout<<"Enter the move of Player 1(write Rowno. and ColNo.) "<>l>>m;
+ if(Game[l-1][m-1]==" ")
+ {
+ Game[l-1][m-1]="x";
+ c++;
+ b++;
+ display(Game);
+ if((Game[0][0]=="x" && Game[0][1]=="x" && Game[0][2]=="x" )|| (Game[1][0]=="x" && Game[1][1]=="x" && Game[1][2]=="x") || (Game[2][0]=="x" && Game[2][1]=="x" && Game[2][2]=="x") || (Game[0][2]=="x" && Game[1][2]=="x" && Game[2][2]=="x") || (Game[0][1]=="x" && Game[1][1]=="x" && Game[2][1]=="x") || (Game[0][0]=="x" && Game[1][0]=="x" && Game[2][0]=="x") || (Game[0][0]=="x" && Game[1][1]=="x" && Game[2][2]=="x") || (Game[0][2]=="x" && Game[1][1]=="x" && Game[2][0]=="x"))
+ {
+ cout<<"Player 1 Wins"<4)
+ {
+ Move bestMove = findBestMove(Game);
+ int k=bestMove.row;
+ int l=bestMove.col;
+ Game[k+1][l+1]="O";
+ }
+ else
+ {
+ {
+ srand(time(0));
+ int computer= (rand()%9)+1;
+ int row=(computer-1)/3;
+ int col=(computer-1)%3;
+ if(Game[row][col]=="x" || Game[row][col]=="O")
+ {
+ continue;
+ }
+ else
+ {
+ Game[row][col]="O";
+ }
+ }
+ }
+
+ c++;
+ b--;
+ display(Game);
+ if((Game[0][0]=="x" && Game[0][1]=="x" && Game[0][2]=="x" )|| (Game[1][0]=="x" && Game[1][1]=="x" && Game[1][2]=="x") || (Game[2][0]=="x" && Game[2][1]=="x" && Game[2][2]=="x") || (Game[0][2]=="x" && Game[1][2]=="x" && Game[2][2]=="x") || (Game[0][1]=="x" && Game[1][1]=="x" && Game[2][1]=="x") || (Game[0][0]=="x" && Game[1][0]=="x" && Game[2][0]=="x") || (Game[0][0]=="x" && Game[1][1]=="x" && Game[2][2]=="x") || (Game[0][2]=="x" && Game[1][1]=="x" && Game[2][0]=="x"))
+ {
+ cout<<"Player 1 Wins"<
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+#include
+
+#include
+#include
+// SAT Solver
+// CDCL Solver
+// Author togatoga
+// https://github.com/togatoga/Togasat
+namespace togasat
+{
+using Var = int;
+using CRef = int;
+using lbool = int;
+const CRef CRef_Undef = -1;
+class Solver
+{
+
+private:
+ const lbool l_True = 0;
+ const lbool l_False = 1;
+ const lbool l_Undef = 2;
+
+ const int var_Undef = -1;
+
+ // Literal
+ struct Lit
+ {
+ int x;
+ inline bool operator==(Lit p) const
+ {
+ return x == p.x;
+ }
+ inline bool operator!=(Lit p) const
+ {
+ return x != p.x;
+ }
+ inline bool operator<(Lit p) const
+ {
+ return x < p.x;
+ }
+ inline Lit operator~()
+ {
+ Lit q;
+ q.x = x ^ 1;
+ return q;
+ }
+ };
+
+ inline Lit mkLit(Var var, bool sign)
+ {
+ Lit p;
+ p.x = var + var + sign;
+ return p;
+ }
+ inline bool sign(Lit p) const
+ {
+ return p.x & 1;
+ }
+ inline int var(Lit p) const
+ {
+ return p.x >> 1;
+ }
+ inline int toInt(Var v)
+ {
+ return v;
+ }
+ inline int toInt(Lit p)
+ {
+ return p.x;
+ }
+ inline Lit toLit(int x)
+ {
+ Lit p;
+ p.x = x;
+ return p;
+ }
+ const Lit lit_Undef = {-2};
+
+ // lifted boolean
+ // VarData
+ struct VarData
+ {
+ CRef reason;
+ int level;
+ };
+ inline VarData mkVarData(CRef cr, int l)
+ {
+ VarData d = {cr, l};
+ return d;
+ }
+ // Watcher
+ struct Watcher
+ {
+ CRef cref;
+ Lit blocker;
+ Watcher()
+ {
+ }
+ Watcher(CRef cr, Lit p) : cref(cr), blocker(p)
+ {
+ }
+ bool operator==(const Watcher &w) const
+ {
+ return cref == w.cref;
+ }
+ bool operator!=(const Watcher &w) const
+ {
+ return cref != w.cref;
+ }
+ };
+
+ // Clause
+ class Clause
+ {
+ public:
+ struct
+ {
+ bool learnt;
+ int size;
+ } header;
+ std::vector data; //(x1 v x2 v not x3)
+ Clause()
+ {
+ }
+ Clause(const std::vector &ps, bool learnt)
+ {
+ header.learnt = learnt;
+ header.size = ps.size();
+ //data = move(ps);
+ data.resize(header.size);
+ for (size_t i = 0; i < ps.size(); i++)
+ data[i] = ps[i];
+ // //data.emplace_back(ps[i]);
+ }
+
+ int size() const
+ {
+ return header.size;
+ }
+ bool learnt() const
+ {
+ return header.learnt;
+ }
+ Lit &operator[](int i)
+ {
+ return data[i];
+ }
+ Lit operator[](int i) const
+ {
+ return data[i];
+ }
+ };
+
+ CRef allocClause(std::vector &ps, bool learnt = false)
+ {
+ static CRef res = 0;
+ ca[res] = Clause(ps, learnt);
+ return res++;
+ }
+
+ Var newVar(bool sign = true, bool dvar = true)
+ {
+ int v = nVars();
+
+ assigns.emplace_back(l_Undef);
+ vardata.emplace_back(mkVarData(CRef_Undef, 0));
+ activity.emplace_back(0.0);
+ seen.push_back(false);
+ polarity.push_back(sign);
+ decision.push_back(0);
+ setDecisionVar(v, dvar);
+ return v;
+ }
+
+ bool addClause_(std::vector &ps)
+ {
+ //std::sort(ps.begin(), ps.end());
+ // empty clause
+ if (ps.size() == 0)
+ return false;
+ else if (ps.size() == 1)
+ uncheckedEnqueue(ps[0]);
+ else
+ {
+ CRef cr = allocClause(ps, false);
+ //clauses.insert(cr);
+ attachClause(cr);
+ }
+
+ return true;
+ }
+ void attachClause(CRef cr)
+ {
+ const Clause &c = ca[cr];
+
+ assert(c.size() > 1);
+
+ watches[(~c[0]).x].emplace_back(Watcher(cr, c[1]));
+ watches[(~c[1]).x].emplace_back(Watcher(cr, c[0]));
+ }
+
+ // Input
+ void readClause(const std::string &line, std::vector &lits)
+ {
+ lits.clear();
+ int var;
+ var = 0;
+ std::stringstream ss(line);
+ while (ss)
+ {
+ int val;
+ ss >> val;
+ if (val == 0)
+ break;
+ var = abs(val) - 1;
+ while (var >= nVars())
+ newVar();
+ lits.emplace_back(val > 0 ? mkLit(var, false) : mkLit(var, true));
+ }
+ }
+
+ std::unordered_map ca; // store clauses
+ std::unordered_set clauses; // original problem;
+ std::unordered_set learnts;
+ std::unordered_map> watches;
+ std::vector vardata; // store reason and level for each variable
+ std::vector polarity; // The preferred polarity of each variable
+ std::vector decision;
+ std::vector seen;
+ // Todo
+ size_t qhead;
+ std::vector trail;
+ std::vector trail_lim;
+ // Todo rename(not heap)
+ std::set> order_heap;
+ std::vector activity;
+ double var_inc;
+ std::vector model;
+ std::vector conflict;
+ int nVars() const
+ {
+ return vardata.size();
+ }
+ int decisionLevel() const
+ {
+ return trail_lim.size();
+ }
+ void newDecisionLevel()
+ {
+ trail_lim.emplace_back(trail.size());
+ }
+
+ inline CRef reason(Var x) const
+ {
+ return vardata[x].reason;
+ }
+ inline int level(Var x) const
+ {
+ return vardata[x].level;
+ }
+ inline void varBumpActivity(Var v)
+ {
+ std::pair p = std::make_pair(activity[v], v);
+ activity[v] += var_inc;
+ if (order_heap.erase(p) == 1)
+ order_heap.emplace(std::make_pair(activity[v], v));
+
+ if (activity[v] > 1e100)
+ {
+ //Rescale
+ std::set> tmp_order;
+ tmp_order = std::move(order_heap);
+ order_heap.clear();
+ for (int i = 0; i < nVars(); i++)
+ activity[i] *= 1e-100;
+ for (auto &val : tmp_order)
+ order_heap.emplace(std::make_pair(activity[val.second], val.second));
+ var_inc *= 1e-100;
+ }
+ }
+ bool satisfied(const Clause &c) const
+ {
+ for (int i = 0; i < c.size(); i++)
+ if (value(c[i]) == l_True)
+ return true;
+
+ return false;
+ }
+ lbool value(Var p) const
+ {
+ return assigns[p];
+ }
+ lbool value(Lit p) const
+ {
+ if (assigns[var(p)] == l_Undef)
+ return l_Undef;
+ return assigns[var(p)] ^ sign(p);
+ }
+ void setDecisionVar(Var v, bool b)
+ {
+ decision[v] = b;
+ order_heap.emplace(std::make_pair(0.0, v));
+ }
+ void uncheckedEnqueue(Lit p, CRef from = CRef_Undef)
+ {
+ assert(value(p) == l_Undef);
+ assigns[var(p)] = sign(p);
+ vardata[var(p)] = mkVarData(from, decisionLevel());
+ trail.emplace_back(p);
+ }
+ // decision
+ Lit pickBranchLit()
+ {
+ Var next = var_Undef;
+ while (next == var_Undef or value(next) != l_Undef)
+ {
+ if (order_heap.empty())
+ {
+ next = var_Undef;
+ break;
+ }
+ else
+ {
+ auto p = *order_heap.rbegin();
+ next = p.second;
+ order_heap.erase(p);
+ }
+ }
+ return next == var_Undef ? lit_Undef : mkLit(next, polarity[next]);
+ }
+ // clause learning
+ void analyze(CRef confl, std::vector &out_learnt, int &out_btlevel)
+ {
+ int pathC = 0;
+ Lit p = lit_Undef;
+ int index = trail.size() - 1;
+ out_learnt.emplace_back(mkLit(0, false));
+ do
+ {
+ assert(confl != CRef_Undef);
+ Clause &c = ca[confl];
+ for (int j = (p == lit_Undef) ? 0 : 1; j < c.size(); j++)
+ {
+ Lit q = c[j];
+ if (not seen[var(q)] and level(var(q)) > 0)
+ {
+ varBumpActivity(var(q));
+ seen[var(q)] = 1;
+ if (level(var(q)) >= decisionLevel())
+ pathC++;
+ else
+ out_learnt.emplace_back(q);
+ }
+ }
+ while (not seen[var(trail[index--])])
+ ;
+ p = trail[index + 1];
+ confl = reason(var(p));
+ seen[var(p)] = 0;
+ pathC--;
+ } while (pathC > 0);
+
+ out_learnt[0] = ~p;
+
+ // unit clause
+ if (out_learnt.size() == 1)
+ out_btlevel = 0;
+ else
+ {
+ int max_i = 1;
+ for (size_t i = 2; i < out_learnt.size(); i++)
+ if (level(var(out_learnt[i])) > level(var(out_learnt[max_i])))
+ max_i = i;
+
+ Lit p = out_learnt[max_i];
+ out_learnt[max_i] = out_learnt[1];
+ out_learnt[1] = p;
+ out_btlevel = level(var(p));
+ }
+
+ for (size_t i = 0; i < out_learnt.size(); i++)
+ seen[var(out_learnt[i])] = false;
+ }
+
+ // backtrack
+ void cancelUntil(int level)
+ {
+ if (decisionLevel() > level)
+ {
+ for (int c = trail.size() - 1; c >= trail_lim[level]; c--)
+ {
+ Var x = var(trail[c]);
+ assigns[x] = l_Undef;
+ polarity[x] = sign(trail[c]);
+ order_heap.emplace(std::make_pair(activity[x], x));
+ }
+ qhead = trail_lim[level];
+ trail.erase(trail.end() - (trail.size() - trail_lim[level]), trail.end());
+ trail_lim.erase(trail_lim.end() - (trail_lim.size() - level),
+ trail_lim.end());
+ }
+ }
+ CRef propagate()
+ {
+ CRef confl = CRef_Undef;
+ int num_props = 0;
+ while (qhead < trail.size())
+ {
+ Lit p = trail[qhead++]; // 'p' is enqueued fact to propagate.
+ std::vector &ws = watches[p.x];
+ std::vector::iterator i, j, end;
+ num_props++;
+
+ for (i = j = ws.begin(), end = i + ws.size(); i != end;)
+ {
+ // Try to avoid inspecting the clause:
+ Lit blocker = i->blocker;
+ if (value(blocker) == l_True)
+ {
+ *j++ = *i++;
+ continue;
+ }
+
+ CRef cr = i->cref;
+ Clause &c = ca[cr];
+ Lit false_lit = ~p;
+ if (c[0] == false_lit)
+ c[0] = c[1], c[1] = false_lit;
+ assert(c[1] == false_lit);
+ i++;
+
+ Lit first = c[0];
+ Watcher w = Watcher(cr, first);
+ if (first != blocker && value(first) == l_True)
+ {
+ *j++ = w;
+ continue;
+ }
+
+ // Look for new watch:
+ for (int k = 2; k < c.size(); k++)
+ if (value(c[k]) != l_False)
+ {
+ c[1] = c[k];
+ c[k] = false_lit;
+ watches[(~c[1]).x].emplace_back(w);
+ goto NextClause;
+ }
+ *j++ = w;
+ if (value(first) == l_False) // conflict
+ {
+ confl = cr;
+ qhead = trail.size();
+ while (i < end)
+ *j++ = *i++;
+ }
+ else
+ uncheckedEnqueue(first, cr);
+ NextClause:;
+ }
+ int size = i - j;
+ ws.erase(ws.end() - size, ws.end());
+ }
+ return confl;
+ }
+
+ static double luby(double y, int x)
+ {
+
+ // Find the finite subsequence that contains index 'x', and the
+ // size of that subsequence:
+ int size, seq;
+ for (size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1)
+ ;
+
+ while (size - 1 != x)
+ {
+ size = (size - 1) >> 1;
+ seq--;
+ x = x % size;
+ }
+
+ return std::pow(y, seq);
+ }
+
+ lbool search(int nof_conflicts)
+ {
+ int backtrack_level;
+ std::vector learnt_clause;
+ learnt_clause.emplace_back(mkLit(-1, false));
+ int conflictC = 0;
+ while (true)
+ {
+ CRef confl = propagate();
+
+ if (confl != CRef_Undef)
+ {
+ // CONFLICT
+ conflictC++;
+ if (decisionLevel() == 0)
+ return l_False;
+ learnt_clause.clear();
+ analyze(confl, learnt_clause, backtrack_level);
+ cancelUntil(backtrack_level);
+ if (learnt_clause.size() == 1)
+ uncheckedEnqueue(learnt_clause[0]);
+ else
+ {
+ CRef cr = allocClause(learnt_clause, true);
+ //learnts.insert(cr);
+ attachClause(cr);
+ uncheckedEnqueue(learnt_clause[0], cr);
+ }
+ //varDecay
+ var_inc *= 1.05;
+ }
+ else
+ {
+ // NO CONFLICT
+ if ((nof_conflicts >= 0 and conflictC >= nof_conflicts))
+ {
+ cancelUntil(0);
+ return l_Undef;
+ }
+ Lit next = pickBranchLit();
+
+ if (next == lit_Undef)
+ return l_True;
+ newDecisionLevel();
+ uncheckedEnqueue(next);
+ }
+ }
+ }
+
+public:
+ std::vector assigns; // The current assignments (ex assigns[0] = 0 ->
+ // X1 = True, assigns[1] = 1 -> X2 = False)
+ lbool answer; // SATISFIABLE 0 UNSATISFIABLE 1 UNKNOWN 2
+ Solver()
+ {
+ qhead = 0;
+ }
+ void parseDimacsProblem(std::string problem_name)
+ {
+ std::vector lits;
+ int vars = 0;
+ int clauses = 0;
+ std::string line;
+ std::ifstream ifs(problem_name, std::ios_base::in);
+ while (ifs.good())
+ {
+ getline(ifs, line);
+ if (line.size() > 0)
+ {
+ if (line[0] == 'p')
+ sscanf(line.c_str(), "p cnf %d %d", &vars, &clauses);
+ else if (line[0] == 'c' or line[0] == 'p')
+ continue;
+ else
+ {
+ readClause(line, lits);
+ if (lits.size() > 0)
+ addClause_(lits);
+ }
+ }
+ }
+ ifs.close();
+ }
+ lbool solve()
+ {
+ model.clear();
+ conflict.clear();
+ lbool status = l_Undef;
+ answer = l_Undef;
+ var_inc = 1.01;
+ int curr_restarts = 0;
+ double restart_inc = 2;
+ double restart_first = 100;
+ while (status == l_Undef)
+ {
+ double rest_base = luby(restart_inc, curr_restarts);
+ status = search(rest_base * restart_first);
+ curr_restarts++;
+ }
+ answer = status;
+ return status;
+ }
+
+ void addClause(std::vector &clause)
+ {
+ std::vector lits;
+ lits.resize(clause.size());
+ for (size_t i = 0; i < clause.size(); i++)
+ {
+ int var = abs(clause[i]) - 1;
+ while (var >= nVars())
+ newVar();
+ lits[i] = clause[i] > 0 ? mkLit(var, false) : mkLit(var, true);
+ }
+ addClause_(lits);
+ }
+ void printAnswer()
+ {
+ if (answer == 0)
+ {
+ std::cout << "SAT" << std::endl;
+ for (size_t i = 0; i < assigns.size(); i++)
+ {
+ if (assigns[i] == 0)
+ std::cout << (i + 1) << " ";
+ else
+ std::cout << -(i + 1) << " ";
+ }
+ std::cout << "0" << std::endl;
+ }
+ else
+ std::cout << "UNSAT" << std::endl;
+ }
+};
+} // namespace togasat
\ No newline at end of file
diff --git a/algorithms/backtracking/All_Codes_Recursion.cpp b/algorithms/backtracking/All_Codes_Recursion.cpp
new file mode 100644
index 00000000..726efea0
--- /dev/null
+++ b/algorithms/backtracking/All_Codes_Recursion.cpp
@@ -0,0 +1,89 @@
+/*
+
+Problem Statement
+
+Assume that the value of a = 1, b = 2, c = 3, ... , z = 26.
+You are given a numeric string S.
+Write a program to return the list of all possible codes that can be generated from the given string.
+
+For Example -
+Input:
+1123
+
+Output:
+aabc
+kbc
+alc
+aaw
+kw
+
+Being a recursive solution, this won't work for large inputs. But we can use DP to make it work for Large results.
+
+*/
+
+
+#include
+#include
+using namespace std;
+
+int getString(string str) {
+ int res = 99999;
+ if(str.size() == 1) {
+ int num = str[0] - '0';
+ //c = 'a' + (num-1);
+ return num-1;
+ }
+ else if(str.size() > 1) {
+ int num = ((str[0] - '0')*10) + (str[1] - '0');
+ if(num > 26) {
+ return res;
+ }
+ else {
+ //c = 'a' + (num-1);
+ return num-1;
+ }
+
+ }
+
+ return res;
+
+}
+
+int helper(string input, string curString, string modString, string output[10000]) {
+ static int i;
+ int cs = getString(curString);
+ if(input.empty() && cs < 27) {
+ modString +=('a' + cs);
+ output[i++] = modString;
+ return i;
+ }
+
+ if(cs < 27) {
+ modString +=('a' + cs);
+ }
+
+ int count = helper(input.substr(1),input.substr(0,1),modString,output);
+ if(input.length() > 1) {
+ int check = getString(input.substr(0,2));
+ if(check < 27) {
+ count = helper(input.substr(2),input.substr(0,2),modString,output);
+ }
+ }
+ return count;
+ }
+
+
+int getCodes(string input, string output[10000]) {
+ return helper(input,"","",output);
+}
+
+int main(){
+ string input;
+ cin >> input;
+
+ string output[10000];
+ int count = getCodes(input, output);
+ for(int i = 0; i < count && i < 10000; i++)
+ cout << output[i] << endl;
+ return 0;
+}
diff --git a/algorithms/backtracking/N-Queen Problem.cpp b/algorithms/backtracking/N-Queen Problem.cpp
new file mode 100644
index 00000000..29adf965
--- /dev/null
+++ b/algorithms/backtracking/N-Queen Problem.cpp
@@ -0,0 +1,61 @@
+#include
+#include
+#include
+void queen(int row,int n);
+int board[20],count;
+void main()
+{
+ int n,i,j;
+ clrscr();
+ printf(".....N Queens Problem Using Backtracking.....\n");
+ printf("Enter number of Queens: ");
+ scanf("%d",&n);
+ queen(1,n);
+ getch();
+}
+void print(int n)
+{
+ int i,j;
+ printf("\nSolution %d:\n`",++count);
+ for(i=1;i<=n;++i)
+ printf("\t%d",i);
+ for(i=1;i<=n;++i)
+ {
+ printf("\n\n%d\t",i);
+ for(j=1;j<=n;++j)
+ {
+ if(board[i]==j)
+ printf("Q%d\t",i);
+ else
+ printf("--\t");
+ }
+ }
+}
+int place(int row,int column)
+{
+ int i;
+ for(i=1;i<=row-1;++i)
+ {
+ if(board[i]==column)
+ return 0;
+ else
+ if(abs(board[i]-column)==abs(i-row))
+ return 0;
+ }
+ return 1;
+}
+void queen(int row,int n)
+{
+ int column;
+ for(column=1;column<=n;++column)
+ {
+ if(place(row,column))
+ {
+ board[row]=column;
+ if(row==n)
+ print(n);
+ else
+ queen(row+1,n);
+ }
+ }
+}
\ No newline at end of file
diff --git a/algorithms/backtracking/crossword_puzzle.cpp b/algorithms/backtracking/crossword_puzzle.cpp
new file mode 100644
index 00000000..d8c200d1
--- /dev/null
+++ b/algorithms/backtracking/crossword_puzzle.cpp
@@ -0,0 +1,171 @@
+#include
+using namespace std;
+
+// ways are to calculate the number of
+// possible ways to fill the grid
+int ways = 0;
+
+// this function is used to print
+// the resultant matrix
+void printMatrix(vector& matrix, int n)
+{
+ for (int i = 0; i < n; i++)
+ cout << matrix[i] << endl;
+}
+
+// this function checks for the current word
+// if it can be placed horizontally or not
+// x -> it represent index of row
+// y -> it represent index of column
+// currentWord -> it represent the
+// current word in word array
+vector checkHorizontal(int x, int y,
+ vector matrix,
+ string currentWord)
+{
+ int n = currentWord.length();
+
+ for (int i = 0; i < n; i++) {
+ if (matrix[x][y + i] == '#' ||
+ matrix[x][y + i] == currentWord[i]) {
+ matrix[x][y + i] = currentWord[i];
+ }
+ else {
+
+ // this shows that word cannot
+ // be placed horizontally
+ matrix[0][0] = '@';
+ return matrix;
+ }
+ }
+
+ return matrix;
+}
+
+// this function checks for the current word
+// if it can be placed vertically or not
+// x -> it represent index of row
+// y -> it represent index of column
+// currentWord -> it represent the
+// current word in word array
+vector checkVertical(int x, int y,
+ vector matrix,
+ string currentWord)
+{
+ int n = currentWord.length();
+
+ for (int i = 0; i < n; i++) {
+ if (matrix[x + i][y] == '#' ||
+ matrix[x + i][y] == currentWord[i]) {
+ matrix[x + i][y] = currentWord[i];
+ }
+ else {
+
+ // this shows that word
+ // cannot be placed vertically
+ matrix[0][0] = '@';
+ return matrix;
+ }
+ }
+ return matrix;
+}
+
+// this function recursively checks for every
+// word that can align vertically in one loop
+// and in another loop it checks for those words
+// that can align horizontally words -> it
+// contains all the words to fill in a crossword
+// puzzle matrix -> it contain the current
+// state of crossword index -> it represent
+// the index of current word n -> it represent
+// the length of row or column of the square matrix
+void solvePuzzle(vector& words,
+ vector matrix,
+ int index, int n)
+{
+ if (index < words.size()) {
+ string currentWord = words[index];
+ int maxLen = n - currentWord.length();
+
+ // loop to check the words that can align vertically.
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j <= maxLen; j++) {
+ vector temp = checkVertical(j, i,
+ matrix, currentWord);
+
+ if (temp[0][0] != '@') {
+ solvePuzzle(words, temp, index + 1, n);
+ }
+ }
+ }
+
+ // loop to check the words that can align horizontally.
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j <= maxLen; j++) {
+ vector temp = checkHorizontal(i, j,
+ matrix, currentWord);
+
+ if (temp[0][0] != '@') {
+ solvePuzzle(words, temp, index + 1, n);
+ }
+ }
+ }
+ }
+ else {
+ // calling of print function to
+ // print the crossword puzzle
+ cout << (ways + 1) << " way to solve the puzzle "
+ << endl;
+ printMatrix(matrix, n);
+ cout << endl;
+
+ // increase the ways
+ ways++;
+ return;
+ }
+}
+
+// Driver Code
+int main()
+{
+ // length of grid
+ int n1 = 10;
+
+ // matrix to hold the grid of puzzle
+ vector matrix;
+
+ // take input of puzzle in matrix
+ // input of grid of size n1 x n1
+ matrix.push_back("*#********");
+ matrix.push_back("*#********");
+ matrix.push_back("*#****#***");
+ matrix.push_back("*##***##**");
+ matrix.push_back("*#****#***");
+ matrix.push_back("*#****#***");
+ matrix.push_back("*#****#***");
+ matrix.push_back("*#*######*");
+ matrix.push_back("*#********");
+ matrix.push_back("***#######");
+
+ vector words;
+
+ // the words matrix will hold all
+ // the words need to be filled in the grid
+ words.push_back("PUNJAB");
+ words.push_back("JHARKHAND");
+ words.push_back("MIZORAM");
+ words.push_back("MUMBAI");
+
+ // initialize the number of ways
+ // to solve the puzzle to zero
+ ways = 0;
+
+ // recursive function to solve the puzzle
+ // Here 0 is the initial index of words array
+ // n1 is length of grid
+ solvePuzzle(words, matrix, 0, n1);
+ cout << "Number of ways to fill the grid is "
+ << ways << endl;
+
+ return 0;
+}
diff --git a/algorithms/backtracking/sudoku_solver.cc b/algorithms/backtracking/sudoku_solver.cc
new file mode 100644
index 00000000..898d79b6
--- /dev/null
+++ b/algorithms/backtracking/sudoku_solver.cc
@@ -0,0 +1,107 @@
+/*
+https://leetcode.com/problems/sudoku-solver/
+
+Sudoku Solver
+==============
+
+Write a program to solve a Sudoku puzzle by filling the empty cells.
+
+Empty cells are indicated by the character '.'.
+
+You may assume that there will be only one unique solution.
+
+
+A sudoku puzzle...
+
+
+...and its solution numbers marked in red.
+*/
+#include
+#include
+#include
+#include
+#include
+#include
+using namespace std;
+
+class Solution {
+ static const int kSize = 9;
+ bool rowUsed[kSize][kSize];
+ bool colUsed[kSize][kSize];
+ bool areaUsed[kSize][kSize];
+
+public:
+ bool backtrack(vector >& board, int r, int c) {
+ if(r >= kSize) return true; // the last cell.
+ if(c >= kSize) return backtrack(board, r+1, 0); // row complete, move to next row.
+ if(isdigit(board[r][c])) return backtrack(board, r, c+1); // skip the given cell.
+
+ // empty cell, try each value [0-9] to fill it.
+ for(int num = 1; num <= kSize; ++num) {
+ int area = (r/3) * 3 + (c/3);
+ if(rowUsed[r][num] || colUsed[num][c] || areaUsed[area][num]) {
+ continue;
+ }
+
+ // emplace num as char.
+ board[r][c] = num + '0';
+ rowUsed[r][num] = colUsed[num][c] = areaUsed[area][num] = true;
+
+ // try next position...
+ if(backtrack(board, r, c+1)) return true; // stop searching when the first solution found.
+
+ // can not continue to place, backtrack.
+ board[r][c] = '.';
+ rowUsed[r][num] = colUsed[num][c] = areaUsed[area][num] = false;
+ }
+ return false;
+ }
+
+ void solveSudoku(vector >& board) {
+ memset(rowUsed, false, sizeof(rowUsed));
+ memset(colUsed, false, sizeof(colUsed));
+ memset(areaUsed, false, sizeof(areaUsed));
+ vector > result(board);
+ if (backtrack(result, 0, 0)) { // found solution
+ board = result; // copy back
+ }
+ }
+};
+
+template
+void printMatrix(Matrix m)
+{
+ for(int i = 0; i < m.size(); i++) {
+ for(int j = 0; j < m[i].size(); j++) {
+ cout << m[i][j];
+ }
+ cout << "\n";
+ }
+ cout << endl;
+}
+
+// get sudoku puzzle from sudokupuzzle.org:
+// curl -s "http://sudokupuzzle.org/online2.php?nd=0&y=`date +%Y\&m=%m\&d=%d`" | grep tmda= | sed "s/.*tmda='//g" | cut -c -81
+
+int main(int argc, char* argv[])
+{
+ const int N = 9;
+ vector > board;
+ string puzzle = argc > 1 ? argv[1] : "000005001097004000005620008951060873804510209063700050149076080032041690780350402";
+
+ board.resize(N);
+ for (int i = 0; i < N; i++) {
+ board[i].resize(N);
+ for (int j = 0; j < N; j++) {
+ const char c = puzzle[i*N + j];
+ board[i][j] = (c == '0' ? '.' : c);
+ }
+ }
+ printMatrix(board);
+
+ Solution().solveSudoku(board);
+ printMatrix(board);
+
+ return 0;
+}
+
diff --git a/algorithms/data-structures/BinaryIndexedTree2d.cpp b/algorithms/data-structures/BinaryIndexedTree2d.cpp
new file mode 100644
index 00000000..a840eb87
--- /dev/null
+++ b/algorithms/data-structures/BinaryIndexedTree2d.cpp
@@ -0,0 +1,35 @@
+// Binary Indexed Tree of sum in 2d array
+// AbraaoCF - UFCG
+#include
+using namespace std;
+#define maxx 1100
+int bit[maxx][maxx];
+void update(int idx, int idy, int value)
+{
+ while(idx <= maxx)
+ {
+ int idy_temp = idy;
+ while(idy_temp <= maxx)
+ {
+ bit[idx][idy_temp] += value;
+ idy_temp += (idy_temp &-idy_temp);
+ }
+ idx += (idx&-idx);
+ }
+ return;
+}
+int query(int idx,int idy)
+{
+ int sum = 0;
+ while(idx > 0)
+ {
+ int idy_temp = idy;
+ while(idy_temp > 0)
+ {
+ sum += bit[idx][idy_temp];
+ idy_temp -= (idy_temp &-idy_temp);
+ }
+ idx -= (idx&-idx);
+ }
+ return sum;
+}
diff --git a/algorithms/data-structures/BinarySearchTree.cpp b/algorithms/data-structures/BinarySearchTree.cpp
new file mode 100644
index 00000000..970e7c6a
--- /dev/null
+++ b/algorithms/data-structures/BinarySearchTree.cpp
@@ -0,0 +1,170 @@
+#include
+#define ll long long int
+#define ull unsigned long long int
+#define pb push_back
+#define MIN 2
+#define sc(n) scanf("%d",&n)
+#define pr(n) printf("%d",n)
+#define gc getchar_unlocked
+#define AC 0
+#define MOD 1000000007
+#define mp make_pair
+#define vc vector
+#define wh(n) while(n--)
+#define ite(type,datatype,name) type::iterator name
+#define gt goto
+
+using namespace std;
+
+ /*Structure of node*/
+struct node{
+ int data;
+ struct node *left,*right;
+};
+ /*Create a new Node*/
+struct node *newnode(int p){
+ struct node *temp = new node();
+ temp->data = p;
+ temp->left = temp->right = NULL;
+ return temp;
+}
+
+ /*Insert a new Node in BST*/
+struct node *insert(struct node *root,int p){
+ if(root == NULL){
+ return newnode(p);
+ }
+ if(root->data > p){
+ root->left = insert(root->left,p);
+ }
+ else{
+ root->right = insert(root->right,p);
+ }
+ return root;
+}
+/* Display BST */
+void display(struct node *root){
+ if(root != NULL){
+ cout<data<<" "; //Pre-Order
+ display(root->left);
+ // cout<data<<" ";
+ display(root->right);
+
+ }
+}
+ /*Return node with minimum value*/
+struct node *minvalue(struct node *root){
+ struct node *curr = root;
+
+ while(curr->left != NULL){
+ curr = curr->left;
+ }
+ return curr;
+}
+
+/* Delete node with given key value in BST */
+struct node *del(struct node* root,int key){
+ //Base case for root
+ if(root == NULL) return root;
+ if(root->data > key){
+ root->left = del(root->left,key);
+ }
+ else if(root->data < key){
+ root->right = del(root->right,key);
+ }
+ else{
+ //noDe has one or nO noDe
+ if(root->left == NULL){
+ struct node *temp = root->right;
+ free(root);
+ return temp;
+ }
+ else if(root->right == NULL){
+ struct node *temp = root->left;
+ free(root);
+ return temp;
+ }
+ //tWo chiLd
+ struct node *temp = minvalue(root->right);
+ root->data = temp->data;
+ root->right = del(root->right,temp->data);
+ }
+ return root;
+}
+
+ /* Return height of BST */
+int maxheight(struct node *node){
+ if(node == NULL){
+ return 0;
+ }
+ int lh = maxheight(node->left);
+ int rh = maxheight(node->right);
+
+ if(lh>rh) return (lh+1);
+ else return (rh+1);
+}
+/* return the search value for given key */
+int search(struct node* temp,int key){
+ int p=key;
+ while(1){
+ if(temp->data == key){
+ return p;
+ }
+ else if(temp->data > key){
+ p = max(p,temp->data);
+ temp = temp->left;
+ }
+ else if(temp->data < key){
+ temp = temp->right;
+ }
+ }
+ return p;
+}
+
+ /*Print BST in zigzag Pattern */
+void zigzeg(struct node* root){
+ stack s[2];
+ int curr = 0;
+ int oth = 1;
+ s[curr].push(root->data);
+ struct node* temp1 = root;
+ struct node* temp2 = root;
+ while((!s[curr].empty()) || (!s[oth].empty())){
+ if(curr == 0){
+ int p = s[curr].top();
+ s[curr].pop();
+ s[oth].push(temp1->left->data);
+ s[oth].push(temp1->right->data);
+ temp1= temp1->right;
+ cout<right->data);
+ s[curr].push(temp1->left->data);
+ temp1= temp1->left;
+ cout<
+#include
+
+using namespace std;
+
+int main()
+{
+
+struct node{
+ int info;
+ node *next;
+}*ptr,*head,*start;
+
+int c=1,data;
+
+ptr=new node;
+ptr->next=NULL;
+
+start=head=ptr;
+
+while(c<3 && c>0){
+ cout<<"1.Insert\n2.Link List\n";
+ cin>>c;
+
+ switch(c){
+ case 1:
+ cout<<"Enter Data\n";
+ cin>>data;
+
+ ptr=new node;
+ ptr->next=start;
+ ptr->info=data;
+
+ head->next=ptr;
+ head=ptr;
+
+ break;
+
+ case 2:
+ ptr=start->next;
+
+ while(ptr!=start && ptr!=NULL){
+ cout<info<<"->";
+ ptr=ptr->next;
+ }
+ cout<<"\n";
+ break;
+
+ default:
+ cout<<"Wrong Choice\nExiting...\n";
+ }
+
+}
+
+getch();
+return 0;
+}
\ No newline at end of file
diff --git a/algorithms/data-structures/CircularlyLinkedList/CircularlySinglyLinkedList.cpp b/algorithms/data-structures/CircularlyLinkedList/CircularlySinglyLinkedList.cpp
new file mode 100644
index 00000000..1a650c2d
--- /dev/null
+++ b/algorithms/data-structures/CircularlyLinkedList/CircularlySinglyLinkedList.cpp
@@ -0,0 +1,286 @@
+
+#include"CircularlySinglyLinkedList.h"
+
+
+
+template
+void CircularlySinglyLinkedList :: Add_to_empty_list(T val)
+{
+ Node* new_node = new Node(val);
+
+ Tail = new_node;
+ Tail->next = new_node;
+
+Size_++;
+}
+
+
+template
+void CircularlySinglyLinkedList ::Push_back( T val)
+{
+ if(Tail == NULL)
+ {
+ Add_to_empty_list(val);
+
+ }
+ else
+ {
+ Node* new_node = new Node(val);
+ new_node->next = Tail->next;
+ Tail->next = new_node;
+ Tail= new_node;
+ Size_++;
+ }
+}
+
+template
+void CircularlySinglyLinkedList :: Clear()
+{
+
+ if(Size_ == 0 )
+ {
+ cout<<" all cleared linked list is empty"<<'\n';
+ }
+ else
+ {
+ Node* tmp1 = Tail->next;
+ Node* tmp2 = tmp1;
+
+ while(tmp1 != Tail)
+ {
+ tmp1 = tmp1->next;
+ //free the memory of the node to delete it
+ delete tmp2;
+ tmp2=tmp1;
+ }
+ // after the loop we make Tail point to NULL because it points
+ //to a deleted location in the memory (dangling pointer)
+ delete Tail;
+ tmp1 = NULL;
+ tmp2 = NULL;
+ Tail = NULL;
+ Size_ = 0;
+ }
+
+}
+template
+
+void CircularlySinglyLinkedList :: Display()
+{
+ if(Size_ == 0)
+ {
+ cout<<"List is empty"<<'\n';
+ return;
+ }
+ Node* tmp = Tail->next; //Head
+
+ do
+ {
+ cout<data<<" ";
+ tmp = tmp->next;
+
+
+ }
+ while(tmp != Tail->next);
+
+
+
+ cout<<'\n';
+}
+template
+void CircularlySinglyLinkedList :: Pop_back()
+{
+ if( Size_ == 0)
+ {
+ cout<<"Can't pop back. list is empty"<<'\n';
+ return;
+
+ }
+
+ if(Size_ == 1)
+ {
+ delete Tail;
+ Tail = NULL;
+
+
+ }
+ else
+ {
+ Node* tmp = Tail->next;
+
+
+ while(tmp->next != Tail)
+ {
+ tmp = tmp->next;
+ }
+
+ tmp->next = Tail->next;
+ delete Tail;
+ Tail = tmp;
+ }
+
+Size_--;
+}
+
+
+template
+void CircularlySinglyLinkedList :: Push_front(T val)
+{
+ if(Tail == NULL)
+ {
+ Add_to_empty_list(val);
+
+ }
+ else
+ {
+ Node* new_node = new Node(val);
+ new_node->next = Tail->next;
+ Tail->next = new_node;
+ Size_++;
+ }
+
+}
+
+template
+void CircularlySinglyLinkedList :: Pop_front()
+{
+
+ if(Size_ == 0)
+ {
+ cout<<"Can't pop front. List is empty "<<'\n';
+ return;
+ }
+
+
+ if( Size_ == 1)
+ {
+ delete Tail;
+ Tail = NULL;
+
+
+ }
+ else
+ {
+
+ Node* tmp = Tail->next;
+ Tail->next = Tail->next->next;
+ delete tmp;
+
+ }
+
+Size_--;
+
+}
+
+template
+void CircularlySinglyLinkedList :: Insert_at(T val, int position,string afterOrbefore_flag)
+{
+
+
+ if(Size_ == 0)
+ {
+ cout<<"no existing nodes.Linked list is empty. ";
+ return;
+ }
+
+ if(position >Size_ || position < 0)
+ {
+ cout<<"invalid position choose a position between 1 and size "<<'\n';
+ cout<<"size is: "<* tmp;
+ if(afterOrbefore_flag == "before")
+ {
+
+ if(position == 1)
+ {
+ Push_front(val);
+ return;
+
+ }
+ else
+ {
+ tmp=Tail->next;
+ for(int i = 1 ; i next);
+
+ }
+
+
+ }
+ else if(afterOrbefore_flag == "after")
+ {
+
+ if(position == Size_)
+ {
+ Push_back(val);
+ return;
+
+ }
+ else
+ {
+ tmp=Tail->next;
+ for( int i = 1 ; i next);
+
+ }
+
+ }
+
+ Node* new_node = new Node(val);
+ new_node->next = tmp->next;
+ tmp->next = new_node;
+ Size_++;
+
+}
+template
+
+void CircularlySinglyLinkedList :: Delete_at(int position)
+{
+ if(Size_ == 0)
+ {
+ cout<<"no existing nodes.Linked list is empty. ";
+ return;
+ }
+
+ if(position >Size_ || position < 0)
+ {
+ cout<<"invalid position choose a position between 1 and size "<<'\n';
+ cout<<"size is: "<* tmp = Tail->next;
+
+ for(int i = 1 ; i < position-1; i++,tmp = tmp->next);
+
+ Node* node = tmp->next;
+
+ tmp->next = node->next;
+
+ delete node;
+
+
+ Size_--;
+
+ }
+
+
+}
diff --git a/algorithms/data-structures/CircularlyLinkedList/CircularlySinglyLinkedList.h b/algorithms/data-structures/CircularlyLinkedList/CircularlySinglyLinkedList.h
new file mode 100644
index 00000000..fcc4fdbe
--- /dev/null
+++ b/algorithms/data-structures/CircularlyLinkedList/CircularlySinglyLinkedList.h
@@ -0,0 +1,62 @@
+#include
+
+using namespace std;
+
+
+template
+class Node
+{
+ public:
+ T data;
+
+ Node* next;
+
+
+ Node()
+ {
+ next = NULL;
+ }
+
+ Node(T val)
+ {
+ data = val;
+ next = NULL;
+ }
+
+
+
+
+};
+
+template
+class CircularlySinglyLinkedList
+{
+ public:
+
+ Node* Tail;
+ int Size_;
+
+ CircularlySinglyLinkedList()
+ {
+ Size_ = 0;
+ Tail = NULL;
+
+ }
+ void Push_front(T val);
+ void Pop_front();
+ void Push_back(T val);
+ void Pop_back();
+ void Display();
+ void Clear();
+ void Insert_at(T val,int position,string afterOrbefore_flag); // has generalized code for add before node and add after node
+ void Delete_at(int position);
+
+ void Add_to_empty_list(T val);
+
+ ~CircularlySinglyLinkedList()
+ {
+ Clear();
+ }
+
+
+};
diff --git a/algorithms/data-structures/Deque/deque.c b/algorithms/data-structures/Deque/deque.c
new file mode 100644
index 00000000..047cbf9d
--- /dev/null
+++ b/algorithms/data-structures/Deque/deque.c
@@ -0,0 +1,202 @@
+#include
+#include
+#define MAX 30
+
+typedef struct dequeue
+{
+ int data[MAX];
+ int rear,front;
+}dequeue;
+
+void initialize(dequeue *p);
+int empty(dequeue *p);
+int full(dequeue *p);
+void enqueueR(dequeue *p,int x);
+void enqueueF(dequeue *p,int x);
+int dequeueF(dequeue *p);
+int dequeueR(dequeue *p);
+void print(dequeue *p);
+
+void main()
+{
+ int i,x,op,n;
+ dequeue q;
+
+ initialize(&q);
+
+ do
+ {
+ printf("\n1.Create\n2.Insert(rear)\n3.Insert(front)\n4.Delete(rear)\n5.Delete(front)");
+ printf("\n6.Print\n7.Exit\n\nEnter your choice:");
+ scanf("%d",&op);
+
+ switch(op)
+ {
+ case 1: printf("\nEnter number of elements:");
+ scanf("%d",&n);
+ initialize(&q);
+ printf("\nEnter the data:");
+
+ for(i=0;irear=-1;
+ P->front=-1;
+}
+
+int empty(dequeue *P)
+{
+ if(P->rear==-1)
+ return(1);
+
+ return(0);
+}
+
+int full(dequeue *P)
+{
+ if((P->rear+1)%MAX==P->front)
+ return(1);
+
+ return(0);
+}
+
+void enqueueR(dequeue *P,int x)
+{
+ if(empty(P))
+ {
+ P->rear=0;
+ P->front=0;
+ P->data[0]=x;
+ }
+ else
+ {
+ P->rear=(P->rear+1)%MAX;
+ P->data[P->rear]=x;
+ }
+}
+
+void enqueueF(dequeue *P,int x)
+{
+ if(empty(P))
+ {
+ P->rear=0;
+ P->front=0;
+ P->data[0]=x;
+ }
+ else
+ {
+ P->front=(P->front-1+MAX)%MAX;
+ P->data[P->front]=x;
+ }
+}
+
+int dequeueF(dequeue *P)
+{
+ int x;
+
+ x=P->data[P->front];
+
+ if(P->rear==P->front) //delete the last element
+ initialize(P);
+ else
+ P->front=(P->front+1)%MAX;
+
+ return(x);
+}
+
+int dequeueR(dequeue *P)
+{
+ int x;
+
+ x=P->data[P->rear];
+
+ if(P->rear==P->front)
+ initialize(P);
+ else
+ P->rear=(P->rear-1+MAX)%MAX;
+
+ return(x);
+}
+
+void print(dequeue *P)
+{
+ if(empty(P))
+ {
+ printf("\nQueue is empty!!");
+ exit(0);
+ }
+
+ int i;
+ i=P->front;
+
+ while(i!=P->rear)
+ {
+ printf("\n%d",P->data[i]);
+ i=(i+1)%MAX;
+ }
+
+ printf("\n%d\n",P->data[P->rear]);
+}
diff --git a/algorithms/data-structures/DoublyLinkedList/doubly_linked_list.cpp b/algorithms/data-structures/DoublyLinkedList/doubly_linked_list.cpp
new file mode 100644
index 00000000..2808971c
--- /dev/null
+++ b/algorithms/data-structures/DoublyLinkedList/doubly_linked_list.cpp
@@ -0,0 +1,271 @@
+#include"doubly_linked_list.h"
+
+using namespace std;
+
+template
+void DoublyLinkedList :: Push_back(T val)
+{
+
+ auto* new_node = new Node(move(val));
+
+ if(Tail != nullptr) //or if(Size != 0)
+ {
+ Tail->next = new_node;
+ new_node->prev = Tail;
+ Tail = new_node;
+
+ }
+ else
+ {
+ Tail = new_node;
+ Head = new_node;
+ }
+
+ Size_++;
+}
+
+
+template
+void DoublyLinkedList :: Pop_back()
+{
+ //if list is empty
+ if(Tail == nullptr) //or Head == NULL
+ {
+ throw runtime_error("Can't pop back the DLS is empty");
+ }
+
+ if(Tail == Head) // if there's only one element in the DLS
+ {
+ delete Tail;
+ Tail = nullptr;
+ Head = nullptr;
+
+ }
+ else
+ {
+ Node* previous_node = Tail->prev;
+
+ delete Tail;
+
+ Tail = previous_node;
+ Tail->next = nullptr;
+ }
+
+ Size_--;
+
+}
+
+template
+void DoublyLinkedList :: Push_front(T val)
+{
+
+ auto* new_node = new Node(move(val));
+
+ new_node->next = Head;
+ if(Head != nullptr)
+ {
+ Head->prev = new_node;
+
+ }
+ Head = new_node;
+ if(Tail == nullptr)
+ {
+ Tail = Head;
+ }
+
+ Size_++;
+
+}
+
+template
+void DoublyLinkedList :: Pop_front()
+{
+ if(Head == nullptr) //if dls is empty can't pop
+ {
+ throw runtime_error("Can't pop front the DLS is empty");
+ }
+
+ Node* next_node = Head->next;
+ delete Head;
+ Head = next_node;
+
+ if(Head == nullptr) //if we popped the last element
+ {
+ Tail = nullptr;
+ }
+ else
+ {
+ Head->prev = nullptr;
+ }
+
+ Size_--;
+
+}
+
+template
+void DoublyLinkedList :: Add_before(Node* node, T val)
+{
+
+ auto* new_node = new Node(move(val));
+ new_node->next = node;
+ new_node->prev = node->prev;
+ node->prev = new_node;
+
+ if(new_node->prev != nullptr)
+ {
+ new_node->prev->next = new_node;
+ }
+
+ if(Head == node)
+ {
+ Head = new_node;
+
+ }
+ Size_++;
+}
+
+
+
+template
+void DoublyLinkedList :: Add_after(Node* node,T val)
+{
+
+ auto* new_node = new Node(move(val));
+ new_node->prev = node;
+ new_node->next = node->next;
+ node->next = new_node;
+
+
+ if(new_node->next != nullptr)
+ {
+ new_node->next->prev = new_node;
+
+ }
+
+ if(Tail == node)
+ {
+ Tail = new_node;
+ }
+
+ Size_++;
+
+}
+
+template
+void DoublyLinkedList :: Display() const
+{
+
+ if(Size_ == 0)
+ {
+ cout<<"Linked List is empty";
+ }
+ else
+ {
+ for(Node* tmp_ptr = Head;tmp_ptr!= nullptr; tmp_ptr= tmp_ptr->next)
+ {
+ cout<data<<" ";
+
+ }
+ }
+ cout<<'\n';
+}
+
+
+
+template
+void DoublyLinkedList :: Clear()
+{
+
+ Node* tmp = Head;
+ if(Size_ == 0 )
+ {
+ throw runtime_error(" all cleared linked list is empty");
+ }
+
+ while(Head != nullptr)
+ {
+
+ Head = Head->next;
+ delete tmp;
+ tmp = Head;
+
+ }
+ cout<<" all cleared linked list is empty"<<'\n';
+ Tail = nullptr;
+ Size_ = 0;
+}
+template
+void DoublyLinkedList :: Insert_at(T val ,int position)
+{
+ if(position >Size_ || position <= 0)
+ {
+ cout<<"invalid position choose a position between 1 and size "<<'\n';
+ cout<<"size is: "<* tmp = Head;
+ //get a pointer of that position that position
+ for(int i =1 ; i<=position-1 ; i++,tmp = tmp->next);
+ Add_before(tmp,val);
+ }
+
+
+}
+
+template
+void DoublyLinkedList :: Delete_at(int position)
+{
+
+
+ if(Size_ ==0)
+ {
+ cout<<"Can't delete DLS is empty "<<'\n';
+ return;
+ }
+
+ if(position >Size_ || position < 0)
+ {
+ cout<<"invalid position choose a position between 1 and size "<<'\n';
+ cout<<"size is: "<* tmp = Head;
+
+ for(int i = 1; i <= position-1; i++,tmp = tmp->next);
+
+ if(tmp->next != nullptr)
+ {
+ tmp->next->prev = tmp->prev;
+ }
+
+ if(tmp->prev != nullptr)
+ {
+ tmp->prev->next = tmp->next;
+
+ }
+
+ if(Head == tmp)
+ {
+ Head = tmp->next;
+
+ }
+
+ if(Tail == tmp)
+ {
+ Tail = Tail->prev;
+ }
+
+ delete tmp;
+ Size_--;
+
+
+}
+
+
+
diff --git a/algorithms/data-structures/DoublyLinkedList/doubly_linked_list.h b/algorithms/data-structures/DoublyLinkedList/doubly_linked_list.h
new file mode 100644
index 00000000..cf6976f6
--- /dev/null
+++ b/algorithms/data-structures/DoublyLinkedList/doubly_linked_list.h
@@ -0,0 +1,66 @@
+#pragma once
+#include
+
+template
+class Node{
+
+
+ //each node has a next pointer and a previous pinter
+public:
+ T data;
+ Node* next;
+ Node* prev;
+
+
+ Node()
+ {
+ next = nullptr;
+ prev = nullptr;
+
+ }
+
+ explicit Node(T&& value) :
+ data(std::move(value)),
+ next(nullptr),
+ prev(nullptr)
+ {
+ }
+
+};
+
+
+template
+class DoublyLinkedList{
+
+private:
+ Node* Head;
+ Node* Tail;
+ int Size_;
+
+public:
+
+ DoublyLinkedList():
+ Head(nullptr),
+ Tail(nullptr),
+ Size_(0)
+ {
+ }
+
+ void Push_back(T val); //append
+ void Pop_back();
+ void Push_front(T val); //prepend
+ void Pop_front();
+ void Display() const;
+ void Clear();
+ void Insert_at(T val, int position);
+ void Delete_at(int position);
+ void Add_before(Node* node, T val);
+ void Add_after(Node* node,T val);
+
+ ~DoublyLinkedList()
+ {
+ std::cout<<"destructor is called"<<'\n';
+ Clear();
+ }
+
+};
diff --git a/algorithms/data-structures/Doubly_Linked_List.cpp b/algorithms/data-structures/Doubly_Linked_List.cpp
new file mode 100644
index 00000000..782c1b2c
--- /dev/null
+++ b/algorithms/data-structures/Doubly_Linked_List.cpp
@@ -0,0 +1,93 @@
+#include
+#include
+
+using namespace std;
+int main()
+{
+struct node{
+ int info;
+ node *left,*right;
+}*ptr,*start,*last,*save;
+
+int c=1,i=0,data,item;
+start=last=NULL;
+
+while(c<4 && c>0){
+ cout<<"1.Insert\n2.Deletion\n3.Link List\n";
+ cin>>c;
+
+ switch(c){
+ case 1:
+ cout<<"Enter Data\n";
+ cin>>data;
+
+ ptr=new node;
+ ptr->info=data;
+ ptr->left=last;
+ ptr->right=NULL;
+
+ if(start==NULL){
+ start=last=ptr;
+ }
+
+ else{
+ last->right=ptr;
+ last=ptr;
+ }
+ break;
+
+ case 2:
+ if(start==NULL){
+ cout<<"Underflow\n";
+ }
+
+ else{
+ cout<<"Enter Item to be Deleted\n";
+ cin>>item;
+ ptr=start;
+
+ while(ptr!=NULL){
+ if(ptr->info==item){
+ i++;
+ if(ptr==start){
+ start->left=NULL;
+ start=start->right;
+ }
+
+ else{
+ ptr->left->right=ptr->right;
+ ptr->right->left=ptr->left;
+ }
+ delete ptr;
+ cout<<"Item Deleted\n";
+ }
+ ptr=ptr->right;
+ }
+
+ if(i==0){
+ cout<<"Item Does not exist\n";
+ }
+ i=0;
+ }
+ break;
+
+ case 3:
+
+ ptr=start;
+
+ while(ptr!=NULL){
+ cout<info<<"->";
+ ptr=ptr->right;
+ }
+ cout<<"\n";
+ break;
+
+ default:
+ cout<<"Wrong Choice\nExiting...\n";
+ }
+
+}
+
+getch();
+return 0;
+}
\ No newline at end of file
diff --git a/algorithms/data-structures/Find the Unique Element b/algorithms/data-structures/Find the Unique Element
new file mode 100644
index 00000000..ce2a7bd8
--- /dev/null
+++ b/algorithms/data-structures/Find the Unique Element
@@ -0,0 +1,32 @@
+/*
+Given an integer array of size 2N + 1. In this given array,
+N numbers are present twice and one number is present only once in the array.
+You need to find and return that number which is unique in the array.
+*/
+
+#include
+#include
+#include "solution.h"
+using namespace std;
+
+int FindUnique(int arr[], int size){
+ int xor1 = 0;
+ for(int i = 0; i < size; i++)
+ xor1 ^= arr[i];
+ return xor1;
+}
+
+int main() {
+
+ int size;
+
+ cin>>size;
+ int *input=new int[1+size];
+
+ for(int i=0;i>input[i];
+
+ cout<
+using namespace std;
+const int SIZE = 26;
+
+struct MyNode{
+ struct MyNode *children[SIZE];
+ bool isEndOfWord;
+};
+
+// Returns new trie node
+struct MyNode *getNode(void)
+{
+ struct MyNode *pNode = new MyNode;
+
+ pNode->isEndOfWord = false;
+
+ for (int i = 0; i < SIZE; i++)
+ pNode->children[i] = NULL;
+
+ return pNode;
+}
+
+/* If not present, inserts key into trie
+ If the key is prefix of trie node, just
+ marks leaf node*/
+void insert(struct MyNode *root, string key)
+{
+ struct MyNode *pCrawl = root;
+
+ for (int i = 0; i < key.length(); i++)
+ {
+ int index = key[i] - 'a';
+ if (!pCrawl->children[index])
+ pCrawl->children[index] = getNode();
+
+ pCrawl = pCrawl->children[index];
+ }
+
+ // mark last node as leaf
+ pCrawl->isEndOfWord = true;
+}
+
+// Returns true if key presents in trie, else false
+bool search(struct MyNode *root, string key)
+{
+ struct MyNode *pCrawl = root;
+
+ for (int i = 0; i < key.length(); i++)
+ {
+ int index = key[i] - 'a';
+ if (!pCrawl->children[index])
+ return false;
+
+ pCrawl = pCrawl->children[index];
+ }
+
+ return (pCrawl != NULL && pCrawl->isEndOfWord);
+}
+
+// Driver Programme to check above functions
+int main()
+{
+ // For input keys use only lower case
+ string keys[] = {"the", "a", "there",
+ "answer", "any", "by",
+ "bye", "their" };
+ int n = sizeof(keys)/sizeof(keys[0]);
+
+ struct MyNode *root = getNode();
+
+ // Build trie
+ for (int i = 0; i < n; i++)
+ insert(root, keys[i]);
+
+ // Search for different keys to check is it present in our dictonary or not..??
+ search(root, "the")? cout << "Yes\n" : cout << "No\n";
+ search(root, "these")? cout << "Yes\n" : cout << "No\n";
+ return 0;
+}
diff --git a/algorithms/data-structures/avl-tree/AVL.cpp b/algorithms/data-structures/avl-tree/AVL.cpp
new file mode 100644
index 00000000..556e74d3
--- /dev/null
+++ b/algorithms/data-structures/avl-tree/AVL.cpp
@@ -0,0 +1,125 @@
+#include "AVL.h"
+using namespace std;
+
+//Calcule altura de um n
+int height_node(struct _Node_* node){
+ if(node == NULL)
+ return -1;
+ else
+ return node->height;
+}
+//Calcule o fator de balanceamento de um n
+int fatorBalanceamento_node(struct _Node_* node){
+ int valor = (height_node(node->right))-(height_node(node->left));
+ return valor;
+}
+//Calcula o maior valor
+int maior(int x, int y){
+ if(x > y)
+ return x;
+ else
+ return y;
+}
+//Rotao a esquerda
+AVLnode* RotationLL(AVLnode* root){
+ AVLnode*node;
+ node = root->left;
+ root->left = node->right;
+ root->height = maior(height_node(root->left),height_node(root->right)) + 1;
+ node->height = maior(height_node(node->left),height_node(root)) + 1;
+ root = node;
+ return root;
+}
+//Rotao a direita
+AVLnode* RotationRR(AVLnode* root){
+ AVLnode* node;
+ node = root->right;
+ root->right = node->left;
+ root->height = maior(height_node(root->left),height_node(root->right)) + 1;
+ node->height = maior(height_node(node->right),height_node(root)) + 1;
+ root = node;
+ return root;
+}
+//Rotao dupla a esquerda
+AVLnode* RotationLR(AVLnode* root){
+ root->left = RotationRR(root->left);
+ root = RotationLL(root);
+ return root;
+}
+//Rotao dupla a direita
+AVLnode* RotationRL(AVLnode* root){
+ root->right = RotationLL(root->right);
+ root = RotationRR(root);
+ return root;
+}
+//Insert AVLtree
+AVLnode* insert_AVLnode(AVLnode* root,Data* data){
+ //rvore vazia ou n folha
+ if(root == NULL){
+ AVLnode* novo;
+ novo = new AVLnode[1];
+ if(novo == NULL)
+ return NULL;
+ novo->data = data;
+ novo->height = 0;
+ novo->left = NULL;
+ novo->right = NULL;
+ return novo;
+ }
+
+ AVLnode* current = root;
+
+ /*Balaneamento*/
+ if(data->key < current->data->key){
+ current->left = insert_AVLnode(current->left, data);
+ if(current->left != NULL){
+ if(fatorBalanceamento_node(current) <= -2){
+ if(data->key < current->left->data->key)
+ root = RotationLL(root);
+ else
+ root = RotationLR(root);
+ }
+ }
+ return root;
+ }else{
+ if(data->key > current->data->key){
+ current->right = insert_AVLnode(current->right, data);
+ if(current->right != NULL){
+ if(fatorBalanceamento_node(current) >= 2){
+ if(data->key > current->right->data->key)
+ root = RotationRR(root);
+ else
+ root = RotationRL(root);
+ }
+ }
+ }
+ return root;
+ }
+ return NULL;
+}
+//Query
+void Query(AVLnode* root,Data** aux,string str,int* passos){
+ int value = valorString(str);
+ if(root != NULL){
+ if(root->data->key == value){
+ *aux = root->data;
+ }else if(value > root->data->key){
+ Query(root->right, &*aux, str, &*passos);
+ }else{
+ Query(root->left, &*aux, str, &*passos);
+ }
+ }
+ *passos = *passos + 1;
+}
+
+//Destruir
+void Destroy(AVLnode *t){
+ if(t != NULL){
+ Destroy(t->left);
+ Destroy(t->right);
+ t->data->linhas.clear();
+ t->data->ocorrencias.clear();
+ delete[]t->data;
+ delete[]t;
+ }
+}
diff --git a/algorithms/data-structures/avl-tree/AVL.h b/algorithms/data-structures/avl-tree/AVL.h
new file mode 100644
index 00000000..2e22c600
--- /dev/null
+++ b/algorithms/data-structures/avl-tree/AVL.h
@@ -0,0 +1,17 @@
+#ifndef _AVL_H_
+#define _AVL_H_
+#include "structs.h"
+
+typedef struct _Node_{
+ struct _data_ *data;
+ int height;
+ struct _Node_ *left;
+ struct _Node_ *right;
+} AVLnode;
+
+AVLnode* insert_AVLnode(AVLnode* root,Data* data);
+void Query(AVLnode* root,Data** aux,string str, int* passos);
+void Destroy(AVLnode *t);
+
+#endif
+
diff --git a/algorithms/data-structures/binary_search_tree.cpp b/algorithms/data-structures/binary_search_tree.cpp
new file mode 100644
index 00000000..9609c66a
--- /dev/null
+++ b/algorithms/data-structures/binary_search_tree.cpp
@@ -0,0 +1,142 @@
+#include
+#include
+#include
+using namespace std;
+struct tree
+{
+ int value;
+ tree *left;
+ tree *right;
+}*root=NULL;
+void inserte()
+{
+ int v,insert_left=0,insert_right=0;
+ cout<<"Enter Value To Insert: ";
+ cin>>v;
+ tree *newnode=(tree*)malloc(sizeof(tree));
+ newnode->value=v;
+ newnode->left=NULL;
+ newnode->right=NULL;
+ if(root==NULL)
+ root=newnode;
+ else
+ {
+ tree *temp=root;
+ while(1)
+ {
+ if(insert_left==1||insert_right==1)
+ break;
+ if(vvalue)
+ {
+ if(temp->left!=NULL)
+ temp=temp->left;
+ else
+ insert_left=1;
+ }
+ else
+ if(v>temp->value)
+ {
+ if(temp->right!=NULL)
+ temp=temp->right;
+ else
+ insert_right=1;
+ }
+ }
+ if(insert_left==1)
+ temp->left=newnode;
+ else
+ if(insert_right==1)
+ temp->right=newnode;
+ }
+}
+void preorder()
+{
+ tree *temp=root;
+ stack s;
+ repeat:
+ while(1)
+ {
+ if(temp->right!=NULL)
+ s.push(temp->right);
+ if(temp->left!=NULL)
+ {
+ cout<value<<" ";
+ temp=temp->left;
+ }
+ else
+ if(temp->left==NULL)
+ {
+ cout<value<<" ";
+ break;
+ }
+ }
+ while(!s.empty())
+ {
+ temp=s.top();
+ s.pop();
+ goto repeat;
+ }
+}
+void inorder()
+{
+ tree *temp=root;
+ stack s;
+ repeat:
+ while(1)
+ {
+ s.push(temp);
+ if(temp->left!=NULL)
+ temp=temp->left;
+ else
+ break;
+ }
+ while(1)
+ {
+ repeat1:
+ temp=s.top();
+ cout<value<<" ";
+ s.pop();
+ if(temp->right==NULL)
+ goto repeat1;
+ else
+ if(temp->right!=NULL)
+ {
+ temp=temp->right;
+ goto repeat;
+ }
+ else
+ if(s.empty())
+ break;
+ }
+}
+
+int main()
+{
+ int ch;
+ while(1)
+ {
+ cout<>ch;
+ if(ch==1)
+ inserte();
+ else
+ if(ch==2)
+ {
+ preorder();
+ cout<
+#include
+using namespace std;
+
+int lengthOfLongestSubsetWithZeroSum(int* arr, int size){
+ unordered_map mymap;
+ int sum = 0;
+ int maxLength = -1;
+ for(int i = 0; i < size; i++){
+ sum += arr[i];
+ int length = 0;
+
+ if(sum == 0){
+ length = i+1;
+ }else if(mymap.count(sum)){
+ length = i - mymap[sum];
+
+ }else{
+ mymap[sum] = i;
+ }
+
+ if(length > maxLength){
+ maxLength = length;
+ }
+ }
+ return maxLength;
+}
+
+int main(){
+ int size;
+
+ cin >> size;
+ int* arr = new int[size];
+ for(int i = 0; i < size; i++){
+ cin >> arr[i];
+ }
+ int ans = lengthOfLongestSubsetWithZeroSum(arr,size);
+ cout << ans << endl;
+ delete arr;
+}
diff --git a/algorithms/data-structures/largest_rectangle_area.cpp b/algorithms/data-structures/largest_rectangle_area.cpp
new file mode 100644
index 00000000..294b0c4b
--- /dev/null
+++ b/algorithms/data-structures/largest_rectangle_area.cpp
@@ -0,0 +1,61 @@
+/**
+ *
+ *@gaurav yadav
+
+ Maintain a stack
+ a. If stack is empty heights[stack.top()] <= heights[i])
+ push this i into stack.
+ b. Else keep popooing from stack till value at i at top of stack is
+ less than value at current index.
+ c. While popping calculate area
+ if stack is empty
+ area = i * heights[top];
+ it means that till this point value just removed has to be smallest element
+ if stack is not empty
+ area = heights[top] * (i - stack.top() - 1);
+
+ * Finally return maxArea
+ * Time complexity is O(n)
+ * Space complexity is O(n)
+ */
+class Solution {
+public:
+
+ int largestRectangleArea(vector& heights) {
+ int area = 0;
+ int maxArea = 0;
+ stack s;
+ int i;
+ for (i = 0; i < heights.size();) {
+ if (s.empty() || heights[s.top()] <= heights[i]) {
+ s.push(i++);
+ }
+ else {
+ int top = s.top();
+ s.pop();
+ if (s.empty()) {
+ area = i * heights[top];
+ }
+ else {
+ area = heights[top] * (i- s.top() -1);
+ }
+ if (area > maxArea)
+ maxArea = area;
+ }
+ }
+
+ while (!s.empty()) {
+ int top = s.top();
+ s.pop();
+ if (s.empty()) {
+ area = i * heights[top];
+ }
+ else {
+ area = heights[top] * (i- s.top() -1);
+ }
+ if (area > maxArea)
+ maxArea = area;
+ }
+ return maxArea;
+ }
+};
diff --git a/algorithms/data-structures/linkedlist/linkedLists.cpp b/algorithms/data-structures/linkedlist/linkedLists.cpp
new file mode 100644
index 00000000..518031bd
--- /dev/null
+++ b/algorithms/data-structures/linkedlist/linkedLists.cpp
@@ -0,0 +1,151 @@
+#include
+
+using namespace std;
+
+
+
+struct btNode
+{
+ int data;
+ btNode* left;
+ btNode* right;
+};
+
+
+
+
+
+
+void bst_insert(btNode*& bst_root, int anInt)
+{
+ if(bst_root == 0) // if list is empty
+ {
+ btNode* newNode = new btNode;
+
+ newNode->data = anInt;
+ newNode->left = 0;
+ newNode->right= 0;
+
+ bst_root = newNode;
+ return; // end function call
+ }
+
+ btNode* marker = new btNode; // traverse pointer
+ marker = bst_root;
+
+ while( marker != 0) // not at a leaf
+ {
+ if(marker->data == anInt) // if duplicate is found
+ {
+ marker->data = anInt; // overwrite and leave function
+ return;
+ }
+
+
+
+ if(marker->data > anInt) // if # is less than
+ {
+ if(marker->left != 0)
+ {
+ marker = marker->left; // if not empty move left
+ }
+
+ else // if empty, populate
+ {
+ btNode* newNode = new btNode; // create
+
+ newNode->data = anInt; // populate
+ newNode->left = 0;
+ newNode->right = 0;
+
+ marker->left = newNode; // attach
+ return;
+
+ }
+ }
+
+ if(marker->data < anInt) // if # is greater
+ {
+ if(marker->right != 0)
+ marker = marker->right;
+
+ else
+ {
+ btNode* newNode = new btNode;
+
+ newNode->data = anInt;
+ newNode->left = 0;
+ newNode->right = 0;
+
+ marker->right = newNode;
+ return;
+ }
+
+ }
+
+ }
+}
+
+
+ bool bst_remove(btNode*& bst_root, int anInt)
+ {
+
+ if(bst_root == 0) // if empty tree return false
+ return false;
+
+
+ if(bst_root->data > anInt) // if # is less than
+ return bst_remove(bst_root->left,anInt); // shift and recurse
+
+ if(bst_root->data < anInt) // if # is greater than
+ return bst_remove(bst_root->right,anInt);
+
+
+ if(bst_root->data == anInt) // if # is found
+ {
+ if(bst_root->left == 0) // if no left node
+ {
+ btNode* temp = bst_root; //mini remove max
+
+ bst_root = bst_root->right;
+
+ delete temp;
+ return true;
+ }
+
+ // if left node is occupied
+ bst_remove_max(bst_root->left, bst_root->data);
+ return true;
+ }
+
+ return false; // if nothing is found
+
+ }
+
+ void bst_remove_max(btNode*& bst_root, int& info)
+ {
+
+ if(bst_root->right != 0) // if right node is still occupied
+ return bst_remove_max(bst_root->right, info);
+
+
+ btNode* tempNode = new btNode; // prepare node to be deleted
+ tempNode = 0; // make NULL
+
+ btNode* marker = new btNode; // make a node to traverse tree
+ marker = bst_root;
+
+
+ if(bst_root->right == 0) // if at rightmost node
+ {
+ info = bst_root->data; // get information stored in node
+
+ tempNode = marker;
+
+ bst_root = bst_root->left;
+
+ delete tempNode;
+ }
+
+ }
+
diff --git a/algorithms/data-structures/queue/circular_buffer.cpp b/algorithms/data-structures/queue/circular_buffer.cpp
new file mode 100644
index 00000000..dc4e8c54
--- /dev/null
+++ b/algorithms/data-structures/queue/circular_buffer.cpp
@@ -0,0 +1,65 @@
+//
+// Queue: the entities in the collection are kept in
+// order and the principal (or only) operations on the
+// collection are the addition of entities to the rear
+// terminal position
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/data-scructures/
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: Carlos Abraham
+// Github: @abranhe
+//
+#include
+#include
+
+template
+class circular_buffer
+{
+private:
+ T* m_buffer;
+ long m_index;
+
+public:
+ circular_buffer()
+ : m_buffer {new T[SZ]()}
+ , m_index {0}
+ {
+ }
+
+ ~circular_buffer()
+ {
+ delete m_buffer;
+ }
+
+ std::vector get_ordered() noexcept
+ {
+ std::vector vec;
+ for (long i = 0; i < SZ; ++i)
+ vec.push_back(m_buffer[(i + m_index) % SZ]);
+ return vec;
+ }
+
+ void push(T x) noexcept
+ {
+ m_buffer[m_index] = x;
+ m_index = (m_index + 1) % SZ;
+ }
+};
+
+int main()
+{
+ circular_buffer buf;
+
+ buf.push(1);
+ buf.push(2);
+ buf.push(3);
+ buf.push(4);
+ buf.push(5);
+ buf.push(6);
+
+ for (auto x : buf.get_ordered())
+ std::cout << x << std::endl;
+}
diff --git a/algorithms/data-structures/queue/queue.cpp b/algorithms/data-structures/queue/queue.cpp
new file mode 100644
index 00000000..5a07ef27
--- /dev/null
+++ b/algorithms/data-structures/queue/queue.cpp
@@ -0,0 +1,86 @@
+//
+// Queue: the entities in the collection are kept in
+// order and the principal (or only) operations on the
+// collection are the addition of entities to the rear
+// terminal position
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/data-scructures/
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: ANUJ MODI
+// Github: @descifrado
+//
+#include
+#define qsize 5
+struct queue
+{
+ int arr[qsize];
+ int f, r;
+};
+typedef struct queue Queue;
+void
+enqueue (Queue * q, int x)
+{
+ if (q->r == qsize - 1)
+ printf ("QUEUE OVERFLOW\n");
+ else
+ q->arr[++q->r] = x;
+}
+
+int
+dequeue (Queue * q)
+{
+ if (q->f - q->r == 1)
+ printf ("Queue Underflow");
+ else
+ return (q->arr[q->f++]);
+}
+
+int
+main ()
+{
+ Queue q;
+ q.f = 0;
+ q.r = -1;
+ while (1)
+ {
+ printf("Enter 1 to Enqueue\nEnter 2 to Dequeue\nEnter 3 to Display All Elements\nEnter 0 to Exit\n");
+ int c;
+ scanf ("%d", &c);
+ switch (c)
+ {
+ case 0:
+ printf("Ended\n");
+ return 0;
+ case 1:
+ printf ("Enter Element to Enqueue\n");
+ int x;
+ scanf ("%d", &x);
+ enqueue (&q, x);
+ break;
+ case 2:
+ if (q.f - q.r == 1)
+ printf ("Queue Undeflow\n");
+ else
+ printf ("Dequeued Element is %d\n", dequeue (&q));
+ break;
+ case 3:
+ printf ("Elements of Queue Are\n");
+ if (q.f - q.r == 1)
+ {
+ printf ("Queue is Empty\n");
+ break;
+ }
+ int i;
+ for (i = q.f; i <= q.r; i++)
+ printf ("%d ", q.arr[i]);
+ printf ("\n");
+ break;
+ default:
+ printf ("Wrong Choice\n");
+ }
+ }
+ return 0;
+}
diff --git a/algorithms/data-structures/red-black-tree/RedBlack.cpp b/algorithms/data-structures/red-black-tree/RedBlack.cpp
new file mode 100644
index 00000000..2710e388
--- /dev/null
+++ b/algorithms/data-structures/red-black-tree/RedBlack.cpp
@@ -0,0 +1,143 @@
+#include "RedBlack.h"
+
+//Rotao a esquerda
+void rightRotate(RBnode** root, RBnode* x){
+ RBnode* y = x->left;
+ x->left = y->right;
+ if(y->right != NULL)
+ y->right->dad = x;
+ y->dad = x->dad;
+ if (x->dad == NULL){
+ *root = y;
+ }else{
+ if(x == x->dad->right)
+ x->dad->right = y;
+ else
+ x->dad->left = y;
+ }
+ y->right = x;
+ x->dad = y;
+}
+//Rotao a direita
+void leftRotate(RBnode** root,RBnode* x){
+ RBnode* y = x->right;
+ x->right = y->left;
+ if(y->left != NULL)
+ y->left->dad = x;
+ y->dad = x->dad;
+ if(x->dad == NULL)
+ *root = y;
+ else{
+ if(x == x->dad->left)
+ x->dad->left = y;
+ else
+ x->dad->right = y;
+ }
+ y->left = x;
+ x->dad = y;
+}
+
+//color 1-red 0-black
+void fix_insert(RBnode **root, RBnode *node){
+ RBnode* z = node;
+ while((*root != z) && (z->dad->color==1)){
+ if(z->dad == z->dad->dad->left){
+ RBnode* y = z->dad->dad->right;
+ /*Caso 1: Um n x est sendo inserido, e seu tio
+ vermelho ento necessrio recolorir o pai, o tio
+ o av*/
+ if((y!=NULL) && (y->color == 1)){
+ z->dad->color = 0;
+ y->color = 0;
+ z->dad->dad->color = 1;
+ z = z->dad->dad;
+ }else{
+ if(z == z->dad->right){
+ /*Caso 2:irmo preto e pai vermelho*/
+ z = z->dad;
+ leftRotate(&*root,z);
+ }
+ /*Caso 3:pai vermelho, irmo preto, av preto*/
+ z->dad->color = 0;
+ z->dad->dad->color = 1;
+ rightRotate(&*root,z->dad->dad);
+ }
+ }else{
+ RBnode* y = z->dad->dad->left;
+ if((y!=NULL) && (y->color == 1)){
+ /*caso 4*/
+ z->dad->color = 0;
+ y->color = 0;
+ z->dad->dad->color = 1;
+ z = z->dad->dad;
+ }else{
+ /*Caso 5:*/
+ if(z == z->dad->left){
+ z = z->dad;
+ rightRotate(&*root,z);
+ }
+ /*Caso 6:pai vermelho, av preto, tio preto*/
+ z->dad->color = 0;//pai fica preto
+ z->dad->dad->color = 1;//av fica vermelho
+ leftRotate(&*root, z->dad->dad);//gera uma rotao a esquerda
+ }
+ }
+ }
+}
+
+void RB_Insert(RBnode** root, Data* data){
+ RBnode* y = NULL;
+ RBnode* x = *root;
+ while(x != NULL){
+ y = x;
+ if(data->key < x->data->key)
+ x = x->left;
+ else
+ x = x->right;
+ }
+ RBnode* newnode = new RBnode[1];
+ if(newnode != NULL){
+ newnode->data = data;
+ newnode->color = 1;
+ newnode->left = NULL;
+ newnode->right = NULL;
+ newnode->dad = y;
+ }
+ if(y == NULL){
+ *root = newnode;
+ }else{
+ if(data->key < y->data->key)
+ y->left = newnode;
+ else
+ y->right = newnode;
+ }
+ fix_insert(&*root, newnode);
+ (*root)->color = 0;
+}
+
+//Query
+void RBQuery(RBnode* root,Data** aux,string str,int* passos){
+ int value = valorString(str);
+ if(root != NULL){
+ if(root->data->key == value){
+ *aux = root->data;
+ }else if(value > root->data->key){
+ RBQuery(root->right, &*aux, str, &*passos);
+ }else{
+ RBQuery(root->left, &*aux, str, &*passos);
+ }
+ }
+ *passos = *passos+1;
+}
+
+//Destruir
+void RBDestroy(RBnode *t){
+ if(t != NULL){
+ RBDestroy(t->left);
+ RBDestroy(t->right);
+ t->data->linhas.clear();
+ t->data->ocorrencias.clear();
+ delete[]t->data;
+ delete[]t;
+ }
+}
diff --git a/algorithms/data-structures/red-black-tree/RedBlack.h b/algorithms/data-structures/red-black-tree/RedBlack.h
new file mode 100644
index 00000000..d2743f54
--- /dev/null
+++ b/algorithms/data-structures/red-black-tree/RedBlack.h
@@ -0,0 +1,14 @@
+#ifndef _REDBLACK_H_
+#define _REDBLACK_H_
+#include "structs.h"
+
+ typedef struct _RBNode_{
+ int color;
+ struct _data_ *data;
+ struct _RBNode_ *left, *right, *dad;
+ } RBnode;
+
+ extern void RB_Insert(RBnode** root, Data* data);
+ extern void RBQuery(RBnode* root,Data** aux,string str,int* passos);
+ void RBDestroy(RBnode *t);
+#endif
diff --git a/algorithms/data-structures/segment_tree/a.out b/algorithms/data-structures/segment_tree/a.out
new file mode 100755
index 00000000..2aa14deb
Binary files /dev/null and b/algorithms/data-structures/segment_tree/a.out differ
diff --git a/algorithms/data-structures/segment_tree/min_in_range.cpp b/algorithms/data-structures/segment_tree/min_in_range.cpp
new file mode 100644
index 00000000..2a5fcb63
--- /dev/null
+++ b/algorithms/data-structures/segment_tree/min_in_range.cpp
@@ -0,0 +1,98 @@
+//
+// SEGMENT TREE : A Segment Tree is a data structure that allows
+// answering range queries over an array effectively,
+// while still being flexible enough to allow modifying the array.
+//
+// The All ▲lgorithms Project
+//
+// https://allalgorithms.com/data-scructures/
+// https://github.com/allalgorithms/cpp
+//
+// Contributed by: RITUPARNO BISWAS
+// Github: @roopbiswas
+//
+
+
+#include
+using namespace std;
+
+
+int st[400005],a[100005],y,l,r,x;
+
+void build(int in,int s,int e)
+{
+ if(s==e)
+ {
+ st[in]=a[s];
+ return;
+ }
+ int m=(s+e)/2;
+ build(2*in,s,m);
+ build(2*in+1,m+1,e);
+ st[in]= min(st[2*in],st[2*in+1]);
+}
+
+void update(int in,int s,int e)
+{
+ if(s==e)
+ {
+ st[in]=y;
+ return;
+ }
+ int m=(s+e)/2;
+ if(s<=x && x<=m)
+ update(2*in,s,m);
+ else
+ update(2*in+1,m+1,e);
+ st[in]=min(st[2*in],st[2*in+1]);
+}
+
+int query(int in,int s,int e)
+{
+ if(r>n;
+ for(i=0;i>a[i];
+ cin>>t;
+ char ch;
+ build(1,0,n-1);
+ while(t--)
+ {
+ cout<<"Enter choice : \nu : for update\nq : for query\n";
+ cin>>ch;
+
+ if(ch=='u')
+ {
+ cout<<"Enter values of index(1 based) and updated value\n";
+ cin>>x>>y;
+ x--;
+ update(1,0,n-1);
+ }
+ else
+ {
+ cout<<"Enter values(1 based) of upper and lower index\n";
+ cin>>l>>r;
+ l--;
+ r--;
+ cout<<"\nMINIMUM : "<
+using namespace std;
+
+
+int st[400005],a[100005],y,l,r,x;
+
+void build(int in,int s,int e)
+{
+ if(s==e)
+ {
+ st[in]=a[s];
+ return;
+ }
+ int m=(s+e)/2;
+ build(2*in,s,m);
+ build(2*in+1,m+1,e);
+ st[in]= st[2*in]+st[2*in+1];
+}
+
+void update(int in,int s,int e)
+{
+ if(s==e)
+ {
+ st[in]=y;
+ return;
+ }
+ int m=(s+e)/2;
+ if(s<=x && x<=m)
+ update(2*in,s,m);
+ else
+ update(2*in+1,m+1,e);
+ st[in]=st[2*in]+st[2*in+1];
+}
+
+int query(int in,int s,int e)
+{
+ if(r>n;
+ for(i=0;i>a[i];
+ cin>>t;
+ char ch;
+ build(1,0,n-1);
+ while(t--)
+ {
+ cout<<"Enter choice : \nu : for update\nq : for query\n";
+ cin>>ch;
+
+ if(ch=='u')
+ {
+ cout<<"Enter values of index(1 based) and updated value\n";
+ cin>>x>>y;
+ x--;
+ update(1,0,n-1);
+ }
+ else
+ {
+ cout<<"Enter values(1 based) of upper and lower index\n";
+ cin>>l>>r;
+ l--;
+ r--;
+ cout<<"\nSUM : "<
- 
- 
- 
- 
- 
- 
-