Skip to content

Commit d872c41

Browse files
gkcsgkcs
committed
Data structures code added
1 parent a66041f commit d872c41

File tree

9 files changed

+644
-1
lines changed

9 files changed

+644
-1
lines changed

‎src/main/java/main/java/Solution.java‎ renamed to ‎src/main/java/main/java/MatrixSum.java‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -5,7 +5,7 @@
55
import java.io.InputStreamReader;
66
import java.util.Arrays;
77

8-
public class Solution {
8+
public class MatrixSum {
99
public static void main(String[] args) throws IOException {
1010
int n = 5, m = 5;
1111
int matrix[][] = new int[n][m];

‎src/main/java/main/java/course/BST.java‎

Lines changed: 80 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,80 @@
1+
package main.java.course;
2+
3+
import java.util.TreeSet;
4+
5+
public class BST {
6+
private BST left, right;
7+
private final int nodeValue;
8+
9+
public BST(final int nodeValue) {
10+
this.nodeValue = nodeValue;
11+
}
12+
13+
public void add(int element) {
14+
if (nodeValue > element) {
15+
if (left == null) {
16+
left = new BST(element);
17+
} else {
18+
left.add(element);
19+
}
20+
} else {
21+
if (right == null) {
22+
right = new BST(element);
23+
} else {
24+
right.add(element);
25+
}
26+
}
27+
}
28+
29+
public void delete(int element) {
30+
if (nodeValue > element) {
31+
if (left == null) {
32+
throw new RuntimeException("Element does not exist!");
33+
} else {
34+
left.delete(element);
35+
}
36+
} else {
37+
if (right == null) {
38+
throw new RuntimeException("Element does not exist!");
39+
} else {
40+
right.delete(element);
41+
}
42+
}
43+
}
44+
45+
public boolean search(int element) {
46+
if (nodeValue == element) {
47+
return true;
48+
}
49+
if (nodeValue > element) {
50+
return left != null && left.search(element);
51+
} else {
52+
return right != null && right.search(element);
53+
}
54+
}
55+
56+
@Override
57+
public String toString() {
58+
return "BST{" +
59+
"left=" + left +
60+
", right=" + right +
61+
", nodeValue=" + nodeValue +
62+
'}';
63+
}
64+
}
65+
66+
class BSTMain {
67+
public static void main(String[] args) {
68+
// BST bst = new BST(0);
69+
TreeSet<Integer> treeSet = new TreeSet<>();
70+
treeSet.add(-1);
71+
treeSet.add(12);
72+
treeSet.add(432);
73+
treeSet.add(34);
74+
treeSet.add(-46);
75+
treeSet.add(-232);
76+
treeSet.add(-45);
77+
System.out.println(treeSet.contains(11));
78+
System.out.println(treeSet);
79+
}
80+
}

‎src/main/java/main/java/course/DynamicList.java‎

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,96 @@
1+
package main.java.course;
2+
3+
import java.util.ArrayList;
4+
import java.util.Arrays;
5+
6+
public class DynamicList {
7+
private String array[];
8+
private int size;
9+
10+
public DynamicList() {
11+
array = new String[5];
12+
size = 0;
13+
}
14+
15+
public void add(String element) {
16+
if (array.length == size) {
17+
System.out.println("DOUBLING SIZE");
18+
String[] temp = new String[size * 2];
19+
System.arraycopy(array, 0, temp, 0, array.length);
20+
array = temp;
21+
}
22+
array[size] = element;
23+
size++;
24+
}
25+
26+
public String delete(int position) {
27+
if (position < 0 || position >= size) {
28+
throw new IllegalArgumentException();
29+
}
30+
String deletedElement = array[position];
31+
for (int i = position; i < size - 1; i++) {
32+
array[i] = array[i + 1];
33+
}
34+
if (size != array.length) {
35+
array[size - 1] = array[size];
36+
}
37+
size--;
38+
if (size < array.length / 4.0) {
39+
System.out.println("HALVING SIZE");
40+
String[] temp = new String[array.length / 2];
41+
System.arraycopy(array, 0, temp, 0, temp.length);
42+
array = temp;
43+
}
44+
return deletedElement;
45+
}
46+
47+
public String get(int position) {
48+
if (position < 0 || position >= size) {
49+
throw new IllegalArgumentException();
50+
}
51+
return array[position];
52+
}
53+
54+
public boolean isEmpty() {
55+
return size == 0;
56+
}
57+
58+
@Override
59+
public String toString() {
60+
return "DynamicList{" +
61+
"array=" + Arrays.toString(array) +
62+
", size=" + size +
63+
'}';
64+
}
65+
}
66+
67+
class DynamicListMain {
68+
public static void main(String[] args) {
69+
// final DynamicList dynamicList = new DynamicList();
70+
// dynamicList.add("Java");
71+
// dynamicList.add("Python");
72+
// dynamicList.add("C++");
73+
// dynamicList.add("C#");
74+
// dynamicList.add("JavaScript");
75+
// dynamicList.add("Cobol");
76+
// dynamicList.delete(0);
77+
// dynamicList.delete(0);
78+
// dynamicList.delete(0);
79+
// dynamicList.delete(0);
80+
// System.out.println(dynamicList);
81+
ArrayList<String> dynamicList = new ArrayList<>();
82+
dynamicList.add("Java");
83+
dynamicList.add("Python");
84+
dynamicList.add("C++");
85+
dynamicList.add("C#");
86+
dynamicList.add("JavaScript");
87+
dynamicList.add("Cobol");
88+
dynamicList.remove(0);
89+
dynamicList.remove(0);
90+
dynamicList.remove(0);
91+
System.out.println(dynamicList);
92+
dynamicList.remove(2);
93+
dynamicList.remove("Cobol");
94+
System.out.println(dynamicList);
95+
}
96+
}

‎src/main/java/main/java/course/HashMap.java‎

Lines changed: 109 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,109 @@
1+
package main.java.course;
2+
3+
import java.util.ArrayList;
4+
import java.util.List;
5+
6+
public class HashMap {
7+
private final List<List<Pair>> buckets;
8+
9+
public HashMap() {
10+
buckets = new ArrayList<>();
11+
for (int i = 0; i < 10; i++) {
12+
buckets.add(new ArrayList<>());
13+
}
14+
}
15+
16+
public void add(String key, Object value) {
17+
final List<Pair> pairs = getBucket(key);
18+
for (final Pair pair : pairs) {
19+
if (pair.key.equals(key)) {
20+
pairs.remove(pair);
21+
break;
22+
}
23+
}
24+
pairs.add(new Pair(key, value));
25+
}
26+
27+
public Object delete(String key) {
28+
final List<Pair> pairs = getBucket(key);
29+
Object removedValue = null;
30+
for (final Pair pair : pairs) {
31+
if (pair.key.equals(key)) {
32+
pairs.remove(pair);
33+
removedValue = pair.value;
34+
break;
35+
}
36+
}
37+
return removedValue;
38+
}
39+
40+
public Object search(String key) {
41+
final List<Pair> pairs = getBucket(key);
42+
Object value = null;
43+
for (final Pair pair : pairs) {
44+
if (pair.key.equals(key)) {
45+
value = pair.value;
46+
}
47+
}
48+
return value;
49+
}
50+
51+
private List<Pair> getBucket(final String key) {
52+
return buckets.get(key.hashCode() % 10);
53+
}
54+
55+
@Override
56+
public String toString() {
57+
return "HashMap{" +
58+
"buckets=" + buckets +
59+
'}';
60+
}
61+
}
62+
63+
class Pair {
64+
final String key;
65+
final Object value;
66+
67+
public Pair(final String key, final Object value) {
68+
this.key = key;
69+
this.value = value;
70+
}
71+
72+
@Override
73+
public boolean equals(final Object o) {
74+
return key.equals(((Pair) o).key);
75+
}
76+
77+
@Override
78+
public int hashCode() {
79+
return key.hashCode();
80+
}
81+
82+
@Override
83+
public String toString() {
84+
return "Pair{" +
85+
"key='" + key + '\'' +
86+
", value=" + value +
87+
'}';
88+
}
89+
}
90+
91+
class HashMapMain {
92+
public static void main(String[] args) {
93+
// HashMap hashMap = new HashMap();
94+
// hashMap.add("java", "course");
95+
// hashMap.add("C++", "code");
96+
// hashMap.add("C#", "Microsoft");
97+
// System.out.println(hashMap);
98+
// System.out.println(hashMap.search("java"));
99+
// System.out.println(hashMap);
100+
java.util.HashMap<String, Object> hashMap = new java.util.HashMap<>();
101+
hashMap.put("java", "course");
102+
hashMap.put("C++", "code");
103+
hashMap.put("C#", "Microsoft");
104+
System.out.println(hashMap);
105+
System.out.println(hashMap.remove("java"));
106+
System.out.println(hashMap);
107+
108+
}
109+
}

‎src/main/java/main/java/course/Map.java‎

Lines changed: 96 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,96 @@
1+
package main.java.course;
2+
3+
import java.util.Arrays;
4+
import java.util.HashMap;
5+
6+
public class Map {
7+
private int keys[];
8+
private String values[];
9+
private int size;
10+
11+
public Map(final int size) {
12+
values = new String[size];
13+
keys = new int[size];
14+
this.size = 0;
15+
}
16+
17+
public void add(int key, String value) {
18+
for (int i = 0; i < keys.length; i++) {
19+
if (keys[i] == key) {
20+
values[i] = value;
21+
return;
22+
}
23+
}
24+
keys[size] = key;
25+
values[size] = value;
26+
size++;
27+
}
28+
29+
public String delete(int key) {
30+
for (int i = 0; i < keys.length; i++) {
31+
if (keys[i] == key) {
32+
keys[i] = keys[size - 1];
33+
values[i] = values[size - 1];
34+
size--;
35+
return values[i];
36+
}
37+
}
38+
throw new RuntimeException("Value does not exist!");
39+
}
40+
41+
public boolean isEmpty() {
42+
return size == 0;
43+
}
44+
45+
public String search(int key) {
46+
for (int i = 0; i < keys.length; i++) {
47+
if (keys[i] == key) {
48+
return values[i];
49+
}
50+
}
51+
return null;
52+
}
53+
54+
public boolean contains(int key) {
55+
for (final int mapKey : keys) {
56+
if (mapKey == key) {
57+
return true;
58+
}
59+
}
60+
return false;
61+
}
62+
63+
@Override
64+
public String toString() {
65+
return "Map{" +
66+
"keys=" + Arrays.toString(keys) +
67+
", values=" + Arrays.toString(values) +
68+
", size=" + size +
69+
'}';
70+
}
71+
}
72+
73+
class MapMain {
74+
public static void main(String[] args) {
75+
// Map map = new Map(10);
76+
// map.add(1123, "Java");
77+
// map.add(1124, "C++");
78+
// map.add(1125, "Python");
79+
// System.out.println(map);
80+
// map.delete(1124);
81+
// System.out.println(map);
82+
// map.add(1123, "C++");
83+
// System.out.println(map);
84+
// System.out.println(map.search(1123));
85+
// map.add(1125, null);
86+
// System.out.println(map.search(1125));
87+
// System.out.println(map.contains(1125));
88+
// System.out.println(map.contains(1124));
89+
// System.out.println(map.search(1124));
90+
java.util.Map<Integer, String> stringMap = new HashMap<>();
91+
stringMap.put(1123, "Java");
92+
stringMap.remove(1123);
93+
stringMap.get(1123);
94+
stringMap.containsKey(1123);
95+
}
96+
}

0 commit comments

Comments
 (0)