# Array Data Structure

One of the most fundamental data structures is an array. It is one of the most widely utilised and serves as a foundation for the creation of more complex data structures. An array is a collection of elements of a specific kind that has a predetermined size. When we look at data structures, we want to see how efficient they are at doing some of the most typical tasks. For example, accessing an element, searching for an element, inserting an element, and removing an element are all possible actions.

Array is the first linear data structure we'll discuss. Enough with the introduction, let's get right to the point about why you've come.

## Array Data Structure

### ⌚ In programming, what is an array?

A collection of similar data kinds stored in contiguous memory spaces is referred to as an array. When declaring an array, the type of data must be specified together with the array name. The index of different elements in an array can be used to access them. For example, in an array arr, you can access an element nice at the 1st index(1st element) by writing arr[0].

### ⌚ Explain memory allocation in arrays?

When we create an array in a programming language, the language allocates memory space for the array and then refers the starting variable to that memory address. After that, it allocates a set amount of RAM to each element. Assume that the array begins at memory address 100. Let's imagine the programming language allots 8 bits to each element in the array and adequate memory to store ten elements evenly spaced.

Array items can be sorted in multiple ways at the same time.
We can access any element in O(1) time by using the index.
You must indicate how many elements you want to store in your array ahead of time, and we cannot change the size of the Array once it has been created.
To fill in or close gaps, you must rearrange the other pieces, which requires worst-case O(n) time.

### ⌚ What do you mean by dynamic arrays?

A dynamic array is a type of array that has a significant enhancement: automatic resizing. One disadvantage of arrays is that they have a fixed size, which means you must determine the number of elements your array will hold in advance. As you add more elements to a dynamic array, it expands. As a result, there's no need to estimate the size ahead of time.

A simple dynamic array can be created by creating a fixed-size array that is often greater than the amount of elements required immediately. The items of the dynamic array are stored consecutively at the beginning of the underlying array, with the remaining positions towards the end reserved or unused. In constant time, elements can be added to the end of a dynamic array by utilising the reserved space until it is completely utilised.
When all of the space is used up and another element is needed, the underlying fixed-sized array must be expanded. Resizing is typically expensive since it requires allocating a larger array and copying all of the elements from the overflowing array before we can finally append our item.
Memory allocation for dynamic arrays is language dependent. In C++, for example, arrays are formed on the stack and have an automated storage duration — you don't have to manage memory manually, but they are destroyed when the function in which they are used ends. They must all be the same size:

### ⌚ Explain differences between Array and ArrayList?

ArrayArrayList
Once delared, the array is static and has a fixed size that cannot be modified.The size of an ArrayList is not static, but rather dynamic. The capacity or size of an ArrayList expands automatically as more elements are added.
It includes both primitive data types and class objects.The primitive data types are not present in ArrayList, but object entries are.
It has not generic feature.It has generic feature.

### ⌚ We now know that Arrays are objects, so why can't we use strArray.length() instead?

Arrays, like classes in Java, are object references. Array can be worked with using Object methods like function toString() or hashCode (). Length is not a function because it is a data item in an array. This is why strArray.length is used.

### ⌚What exactly is the distinction between an Array and an Object?

An array creates a collection of data and keeps it in a single variable, whereas an object represents an entity with characteristics (called a property). We can access, alter, and delete items from objects using brackets and dots, whereas we can access and modify items in arrays using a range of built-in methods and zero-based indexing. Various loops (e.g. for, for...in, for...of, forEach()) can traverse across object properties and array entries.

On the heap, all Java objects are dynamically allocated. Unlike C++, where objects can be allocated to Heap or Stack in memory. When we call the new() method in C++, the object is allocated on the heap, unless it is global or static, in which case it is allocated on Stack.

### ⌚ How do you find the missing number in an integer array of numbers ranging from 1 to 100?

The most basic variant of this problem is to locate missing pieces in a 100-integer area with numbers ranging from 1 to 100.

This can be readily solved by using n(n+1)/2 to calculate the sum of the series, which is also one of the quickest and most efficient methods, but it cannot be used if the array contains more than one missing integer or duplicates.

### ⌚ When are we going to see an ArrayIndexOutOfBoundsException?

ArrayIndexOutOfBounds is a runtime exception that happens when a programme tries to access an array with an invalid index, such as one that is greater than the array's size or a negative index.

### ⌚ Is it possible to use the sizeof operator to determine the size of an array provided to a function?

When you send an array as a parameter in C or C++, you don't get any information about how many elements are in it. Despite the fact that sizeof() can tell you the size of the pointer and the type it points to, it can't tell you how many bytes the entire array takes up.

### ⌚ Explain the difference between Array and Linked List?

Size: Because data may only be stored in continuous blocks of memory in an array, its size cannot be changed at runtime. However, because a linked list's node structure allows each node to point to the next, its size can be readily changed, allowing data to exist at several (non-contiguous) addresses.
Memory allocation: Memory is allocated at build time for arrays, but memory is allocated at runtime for linked lists. A dynamically allocated array, on the other hand, allocates memory during runtime as well.
Memory efficiency: Because each node maintains a reference to the next node along with the data, the linked list consumes more memory for the same number of elements. When there is uncertainty about size or big changes in the size of data pieces, however, linked lists may utilise less memory overall than arrays.
Time to execute: To reach any element in a linked list, all preceding elements must be traversed, whereas elements in an array can be accessed simply using their index. As a result, some actions, like changing an element, are faster in arrays, while others, like inserting an element, are faster in linked lists.

### ⌚What is the best way to acquire the index of an array element?

A linear or binary search can be used to determine an element's index. A linear search is a function that loops through all of the elements of an array until it finds the required element's match. It returns the index when it detects the matched element. As a result, the linear search's time complexity is O. (n). Linear search can be used on both sorted and unsorted arrays.

If the array is sorted, you can perform a binary search, which divides the array in half periodically until the median of the interval matches the requested element and returns the index. As a result, the binary search's time complexity is O. (log n).

### ⌚ How do I check if two arrays are equal. You will be given two arrays and will need to determine whether they are equal?

To begin, you must compare the lengths of two supplied arrays. We compare corresponding members of both arrays when their lengths are the same. Both arrays will be treated equally. If all corresponding element pairs are the same. This method will take a long time if the arrays are large, hence it is not recommended for checking the equality of two arrays. You can also use the Arrays class's equals() method, however the interviewer may ask you to compare two arrays without utilising in-built functions, in which case this method will come in handy.

### ⌚ How can we remove a particular element from an array?

Because you can't directly remove elements from the original array because arrays are fixed sets with no way to adjust their size, the interviewer is asking for you to come up with a different solution to the problem. Creating a new array is the best technique to remove an element. You might include copies of the original array's elements in this array while excluding only the element you want to remove.
Another method is to look for the target element in the array and then return all the items on the right side of the target element to their original location.

### ⌚ How can I reorganise an array so that the positive and negative numbers alternate?

The goal is to process the array in O(n) time and move all negative values to the end. We can easily reorder the array in alternating positive and negative elements after all negative values have been relocated to the end. In this stage, we effectively replace the next positive element at even position with the following negative element.

```def partition(A):

j = 0
pivot = 0       # consider 0 as a pivot

# 'j' is increased each time we find a negative number, and ,
#  a negative element is added before the pivot.
for i in range(len(A)):
if A[i] < pivot:
# swap `A[i]` with `A[j]`
temp = A[i]
A[i] = A[j]
A[j] = temp

j = j + 1

# `j` have the elements of the first positive element
return j

# Rearranges a list so that it contains only positive items.
# and negative numbers at alternate positions
def rearrange(A):

# divide a list so that all positive elements are moved to the top
# to the end of the list

p = partition(A)

# switch alternate negative elements from the next positive element
# element until the list reaches the end or all negative
# or positive elements have been exhausted..

n = 0
while len(A) > p > n:
# swap `A[n]` with `A[p]`
temp = A[n]
A[n] = A[p]
A[p] = temp

p = p + 1
n = n + 2

if __name__ == '__main__':

A = [-1,2,-2,6,-9]

rearrange(A)
print(A)
```

### ⌚ How do you find the smallest and greatest numbers in an array?

Create two variables named smallest and largest to store the largest and smallest values.
MAX VALUE to the smallest variable
Assign the variable largest the value Integer.MIN VALUE.
We will compare the current element with the greatest and smallest integer in each iteration of the for loop and change the value accordingly.
If a number is higher than the largest, it cannot be smaller than the smallest; so, if the first condition is met, we can go to the next step.

```import java.util.*;
public class LogicMojo{
public static void main(String args[]) {

int[] inputArray = {10,20, 22, 30, 77};
int largest = inputArray[0];
int smallest = inputArray[0];

for( int number : inputArray ) {
if(number > largest) {
largest = number;
}
else if (smallest > number) {
smallest = number;
}
}
System.out.println("Largest and Smallest numbers are "
+ largest +" "+smallest);
}
}
```

### ⌚ Two sums of an array: You will be given an array arr and a target in this question. You must return the two numbers' indices in such a way that they sum up to goal.

As a result, utilising a HashMap is the simplest and most efficient method. We must loop through all of the array's elements and return lower index, higher index if (target-num) is present, otherwise push the value to arr[i] and the index I in the hashmap.

```public class LogicMojo {
public int[] twoSum(int[] arr, int target) {

HashMap<Integer,Integer> hash = new HashMap<Integer,Integer>();
for(int i = 0; i <arr.length; i++){

Integer diff = (Integer)(target - arr[i]);
if(hash.containsKey(diff)){
int toReturn[] = {hash.get(diff)+1, i+1};
}

hash.put(arr[i], i);

}

return null;

}
}
```

### ⌚ When will ArrayStoreException be available?

The ArrayStoreException exception is a runtime error.
If you define a String Array and then try to put integer elements into the array, you will get this exception at runtime.

### ⌚ How long does it take to do fundamental operations in an array?

The time complexity of various array operations is: You must also consider the time it takes to transport a block of memory from an external device to RAM, which requires O(√N) time, when analysing real-time complexity.

Array OperationTime Complexity
Accessing the i-th element.O(1)
Traversing all elements.O(N)
At the i-th index, override the element.O(1)
Remove a element.O(N)

### ⌚ How do you reverse an array?

Interviewers may inquire about how you reverse an array. This quiz tests your basic knowledge of arrays and your ability to manipulate them in your code. Reversing an array can be done in a variety of ways. By establishing a reverse function and inserting a new array with the same parameters and data as the original, you may create a temporary array. Swapping the components within the original array is another option. You can do this by replacing 1 with n, 2 with n -1, and so on until you've reached the end of the array. You may also use a collections reverse list method to convert the array to a list.

### ⌚ In Java, what's the difference between length and length ()?

In Java, length() is a String class function, whereas length is an array instance variable.

length in java:
The length variable returns the array's length, or the number of elements in the array.
Because the length of an array cannot be modified once it has been initialised, the length variable can be used to determine the array's length directly. It is solely used to create an array.

Example:

```public class LogicMojo {
public static void main(String args[]) {
int array[] = {1, 2, 3, 4, 5};
System.out.println("Length of an array is: " + array.length);
}
}
```

length() in java:
It's a String class static method.
A string object's length() function returns the number of characters stored in it.
This function is used by the string class because the length of a string can be changed by performing various actions on a string object.
Internally, the String class employs a char[] array.

Example:

```public class logicmojo {
public static void main(String args[]) {
String str = "Welcome to logicmojo";
System.out.println("Length of String using length() method is: " + str.length());
}
}
```

### ⌚ In Java, what is a Jagged Array?

Multidimensional arrays with member arrays of varying widths are known as jagged arrays. We can build a 2D array with three elements in the first array and four elements in the second array, for example. The concept of jagged arrays is demonstrated in the example below.

### 🚀Conclusion

This page has reached the end of its content. You should be able to construct your own programmes with the material on this page and some practise, and little projects are highly encouraged for improving your programming skills. You won't be able to learn everything you need to know about programming in a single course it's like a marathon.

int (*ptr) [10];

### HAVE A QUESTION? GIVE US A CALL OR CONTACT US - WE'D LOVE TO HEAR FROM YOU

PHONE: +91 80889-75867