The array is a collection of the same type of elements at contiguous memory locations under the same name.
It is easier to access the element in the case of an array.
The size is the key issue in the case of an array which must be known in advance so as to store the elements in it.
Insertion and deletion operations are costly in the case of an array since the elements are stored at contiguous memory locations.
No modification is possible at the runtime after the array is created and memory wastage can also occur if the size of the array is greater than the number of elements stored in the array.
Array representation:
C++
#include <iostream>
using namespace std;
int main()
{
int arr[10]={1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < 10; i++)
{
cout << arr[i] << " ";
}
return 0;
}
Java
import java.io.*;
class GFG {
public static void main (String[] args) {
int arr[] = {1,2,3,4,5,6,7,8,9,10};
for (int i = 0; i < 10; i++){
System.out.print(arr[i]+" ");
}
}
}
Python
import array as arr
a = arr.array('i', [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
for i in range(0, 10):
print(a[i]),
C#
using System;
public class GFG {
static public void Main()
{
int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
for (int i = 0; i < arr.Length; i++) {
Console.Write(arr[i] + " ");
}
}
}
Javascript
<script>
let arr = [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ]
for(let i = 0; i < 10; i++){
document.write(arr[i] + " ");
}
</script>
Output
1 2 3 4 5 6 7 8 9 10
Time Complexity: O(1) Auxiliary Space: O(1)
A dictionary is a collection of data values.
It holds a key: value pair in which we can easily access a value if the key is known.
It improves the readability of your code and makes it easier to debug
It is fast as the access of a value through a key is a constant time operation
Dictionary representation:
C++
#include <iostream>
#include <unordered_map>
using namespace std;
int main()
{
unordered_map<string, int> my_dict;
my_dict["key1"] = 1;
my_dict["key2"] = 2;
my_dict["key3"] = 3;
for (auto key : my_dict)
cout << "Key: " << key.first << " Value: " << key.second << endl;
}
Java
import java.io.*;
import java.util.*;
class GFG {
public static void main (String[] args) {
HashMap<String,Integer> my_dict = new HashMap<>();
my_dict.put("key1", 1);
my_dict.put("key2", 2);
my_dict.put("key3", 3);
for(String key:my_dict.keySet()) {
System.out.println("Key: "+ key +", Value: " + my_dict.get(key));
}
}
}
Python
my_dict = {
"key1": 1,
"key2": 2,
"key3": 3
}
print(my_dict)
C#
using System;
using System.Collections.Generic;
public class GFG {
static public void Main()
{
IDictionary<string, int> my_dict= new Dictionary<string, int>();
my_dict.Add("key1", 1);
my_dict.Add("key2", 2);
my_dict.Add("key3", 3);
foreach(var kvp in my_dict) {
Console.WriteLine("Key: {0}, Value: {1}", kvp.Key, kvp.Value);
}
}
}
Javascript
<script>
var my_dict = new Map();
my_dict.set("key1", 1);
my_dict.set("key2", 2);
my_dict.set("key3", 3);
console.log(my_dict);
</script>
Output
{'key3': 3, 'key2': 2, 'key1': 1}
Time Complexity: O(1) Auxiliary Space: O(1)
Comparison Between Array and Dictionary:
#
Array Dictionary
1
Stores just a set of objects
Represents the relationship between pair of objects
2
Lookup time is more in the case of array O(N)
where N is the size of the array
Lookup time is less compared to an array.
Generally, it is O(1)
3
Elements are stored at contiguous memory locations.
Elements may or may not be stored at a contiguous memory location.
4
Items are unordered, changeable, and do allow duplicates
Items are ordered, changeable, and do not allow duplicates
5
Items are not represented as key: value pair
Items are represented as key: value pair
6
The values in the array are of the same data type
The values in dictionary items can be of any data type
7
Values can be accessed randomly without the need for any key
To access a value the key is required
