diff --git a/Greedy/java/kruskal. Java b/Greedy/java/kruskal. Java new file mode 100644 index 0000000..a0daccf --- /dev/null +++ b/Greedy/java/kruskal. Java @@ -0,0 +1,122 @@ +// Kruskal's algorithm in Java + +import java.util.*; + +class Graph { + class Edge implements Comparable { + int src, dest, weight; + + public int compareTo(Edge compareEdge) { + return this.weight - compareEdge.weight; + } + }; + + // Union + class subset { + int parent, rank; + }; + + int vertices, edges; + Edge edge[]; + + // Graph creation + Graph(int v, int e) { + vertices = v; + edges = e; + edge = new Edge[edges]; + for (int i = 0; i < e; ++i) + edge[i] = new Edge(); + } + + int find(subset subsets[], int i) { + if (subsets[i].parent != i) + subsets[i].parent = find(subsets, subsets[i].parent); + return subsets[i].parent; + } + + void Union(subset subsets[], int x, int y) { + int xroot = find(subsets, x); + int yroot = find(subsets, y); + + if (subsets[xroot].rank < subsets[yroot].rank) + subsets[xroot].parent = yroot; + else if (subsets[xroot].rank > subsets[yroot].rank) + subsets[yroot].parent = xroot; + else { + subsets[yroot].parent = xroot; + subsets[xroot].rank++; + } + } + + // Applying Krushkal Algorithm + void KruskalAlgo() { + Edge result[] = new Edge[vertices]; + int e = 0; + int i = 0; + for (i = 0; i < vertices; ++i) + result[i] = new Edge(); + + // Sorting the edges + Arrays.sort(edge); + subset subsets[] = new subset[vertices]; + for (i = 0; i < vertices; ++i) + subsets[i] = new subset(); + + for (int v = 0; v < vertices; ++v) { + subsets[v].parent = v; + subsets[v].rank = 0; + } + i = 0; + while (e < vertices - 1) { + Edge next_edge = new Edge(); + next_edge = edge[i++]; + int x = find(subsets, next_edge.src); + int y = find(subsets, next_edge.dest); + if (x != y) { + result[e++] = next_edge; + Union(subsets, x, y); + } + } + for (i = 0; i < e; ++i) + System.out.println(result[i].src + " - " + result[i].dest + ": " + result[i].weight); + } + + public static void main(String[] args) { + int vertices = 6; // Number of vertices + int edges = 8; // Number of edges + Graph G = new Graph(vertices, edges); + + G.edge[0].src = 0; + G.edge[0].dest = 1; + G.edge[0].weight = 4; + + G.edge[1].src = 0; + G.edge[1].dest = 2; + G.edge[1].weight = 4; + + G.edge[2].src = 1; + G.edge[2].dest = 2; + G.edge[2].weight = 2; + + G.edge[3].src = 2; + G.edge[3].dest = 3; + G.edge[3].weight = 3; + + G.edge[4].src = 2; + G.edge[4].dest = 5; + G.edge[4].weight = 2; + + G.edge[5].src = 2; + G.edge[5].dest = 4; + G.edge[5].weight = 4; + + G.edge[6].src = 3; + G.edge[6].dest = 4; + G.edge[6].weight = 3; + + G.edge[7].src = 5; + G.edge[7].dest = 4; + G.edge[7].weight = 3; + G.KruskalAlgo(); + } +} diff --git a/Greedy/kruskal'sAlgoritym. Java b/Greedy/kruskal'sAlgoritym. Java new file mode 100644 index 0000000..c186d1e --- /dev/null +++ b/Greedy/kruskal'sAlgoritym. Java @@ -0,0 +1,120 @@ +import java.util.*; + +class Graph { + class Edge implements Comparable { + int src, dest, weight; + + public int compareTo(Edge compareEdge) { + return this.weight - compareEdge.weight; + } + }; + + // Union + class subset { + int parent, rank; + }; + + int vertices, edges; + Edge edge[]; + + // Graph creation + Graph(int v, int e) { + vertices = v; + edges = e; + edge = new Edge[edges]; + for (int i = 0; i < e; ++i) + edge[i] = new Edge(); + } + + int find(subset subsets[], int i) { + if (subsets[i].parent != i) + subsets[i].parent = find(subsets, subsets[i].parent); + return subsets[i].parent; + } + + void Union(subset subsets[], int x, int y) { + int xroot = find(subsets, x); + int yroot = find(subsets, y); + + if (subsets[xroot].rank < subsets[yroot].rank) + subsets[xroot].parent = yroot; + else if (subsets[xroot].rank > subsets[yroot].rank) + subsets[yroot].parent = xroot; + else { + subsets[yroot].parent = xroot; + subsets[xroot].rank++; + } + } + + // Applying Krushkal Algorithm + void KruskalAlgo() { + Edge result[] = new Edge[vertices]; + int e = 0; + int i = 0; + for (i = 0; i < vertices; ++i) + result[i] = new Edge(); + + // Sorting the edges + Arrays.sort(edge); + subset subsets[] = new subset[vertices]; + for (i = 0; i < vertices; ++i) + subsets[i] = new subset(); + + for (int v = 0; v < vertices; ++v) { + subsets[v].parent = v; + subsets[v].rank = 0; + } + i = 0; + while (e < vertices - 1) { + Edge next_edge = new Edge(); + next_edge = edge[i++]; + int x = find(subsets, next_edge.src); + int y = find(subsets, next_edge.dest); + if (x != y) { + result[e++] = next_edge; + Union(subsets, x, y); + } + } + for (i = 0; i < e; ++i) + System.out.println(result[i].src + " - " + result[i].dest + ": " + result[i].weight); + } + + public static void main(String[] args) { + int vertices = 6; // Number of vertices + int edges = 8; // Number of edges + Graph G = new Graph(vertices, edges); + + G.edge[0].src = 0; + G.edge[0].dest = 1; + G.edge[0].weight = 4; + + G.edge[1].src = 0; + G.edge[1].dest = 2; + G.edge[1].weight = 4; + + G.edge[2].src = 1; + G.edge[2].dest = 2; + G.edge[2].weight = 2; + + G.edge[3].src = 2; + G.edge[3].dest = 3; + G.edge[3].weight = 3; + + G.edge[4].src = 2; + G.edge[4].dest = 5; + G.edge[4].weight = 2; + + G.edge[5].src = 2; + G.edge[5].dest = 4; + G.edge[5].weight = 4; + + G.edge[6].src = 3; + G.edge[6].dest = 4; + G.edge[6].weight = 3; + + G.edge[7].src = 5; + G.edge[7].dest = 4; + G.edge[7].weight = 3; + G.KruskalAlgo(); + } +} diff --git a/LinkedList/c++/DoublyLinkedList.cpp b/LinkedList/c++/DoublyLinkedList.cpp new file mode 100644 index 0000000..982db14 --- /dev/null +++ b/LinkedList/c++/DoublyLinkedList.cpp @@ -0,0 +1,35 @@ +#include +using namespace std; +struct Node { + int data; + struct Node *prev; + struct Node *next; +}; +struct Node* head = NULL; +void insert(int newdata) { + struct Node* newnode = (struct Node*) malloc(sizeof(struct Node)); + newnode->data = newdata; + newnode->prev = NULL; + newnode->next = head; + if(head != NULL) + head->prev = newnode ; + head = newnode; +} +void display() { + struct Node* ptr; + ptr = head; + while(ptr != NULL) { + cout<< ptr->data <<" "; + ptr = ptr->next; + } +} +int main() { + insert(3); + insert(1); + insert(7); + insert(2); + insert(9); + cout<<"The doubly linked list is: "; + display(); + return 0; +} diff --git a/LinkedList/c++/LinkedList.cpp b/LinkedList/c++/LinkedList.cpp new file mode 100644 index 0000000..fa8ddd0 --- /dev/null +++ b/LinkedList/c++/LinkedList.cpp @@ -0,0 +1,31 @@ +#include +using namespace std; +struct Node { + int data; + struct Node *next; +}; +struct Node* head = NULL; +void insert(int new_data) { + struct Node* new_node = (struct Node*) malloc(sizeof(struct Node)); + new_node->data = new_data; + new_node->next = head; + head = new_node; +} +void display() { + struct Node* ptr; + ptr = head; + while (ptr != NULL) { + cout<< ptr->data <<" "; + ptr = ptr->next; + } +} +int main() { + insert(3); + insert(1); + insert(7); + insert(2); + insert(9); + cout<<"The linked list is: "; + display(); + return 0; +} diff --git a/LinkedList/c++/StackUsingLinkedList. cpp b/LinkedList/c++/StackUsingLinkedList. cpp new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/LinkedList/c++/StackUsingLinkedList. cpp @@ -0,0 +1 @@ + diff --git a/SinglyLinkedlist.cpp b/SinglyLinkedlist.cpp new file mode 100644 index 0000000..fa8ddd0 --- /dev/null +++ b/SinglyLinkedlist.cpp @@ -0,0 +1,31 @@ +#include +using namespace std; +struct Node { + int data; + struct Node *next; +}; +struct Node* head = NULL; +void insert(int new_data) { + struct Node* new_node = (struct Node*) malloc(sizeof(struct Node)); + new_node->data = new_data; + new_node->next = head; + head = new_node; +} +void display() { + struct Node* ptr; + ptr = head; + while (ptr != NULL) { + cout<< ptr->data <<" "; + ptr = ptr->next; + } +} +int main() { + insert(3); + insert(1); + insert(7); + insert(2); + insert(9); + cout<<"The linked list is: "; + display(); + return 0; +} diff --git a/Stacks & Queues/c++/DynamicStack.cpp b/Stacks & Queues/c++/DynamicStack.cpp new file mode 100644 index 0000000..18d7d91 --- /dev/null +++ b/Stacks & Queues/c++/DynamicStack.cpp @@ -0,0 +1,71 @@ +#include +#include + +struct Node +{ + int data; + struct Node *next; +}*top = NULL; + +void push(int); +void pop(); +void display(); + +void main() +{ + int choice, value; + clrscr(); + printf("\n:: Stack using Linked List ::\n"); + while(1){ + printf("\n****** MENU ******\n"); + printf("1. Push\n2. Pop\n3. Display\n4. Exit\n"); + printf("Enter your choice: "); + scanf("%d",&choice); + switch(choice){ + case 1: printf("Enter the value to be insert: "); + scanf("%d", &value); + push(value); + break; + case 2: pop(); break; + case 3: display(); break; + case 4: exit(0); + default: printf("\nWrong selection!!! Please try again!!!\n"); + } + } +} +void push(int value) +{ + struct Node *newNode; + newNode = (struct Node*)malloc(sizeof(struct Node)); + newNode->data = value; + if(top == NULL) + newNode->next = NULL; + else + newNode->next = top; + top = newNode; + printf("\nInsertion is Success!!!\n"); +} +void pop() +{ + if(top == NULL) + printf("\nStack is Empty!!!\n"); + else{ + struct Node *temp = top; + printf("\nDeleted element: %d", temp->data); + top = temp->next; + free(temp); + } +} +void display() +{ + if(top == NULL) + printf("\nStack is Empty!!!\n"); + else{ + struct Node *temp = top; + while(temp->next != NULL){ + printf("%d--->",temp->data); + temp = temp -> next; + } + printf("%d--->NULL",temp->data); + } +} diff --git a/Stacks & Queues/c++/StackUsingLinkedList. cpp b/Stacks & Queues/c++/StackUsingLinkedList. cpp new file mode 100644 index 0000000..18d7d91 --- /dev/null +++ b/Stacks & Queues/c++/StackUsingLinkedList. cpp @@ -0,0 +1,71 @@ +#include +#include + +struct Node +{ + int data; + struct Node *next; +}*top = NULL; + +void push(int); +void pop(); +void display(); + +void main() +{ + int choice, value; + clrscr(); + printf("\n:: Stack using Linked List ::\n"); + while(1){ + printf("\n****** MENU ******\n"); + printf("1. Push\n2. Pop\n3. Display\n4. Exit\n"); + printf("Enter your choice: "); + scanf("%d",&choice); + switch(choice){ + case 1: printf("Enter the value to be insert: "); + scanf("%d", &value); + push(value); + break; + case 2: pop(); break; + case 3: display(); break; + case 4: exit(0); + default: printf("\nWrong selection!!! Please try again!!!\n"); + } + } +} +void push(int value) +{ + struct Node *newNode; + newNode = (struct Node*)malloc(sizeof(struct Node)); + newNode->data = value; + if(top == NULL) + newNode->next = NULL; + else + newNode->next = top; + top = newNode; + printf("\nInsertion is Success!!!\n"); +} +void pop() +{ + if(top == NULL) + printf("\nStack is Empty!!!\n"); + else{ + struct Node *temp = top; + printf("\nDeleted element: %d", temp->data); + top = temp->next; + free(temp); + } +} +void display() +{ + if(top == NULL) + printf("\nStack is Empty!!!\n"); + else{ + struct Node *temp = top; + while(temp->next != NULL){ + printf("%d--->",temp->data); + temp = temp -> next; + } + printf("%d--->NULL",temp->data); + } +} diff --git a/Stacks & Queues/c++/queue_stl.cpp b/Stacks & Queues/c++/queue_stl.cpp new file mode 100644 index 0000000..b972fa4 --- /dev/null +++ b/Stacks & Queues/c++/queue_stl.cpp @@ -0,0 +1,31 @@ +#include +#include + +using namespace std; + +int main() { + + // create a queue of string + queue animals; + + // push elements into the queue + animals.push("Cat"); + animals.push("Dog"); + + cout << "Queue: "; + + // print elements of queue + // loop until queue is empty + while(!animals.empty()) { + + // print the element + cout << animals.front() << ", "; + + // pop element from the queue + animals.pop(); + } + + cout << endl; + + return 0; +}