## Basic Algorithms

In all the algorithms that we will illustrate in pseudocode we will be using an array or list of integers. Integers are easy to work with and understand and there is no loss of generality in our algorithms.

An array is a contiguous space in memory to store values. An array is an ordered sequence of values. The order is indicated by the position or index. The first position or index starts at 0. The next index 1 and so on. The last index is the size of the array - 1. Here is an example of an array of 10 unsorted integers.
 Index 0 1 2 3 4 5 6 7 8 9 Value 20 13 24 53 46 15 36 72 8 29
Here the length of the array is 10 but the last index is 9. To refer to any given element by position we use square brackets. For example, if we called the array a, the third element in a is a. In all our examples, to follow we will be using an array of integers called a that has been prepopulated. Assume also that we can get the size or length of the array.

### Traversing an Array

Our basic operation starts with visiting each element of the array exactly once and in order. We can write that in pseudocode in two ways:

```FOR i = 0 to array length - 1

FOR each element in the array
```
In the first example we are going by position starting at the first position 0 and going to the last position. In the second example we are going element by element.

### Summing the Array

In any summing problem, we need a place or variable to store the sum. We have to initialize this variable to zero to start with and then traverse the array adding each element to the sum. Here is the pseudocode:

```SET Sum to 0
FOR each element in the array
ENDFOR
PRINT Sum
```
Here is another version of the same code:
```INITIALIZE Sum to 0
FOR i = 0 to array length - 1
ENDFOR
WRITE Sum
```

### Find Maximum Value in the Array

To find the maximum value, you initialize a placeholder called max with the value of the first element in the array. Then you go through the array element by element. If any element is greater than max you replace max with that element. Here is the pseudocode:

```SET Max to array
FOR i = 1 to array length - 1
IF array[i] > Max THEN
SET Max to array[i]
ENDIF
ENDFOR
PRINT Max
```

### Sequential Search for an Element in the Array

Let the element that we are searching for be X. We need to know if that element occurs in the array. One way is to return the position of the first occurrence of that element and if that element does not exist return -1 which is an invalid index. This is the pseudocode:

```FOR i = 0 to array length - 1
IF X = array[i] THEN
RETURN i
ENDIF
ENDFOR
RETURN -1
```
Another variation of this problem is to return the number of occurrences of X in the array. Here is a modification of the above code:
```SET Count to 0
FOR i = 0 to array length - 1
IF X = array[i] THEN
INCREMENT Count
ENDIF
ENDFOR
RETURN Count
```

### Binary Search for an Element in a Sorted Array

For binary search to work, let us assume that the array is already sorted in ascending order. We will return the position of the element X if we find it, otherwise we will return -1.

```SET Lo to 0
SET Hi to array length - 1
WHILE Lo <= Hi
SET Mid to (Lo + Hi) / 2
IF X < array[Mid] THEN
SET Hi to Mid - 1
ELSE IF X > array[Mid] THEN
SET Lo to Mid + 1
ELSE
RETURN Mid
ENDIF
ENDWHILE
RETURN -1
```
Binary Search is one of the the most efficient algorithms that we have. It is efficient because in each iteration we are halving the search space.

### Selection Sort

This is one of the easiest sorting algorithms to understand and write but not the most efficient one. In Selection Sort we start at the first element of the array and go through the array and find the minimum element. We swap the minimum element with the element at the first place. We start at the second position in the array and go through the array and find the minimum element in the remaining portion of the array. We swap that minimum element with the element with the element at the second position. We start at the third position and repeat the procedure until we reach the end of the array.

```FOR i = 0 to array length - 2
SET Min to array[i]
SET MinIndex to i
FOR j = i + 1 to array length - 1
IF array[j] < Min THEN
Min = array[j]
MinIndex = j
ENDIF
ENDFOR
SET array[MinIndex] to array[i]
SET array[i] to Min
ENDFOR
```
Selection Sort is not efficient. It does the same amount searches if the values in the array are in random order, partially sorted or completely sorted.

### Merge Two Sorted Arrays

To merge two sorted arrays a and b we first create a third array c that has the same size as array a and b combined. We compare the first element in a with the first element in b. We insert the smaller of the two elements into array c. We then advance by one position in the array a or b that we took the element from. We keep going until we deplete all the elements in either array a or b. Then we add all the elements in the remaining array to c. Here is the pseudocode:

```CREATE array c having size = array length a + aray length b
SET aIdx to 0
SET bIdx to 0
SET cIdx to 0
WHILE aIdx < length of a - 1 and bIdx < length of b - 1
IF a [aIdx] < b [bIdx] THEN
SET c[cIdx] to a[aIdx]
INCREMENT aIdx
INCREMENT cIdx
ELSE
SET c[cIdx] to b[bIdx]
INCREMENT bIdx
INCREMENT cIdx
ENDIF
ENDWHILE

WHILE aIdx < length of a - 1
SET c[cIdx] to a[aIdx]
INCREMENT aIdx
INCREMENT cIdx
ENDWHILE

WHILE bIdx < length of b - 1
SET c[cIdx] to b[bIdx]
INCREMENT bIdx
INCREMENT cIdx
ENDWHILE

RETURN c
```