Professional Documents
Culture Documents
import java.util.*;
import java.lang.*;
import java.io.*;
import java.util.LinkedList;
class MaxFlow
{
static final int V = 6; //Number of vertices in graph
boolean bfs(int rGraph[][], int s, int t, int parent[])
{
boolean visited[] = new boolean[V];
for(int i=0; i<V; ++i)
visited[i]=false;
LinkedList<Integer> queue = new LinkedList<Integer>();
queue.add(s);
visited[s] = true;
parent[s]=-1;
while (queue.size()!=0)
{ int u = queue.poll();
for (int v=0; v<V; v++)
{
if (visited[v]==false && rGraph[u][v] > 0)
{
queue.add(v);
parent[v] = u;
visited[v] = true;
}
}
}
return (visited[t] == true);
}
int fordFulkerson(int graph[][], int s, int t)
{
int u, v;
}
}
Implementation of bipartite graph
import java.util.*;
class Edge
{
int source, dest;
// Constructor
Graph(List<Edge> edges, int N) {
adjList = new ArrayList<>(N);
for (int i = 0; i < N; i++) {
adjList.add(i, new ArrayList<>());
}
if (!discovered[u])
{
discovered[u] = true;
level[u] = level[v] + 1;
q.add(u);
}
else if (level[v] == level[u])
return false;
}
}
return true;
}
if (BFS(graph, 1, N))
System.out.println("Bipartite Graph");
else
System.out.println("Not a Bipartite Graph");
}
}
Implementation of Red Black Tree
#include<stdio.h>
#include<stdlib.h>
x->right = y->left;
if (x->right != NULL)
x->right->parent = x;
y->parent = x->parent;
if (x->parent == NULL)
(*root) = y;
y->left = x;
x->parent = y;
}
if (y->color == 'R')
{
y->color = 'B';
z->parent->color = 'B';
z->parent->parent->color = 'R';
z = z->parent->parent;
}
else
{
while (x != NULL)
{
y = x;
if (z->data < x->data)
x = x->left;
else
x = x->right;
}
z->parent = y;
if (z->data > y->data)
y->right = z;
else
y->left = z;
z->color = 'R';
insertFixUp(root,z);
}
}
return 0;
}
TwoThreeTree()
{
root = null;
traverse = new Traversal();
size = 0;
}
void insert(T x)
{
if (root == null)
{
root = new Node(x);
size++;
}
root.insert(x);
modified = true;
}
int size()
{
return size;
}
boolean search(T x)
{
if (root == null)
return false;
return root.search(x).keys.contains(x);
}
void clear()
{
root = null;
size = 0;
}
public Iterator<T> iterator()
{
if (modified)
{
traverse.traverseTree();
modified = false;
}
return traverse.ordered.iterator();
}
void traverseTree()
{
ordered = new ArrayList<>();
traverse(root);
}
void traverse(Node n)
{
if (n.children.size() == 0)
ordered.addAll(n.keys);
else
{
traverse(n.children.get(0));
ordered.add(n.keys.get(0));
traverse(n.children.get(1));
if (n.children.size() == 3)
{
ordered.add(n.keys.get(1
traverse(n.children.get(2));
}
}
}
}
Node(T data)
{
keys.add(data);
}
this.keys.set(i, this.keys.get(lastIndex));
this.keys.set(lastIndex, temp);
}
}
}
int i = 0;
while (i < this.keys.size() && x.compareTo(this.keys.get(i)) > 0)
i++;
boolean childWasSplit;
if (i < this.children.size())
childWasSplit = this.children.get(i).insert(x);
else
{
this.addKey(x);
size++;
if (this.keys.size() == 3)
{
this.splitify();
return true;
}
return false;
}
if (childWasSplit)
{
Node tempChild = this.children.get(i);
this.addKey(tempChild.keys.get(0));
this.children.set(i, tempChild.children.get(0));
this.children.add(i+1, tempChild.children.get(1));
if (this.children.size() == 4)
{
this.splitify();
return true;
}
}
return false;
}
T tempKey = this.keys.get(1);
this.keys.clear
this.keys.add(tempKey);
}