Java Syntax - Common Data Structures

Question 1

Array definition

Answer 1

An array is a container object that holds a fixed number of values of a single type. The length of an array is established when the array is created. After creation, its length is fixed.

Question 2

Initialize a one dimensional array that can hold 10 integers

Answer 2

int[] myArr = new int[10];

Question 3

Initialize a two dimensional array of integers with 10 rows and 20 columns

Answer 3

int[][] myArr = new int[10][20];

Question 4

Initialize an array containing the integers 1, 2, and 3

Answer 4

int[] myArr = new int[]{1, 2, 3};

or

int[] myArr = {1, 2, 3};

Question 5

Initialize a two dimensional array with 3 rows and 3 columns:

1, 2, 3
4, 5, 6
7, 8, 9

Answer 5

int[][]myArr={{1,2,3},{4,5,6},{7,8,9}}

Question 6

Iterate through an array

Answer 6

for (int i = 0; i < array.length; i++) {
System.out.print(array[i]);
}

for (int i : array) {
System.out.print(array[i]);
}

Question 7

String creation

Answer 7

String s = new String(“hello”);

String s = “hello”;

Question 8

String size

Answer 8

s.length()

Question 9

Accessing and iterating through characters in a String, s.

Answer 9

char[] charArray = s.toCharArray();
for (int i = 0; i < charArray.length; i++) {
System.out.print(charArray[i]);
}

for (int i = 0; i < s.length(); i++) {
System.out.print(s.charAt(i));
}

Question 10

HashMap definition

Answer 10

A HashMap is a data structure that maps keys to values. A map cannot contain duplicate keys and each key can map to at most one value.

Question 11

HashMap

1. Create a new HashMap mapping String to String
2. Add an element
3. Update element
4. Remove element
5. Size
6. Iterate through entry set
7. Iterate through key set
8. Iterate through values

Answer 11

1. Create a new HashMap:

HashMap map = new HashMap<>();

2. Add an element:
   map. put(“key”, “value”);
3. Update element:
   map. put(“key”, map.getOrDefault(“key”, “updatedValue”);
4. Remove element:
   map. remove(“key”);
5. Size
   map. size();
6. Iterate through entry set

for (Map.Entry entry : map.entrySet()) { System.out.println(entry.getKey() + “ “ +
entry.getValue());
}

7. Iterate through key set

for (String key : map.keySet()) {
System.out.println(key);
}

8. Iterate through values

for (String value : map.values()) {
System.out.println(value);
}

Question 12

HashMap Time Complexity

1. Access
2. Search
3. Insert
4. Remove

Answer 12

1. Access: O(1)
2. Search: O(n)
3. Insert: O(1)
4. Remove: O(1)

Question 13

HashSet definition

Answer 13

A HashSet is a collection that uses a Hash table for storage, only allowing unique elements to be added.

Question 14

HashSet

1. Create a new HashSet of String
2. Add an element
3. Remove element
4. Search element
5. Size
6. Iterate through set

Answer 14

1. Create a new HashSet of String:

HashSet set = new HashSet<>();

2. Add an element:
   set. add(“hello”);
3. Remove element:
   set. remove(“hello”);
4. Search element:
   set. contains(“hello”);
5. Size:
   set. size();
6. Iterate through set:

for(String s : set) {
System.out.println(s);
}

Question 15

HashSet Time Complexity

1. Access
2. Search
3. Insert
4. Remove

Answer 15

1. Access: O(1)
2. Search: O(1)
3. Insert: O(1)
4. Remove: O(1)

Question 16

ArrayList definition

Answer 16

An ArrayList is a collection of data elements sequentially ordered from 0 to length - 1. This means that we are able to access an element inside an ArrayList by its position (index).

Question 17

ArrayList

1. Create ArrayList of Integer
2. Add element
3. Update element
4. Remove element
5. Size
6. Accessing
7. Sorting

Answer 17

1. Create ArrayList of Integer

ArrayList list = new ArrayList<>();
List list = new ArrayList<>();

2. Add element
   list. add(1);
3. Update element
   list. set(0, 100); // Update index 0’s value to 100
4. Remove element

list. remove(0); // Remove index 0
list. clear(); // Remove all elements

5. Size
   list. size();
6. Accessing

for (int i = 0; i < list.size(); i++) {
System.out.println(list.get(i));
}

for (String s : list) {
System.out.println(s);
}

7. Sorting

Collections.sort(list); // Sort ascending
Collections.sort(list, Collections.reverseOrder()); // Sort descending

Question 18

ArrayList Time Complexity

1. Access
2. Search
3. Insert
4. Remove

Answer 18

1. Access: O(1)
2. Search: O(n)
3. Insert: O(1) (at the back of the ArrayList)
4. Remove: O(n)
   O(1) (removing from the back of the list)

Question 19

Heap definition

Answer 19

A heap is a specialized tree based structure data structure that satisfies the ​heap property​: if A is a parent node of B, then the key (the value) of node A is ordered with respect to the key of node B with the same ordering applying across the entire heap.

A heap can be classified further as either a “max heap” or a “min heap”. In a max heap, the keys of parent nodes are always greater than or equal to those of the children and the highest key is in the root node. In a min heap, the keys of parent nodes are less than or equal to those of the children and the lowest key is in the root node.

Question 20

Heap

1. Create a min heap of Integer
2. Create a max heap of Integer
3. Add element
4. View top element
5. Remove top element
6. Size

Answer 20

1. Create a min heap of Integer

PriorityQueue pq = new PriorityQueue<>(); // Min heap by default

2. Create a max heap of Integer

PriorityQueue pq = new PriorityQueue<>(Collections.reverseOrder);

3. Add element
   pq. add(10);
4. View top element
   pq. peek();
5. Remove top element
   pq. poll();
6. Size
   pq. size();

Question 21

Heap Time Complexity

1. Access min or max
2. Insert
3. Remove min or max

Answer 21

1. Access min or max: O(1)
2. Insert: O(log(n))
3. Remove min or max: O(log(n))

Question 22

Queue definition

Answer 22

A Queue is a collection of elements, supporting two principle operations: ​enqueue,​ which inserts an element into the queue, and ​dequeue​, which removes an element from the queue.

Question 23

Queue

1. Create a new Queue of Integer
2. Add element
3. View top element
4. Remove element
5. Size
6. Empty check

Answer 23

1. Create a new Queue of Integer

Queue q = new LinkedList<>(); // Specify as a LinkedList!

2. Add element
   q. add(10);
3. View top element
   q. peek(); // Returns head or null if empty
4. Remove element
   q. poll(); // Returns head or null if empty
5. Size
   q. size();
6. Empty check
   q. isEmpty();

Question 24

Queue Time Complexity

1. Access
2. Search
3. Insert
4. Remove

Answer 24

1. Access: O(n)
2. Search: O(n)
3. Insert: O(1)
4. Remove: O(1)

Question 25

Stack definition

Answer 25

A Stack is a collection of elements, with two principle operations: ​push,​ which adds to the collection, and pop,​ which removes the most recently added element.

Question 26

Stack 1. Create a Stack of Integers 2. Add an element 3. View top element 4. Remove element 5. Size

Answer 26

1. Create a Stack of Integers Stack stack = new Stack<>(); 2. Add an element stack. push(10); 3. View top element stack. peek(); // Returns but does not remove the top element 4. Remove element stack. pop(); // Returns an removes the top element 5. Size stack. size(); 6. Empty check stack. isEmpty();

Question 27

Stack Time Complexity 1. Access 2. Search 3. Insert 4. Remove

Answer 27

1. Access: O(n) 2. Search: O(n) 3. Insert: O(1) 4. Remove: O(1)

Question 28

Linked List definition

Answer 28

A Linked List is a linear collection of data elements, called nodes, each pointing to the next node by means of a pointer. It is a data structure consisting of a group of nodes which together represent a sequence. The Java LinkedList collection is a doubly linked list.

Question 29

Linked List 1. Create a linked list of Integers 2. Add element 3. Update element 4. Remove element 5. Size 6. Accessing

Answer 29

1. Create a linked list of Integers LinkedList list = new LinkedList<>(); 2. Add element list. add(1); 3. Update element list. set(0, 100); // Update index 0’s value to 100 4. Remove element list. remove(0); // Remove index 0 list. clear(); // Remove all elements 5. Size list. size(); 6. Accessing for(int i = 0; i < list.size(); i++) { System.out.println(list.get(i)); } for(int i : list) { System.out.println(i); }

Question 30

Linked List Time Complexity 1. Access 2. Search 3. Insert 4. Remove

Answer 30

1. Access: O(n) 2. Search: O(n) 3. Insert: O(1) // At the head or tail 4. Remove: O(1) // At the head or tail