Skip to content

Commit 6d54e8d

Browse files
vamsee91vamsee91
authored
Add files via upload
1 parent 164a42e commit 6d54e8d

11 files changed

+631
-0
lines changed

‎BinarySearchTree.java

+156
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,156 @@
1+
package datastructures;
2+
3+
public class BinarySearchTree {
4+
5+
public static void main(String[] args) {
6+
BinarySearchTree bst = new BinarySearchTree();
7+
8+
Tree root = bst.insert(6);
9+
bst.insert(10);
10+
bst.insert(8);
11+
bst.insert(7);
12+
bst.insert(9);
13+
bst.insert(4);
14+
bst.insert(5);
15+
bst.insert(3);
16+
bst.traverse(BinarySearchTree.IN_ORDER);
17+
bst.traverse(BinarySearchTree.POST_ORDER);
18+
out("\n");
19+
//out(findMinimum(root).data + "\n");
20+
//out(findMaximum(root).data + "\n");
21+
//out(search(root, 5).data + "\n");
22+
//out(search(root, 7).data + "\n");
23+
bst.delete(6);
24+
bst.traverse(BinarySearchTree.IN_ORDER);
25+
out("\n");
26+
bst.delete(5);
27+
bst.traverse(BinarySearchTree.IN_ORDER);
28+
out("\n");
29+
bst.delete(4);
30+
bst.traverse(BinarySearchTree.IN_ORDER);
31+
out("\n");
32+
bst.delete(10);
33+
bst.traverse(BinarySearchTree.IN_ORDER);
34+
out("\n");
35+
}
36+
37+
public static final int IN_ORDER = 1;
38+
public static final int PRE_ORDER = 2;
39+
public static final int POST_ORDER = 3;
40+
41+
private Tree root;
42+
43+
/* O(h) where h is height of the tree */
44+
public Tree search(Tree node, int x) {
45+
if (root == null) return null;
46+
if (x == root.data) return root;
47+
if (x < root.data) return search(root.left, x);
48+
else return search(root.right, x);
49+
}
50+
51+
public Tree findMinimum() {
52+
if (root == null) return null;
53+
Tree min = root;
54+
while (min.left != null) {
55+
min = min.left;
56+
}
57+
return min;
58+
}
59+
60+
public Tree findMaximum() {
61+
if (root == null) return null;
62+
Tree max = root;
63+
while (max.right != null) {
64+
max = max.right;
65+
}
66+
return max;
67+
}
68+
69+
public void traverse(int order) {
70+
if (root == null) return;
71+
traverse(root, order);
72+
}
73+
74+
private void traverse(Tree node, int order) {
75+
if (root == null) return;
76+
if (order == PRE_ORDER) processNode(root);
77+
traverse(root.left, order);
78+
if (order == IN_ORDER) processNode(root);
79+
traverse(root.right, order);
80+
if (order == POST_ORDER) processNode(root);
81+
}
82+
83+
/* left most child in right subtree */
84+
public Tree successor(Tree node) {
85+
if (node == null || node.right == null) return null;
86+
Tree tmp = node.right;
87+
while (tmp.left != null) tmp = tmp.left;
88+
return tmp;
89+
}
90+
91+
/* right most child in left subtree */
92+
public Tree predecessor(Tree node) {
93+
if (node == null || node.left == null) return null;
94+
Tree tmp = node.left;
95+
while (tmp.right != null) tmp = tmp.right;
96+
return tmp.right;
97+
}
98+
99+
public Tree insert(int x) {
100+
return insert(root, x, null);
101+
}
102+
103+
public Tree insert(Tree node, int x, Tree parent) {
104+
if (root == null) {
105+
Tree tree = new Tree(x);
106+
tree.left = tree.right = null;
107+
tree.parent = parent;
108+
if (parent != null) {
109+
if (x < parent.data) parent.left = tree;
110+
else parent.right = tree;
111+
}
112+
root = tree;
113+
return tree;
114+
}
115+
if (x < root.data) return insert(root.left, x, root);
116+
else return insert(root.right, x, root);
117+
}
118+
119+
public boolean delete(int x) {
120+
Tree node = search(root, x);
121+
if (node == null) return false;
122+
Tree parent = node.parent;
123+
Tree delNode = null;
124+
125+
if (parent == null) { /* root node */
126+
if (node.left == null && node.right == null) { /* root only tree */
127+
root = null;
128+
return true;
129+
} else {
130+
if (node.left != null) delNode = predecessor(node);
131+
else delNode = successor(node);
132+
}
133+
} else { /* non root node */
134+
if (node.left != null && node.right != null) { /* both left and right children exist */
135+
delNode = successor(node);
136+
} else if (node.left != null || node.right != null) { /* only a single child exists */
137+
if (node.left != null) delNode = node.left;
138+
else delNode = node.right;
139+
} else { /* no children */
140+
141+
}
142+
}
143+
144+
delete(delNode.data);
145+
node.data = delNode.data;
146+
return true;
147+
}
148+
149+
private static void processNode(Tree tree) {
150+
out(tree.data + " ");
151+
}
152+
153+
private static void out(String str) {
154+
System.out.print(str);
155+
}
156+
}

‎DataStructuresTests.java

+64
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,64 @@
1+
package datastructures;
2+
3+
import java.util.Arrays;
4+
import java.util.Random;
5+
6+
public class DataStructuresTests {
7+
8+
9+
public static void main(String[] args) {
10+
//testStack();
11+
//testQueue();
12+
//testHeapSort();
13+
int[] a = new int[10];
14+
for (int i = 0; i < 10; a[i] = i++);
15+
System.out.println(Arrays.toString(a));
16+
new PQ().swap(2, 3, a);
17+
System.out.println(Arrays.toString(a));
18+
}
19+
20+
static void testStack() {
21+
outln("Testing stack");
22+
Stack<Integer> s = new Stack<Integer>();
23+
for (int i= 1; i < 15; i++) s.push(new Integer(i));
24+
for (int i= 1; i < 20; i++) outln(" " + s.pop());
25+
//for (int i= 1; i < 15; i++) s.push(new Integer(i));
26+
//for (int i= 1; i < 20; i++) outln(" " + s.pop());
27+
}
28+
29+
static void testQueue() {
30+
outln("Testing queue");
31+
Queue<Integer> q = new Queue<Integer>();
32+
for (int i= 1; i < 15; i++) q.add(new Integer(i));
33+
for (int i= 1; i < 20; i++) outln(" " + q.remove());
34+
//for (int i= 1; i < 15; i++) q.add(new Integer(i));
35+
//for (int i= 1; i < 20; i++) outln(" " + q.remove());
36+
}
37+
38+
static void testHeapSort() {
39+
outln("Testing Heap Sort");
40+
Integer[] arr = new Integer[10];
41+
Random rand = new Random(); int t = 20;
42+
for (int i = 0; i < arr.length; i++, t -= 2) {
43+
//arr[i] = new Integer(rand.nextInt(30));
44+
arr[i] = new Integer(t);
45+
}
46+
for (int i = 0; i < arr.length; i++) outln(" " + arr[i]);
47+
Heap<Integer> heap = new Heap<Integer>(arr, arr.length, Heap.Order.DESCENDING);
48+
for (int i = 0; i < arr.length; i++) {
49+
arr[i] = heap.remove();
50+
}
51+
outln("Sorted");
52+
for (int i = 0; i < arr.length; i++) outln(" " + arr[i]);
53+
}
54+
55+
static void out(String str) { System.out.println(str); }
56+
static void outln(String str) { System.out.println(str); }
57+
}
58+
59+
class PQ {
60+
//int[] a = new int[10];
61+
//PQ() { for (int i = 0; i < 10; a[i] = i++); }
62+
int[] swap(int p, int q, int[] a) { int tmp = a[p]; a[p] = a[q]; a[q] = tmp; return a; }
63+
//@Override public String toString() { return Arrays.toString(a); }
64+
}

‎Heap.java

+99
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,99 @@
1+
package datastructures;
2+
3+
public class Heap<E extends Comparable<E>> extends PriorityQueue<E> {
4+
public enum Order { ASCENDING, DESCENDING; };
5+
6+
E[] data;
7+
int order;
8+
9+
Heap(E[] data, int length) {
10+
this(data, length, Order.ASCENDING);
11+
}
12+
13+
@SuppressWarnings("unchecked")
14+
public Heap(E[] e, int length, Order o) {
15+
data = (E[])new Comparable[length];
16+
order = (o == Order.ASCENDING) ? 1 : -1;
17+
/* O(nlogn) */
18+
for (int i = 0; i < length; i++) insert(e[i]);
19+
/* O(2n) optimization using only bubble down */
20+
/*
21+
size = length;
22+
for (int i = 0; i < length; i++) data[i] = e[i];
23+
for (int i = (size/2-1); i >= 0; i--) bubbleDown(i);
24+
*/
25+
}
26+
27+
/* log(n) operation */
28+
@Override
29+
public void insert(E e) {
30+
if (size >= data.length) {
31+
// TODO add error handling
32+
} else {
33+
data[size] = e;
34+
bubbleUp(size);
35+
size++;
36+
}
37+
}
38+
39+
/* log(n) operation */
40+
private void bubbleUp(int index) {
41+
int pIndex = parent(index);
42+
if (pIndex == -1) return;
43+
if ((data[pIndex].compareTo(data[index]) * order) > 0) { /* read as p > data[index] */
44+
swap(index, pIndex);
45+
bubbleUp(pIndex);
46+
}
47+
}
48+
49+
/* log(n) operation */
50+
private void bubbleDown(int index) {
51+
int cIndex = firstChild(index);
52+
if (cIndex == -1) return;
53+
int minIndex = index;
54+
minIndex = ((data[index].compareTo(data[cIndex]) * order) < 0) ? index : cIndex;
55+
if(cIndex + 1 < size) {
56+
minIndex = ((data[minIndex].compareTo(data[cIndex + 1]) * order) < 0) ?
57+
minIndex : cIndex+1;
58+
}
59+
60+
if (minIndex != index) {
61+
swap(index, minIndex);
62+
bubbleDown(minIndex);
63+
}
64+
}
65+
66+
private int parent(int n) {
67+
return ((n+1)/2 - 1);
68+
}
69+
70+
private int firstChild(int n) {
71+
if ((2*n + 1) < size) return (2*n + 1);
72+
else return -1;
73+
}
74+
75+
private void swap(int a, int b) {
76+
E t = data[a];
77+
data[a] = data[b];
78+
data[b] = t;
79+
}
80+
81+
@Override
82+
public E top() {
83+
E e = null;
84+
if(size > 0) e = data[0];
85+
return e;
86+
}
87+
88+
@Override
89+
public E remove() {
90+
E e = null;
91+
if(size > 0) {
92+
e = data[0];
93+
data[0] = data[size - 1];
94+
size--;
95+
bubbleDown(0);
96+
}
97+
return e;
98+
}
99+
}

‎Link.java

+11
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,11 @@
1+
package datastructures;
2+
3+
public class Link<E> {
4+
public Link(E data, Link<E> next) {
5+
this.data = data;
6+
this.next = next;
7+
}
8+
9+
E data;
10+
Link<E> next, prev;
11+
}

0 commit comments

Comments
 (0)