1. ARRAYS
Lecture 12

2. Add an element in the front: Shifting an array
/* Shift x[0],x[1], ... ,x[n-1] one position upwards (rightwards)to make space for a new element at x[0]
Insert the value newval at x[0], update size */
int x[MAX], size, i;
. . .
for (i=size; i>=1; i=i-1)
x[i] = x[i-1];
x[0] = newval;
size++;

3. Shifting Array Elements4 7 5 ?
size = 3;
newval = 0; 5 4 7 5 5 4 7 7 4 7 5 4 4 7 5

4. Delete the ith element of the array: shift left
/* Shift x[i+1], ... , x[n-1], one position to the left thus deleting item x[i] */
for (k=i; k<(size-1); k++)
x[k] = x[k+1];
size = size-1;
size = 6 1 2 3 4 5 6 1 2 4 4 5 6 1 2 4 5 5 6
size = 5 1 2 4 5 6 6

5. Array Initialization int marks[10] = {10,8,7,9,6,10,6,7,8,8}
marks has size 4, all values are initialized
char vowels[6] = {'a','e','i'}
vowels has size 6, only 3 values are initialized.
Can not use this notation in assignment statement.
Int w[10];
w = {1,2,3,4}; Syntax error
double x[] = {1.2,3.4,8.1,0.9} /* x has size 4, all values initialized */
double x[]; Illegal

6. Passing array elements to functions
Array element can be passed to functions as ordinary arguments.
IsFactor (x[i], x[0])
sin (x[5])

7. Passing Arrays to a Function
An array name can be used as an argument to a function.
Permits the entire array to be passed to the function.
The way it is passed differs from that for ordinary variables.
Rules:
The array name must appear by itself as argument, without brackets or subscripts.
The corresponding formal argument is written in the same manner.
Declared by writing the array name with a pair of empty brackets.

8. Whole array as Parameters
#define ASIZE 200
double average (int a[]) {
int i, total=0;
for (i=0; i<ASIZE; i++)
total = total + a[i];
return ((double) total / (double) ASIZE); }
fun (. . .) {
int x[ASIZE] ; double x_avg;
. . .
x_avg = average (x) ;

9. Arrays as Output Parameters
void VectorSum (int a[], int b[], int vsum[], int length) {
int i;
for (i=0; i<length; i=i+1)
vsum[i] = a[i] + b[i] ; }
int main (void) {
int x[3] = {1,2,3}, y[3] = {4,5,6}, z[3];
VectorSum (x, y, z, 3) ;
PrintVector (z, 3) ;
void PrintVector (int a[], int length) {
for (i=0; i<length; i++) printf (“%d “, a[i]);

10. The Actual Mechanism
When an array is passed to a function, the values of the array elements are not passed to the function.
The array name is interpreted as the address of the first array element.
The formal argument therefore becomes a pointer to the first array element.
When an array element is accessed inside the function, the address is calculated using the formula stated before.
Changes made inside the function are thus also reflected in the calling program.

11. Array operations } int readarray (int x[], int size) { int i;
for (i=0; i<size; i++)
scanf(“%d”, &x[i]) ;
return size; }
#define MAXS 100
int insert (int[], int, int, int) ;
int delete (int[], int, int) ;
int getelement (int[], int, int) ;
int readarray (int[], int) ;
main () {
int a[MAXS];
int size;
size = readarray (a, 10) ;
size = insert (a, size, 4, 7) ;
x = getelement (a, size, 3) ;
size = delete (a, size, 3) ; }
int getelement (int x[], int size, int pos){
if (pos <size) return x[pos] ;
return -1; }
int insert (int x[], int size, int pos. int val){
for (k=size; k>pos; k--)
x[k] = x[k-1] ;
x[pos] = val ;
return size+1; }

12. void reverse (int x[], int size) {
int i;
for (i=0; i< (size/2); i++)
temp = x[size-i-1] ;
x[size-1-1] = x[i] ;
x[i] = temp; }
int findmax (int x[], int size) {
int i, max;
max = x[0];
for (i=1; i< size; i++)
if (x[i] > max)
max = x[i] ;
return max; }

13. Strings Strings are 1-dimensional arrays of type char.
By convention, a string in C is terminated by the end-of-string sentinel \0, or null character.
String constant : “abc” is a character array of size 4, with the last element being the null chaaracter \0.
char s[] = “abc” ; a b c \0

14. Searching an Array: Linear and Binary Search

15. Searching Check if a given element (key) occurs in the array.
If the array is unsorted :
start at the beginning of the array
inspect every element to see if it matches the key

16. Linear Search
/* If key appears in a[0..size-1], return its location, pos, s.t. a[pos] == key. If key is not found, return -1 */
int search (int a[], int size, int key) {
int pos = 0;
while (pos < size && a[pos] != key)
pos++;
if (pos<n)
return pos;
return -1; }

17. Linear Search int x= {12,-3, 78,67,6,50,19,10} ;
Trace the following calls :
search (x, 8,6) ;
search (x,8,5) ;

18. Searching a sorted array
Binary search works if the array is sorted
Look for the target in the middle
If you don’t find it, you can ignore half of the array, and repeat the process with the other half.

19. Binary Search Strategy
What we want : Find split betwen values larger and smaller than x : L R x:
<=key
>key n
Situation while searching : L R n x:
<=key ?
>key
Step : Look at [(L+R)/2]. Move L or R to the middle depending on test.

20. Binary Search
/* If key appears in x[0..size-1], return its location, pos s.t. x[pos]==key. If not found, return -1 */
int binsearch (int x[], int size, int key) {
int L, R, mid;
______________________;
while (_________________) { }
____________________ ;

21. Binary Search mid = (L+R)/2; if (x[mid] <= key) L = mid;
/* If key appears in x[0..size-1], return its location, pos s.t. x[pos]==key. If not found, return -1 */
int binsearch (int x[], int size, int key) {
int L, R, mid;
______________________;
while (_________________) {
mid = (L+R)/2;
if (x[mid] <= key)
L = mid;
else R = mid; }
____________________ ;
mid = (L+R)/2;
if (x[mid] <= key)
L = mid;
else R = mid;

22. Binary Search: loop termination
/* If key appears in x[0..size-1], return its location, pos s.t. x[pos]==key. If not found, return -1 */
int binsearch (int x[], int size, int key) {
int L, R, mid;
______________________;
while (_________________) {
mid = (L+R)/2;
if (x[mid] <= key)
L = mid;
else R = mid; }
____________________ ;
L+1 != R

23. Binary Search: Return result
/* If key appears in x[0..size-1], return its location, pos s.t. x[pos]==key. If not found, return -1 */
int binsearch (int x[], int size, int key) {
int L, R, mid;
______________________;
while ( L+1 != R) {
mid = (L+R)/2;
if (x[mid] <= key)
L = mid;
else R = mid; }
if (L>=0 && x[L]==key) return L;
else return -1;

24. Binary Search: Initialization
/* If key appears in x[0..size-1], return its location, pos s.t. x[pos]==key. If not found, return -1 */
int binsearch (int x[], int size, int key) {
int L, R, mid;
______________________;
while ( L+1 != R) {
mid = (L+R)/2;
if (x[mid] <= key)
L = mid;
else R = mid; }
if (L>=0 && x[L]==key) return L;
else return -1;
L=-1; R=size;

25. Binary Search Examples
Trace :
binsearch (x, 9, 3);
binsearch (x, 9, 145);
binsearch (x, 9, 45);

26. Is it worth the trouble ? Suppose you had 1000 elements
Ordinary search (if key is a member of x) would require 500 comparisons on average.
Binary search
after 1st compare, left with 500 elements
after 2nd compare, left with 250 elements
After at most 10 steps, you are done.
What if you had 1 million elements ?

27. Sorting Given an array x[0], x[1], ... , x[size-1]
reorder entries so that
x[0]<=x[1]<= <=x[size-1]

28. Sorting Problem What we want : Data sorted in order size x:
sorted : x[0]<=x[1]<= <=x[size-1]
size x:
Initial conditions :
size x:
unsorted

29. Selection Sort General situation : k size x: Step :k
size x:
smallest elements, sorted
remainder, unsorted
Step :
Find smallest element, mval, in x[k..size-1]
Swap smallest element with x[k], then increase k. k
mval
size x:
smallest elements, sorted

30. Subproblem : :
/* Yield location of smallest element int[x] in x[0 .. size-1];*/
int min_loc (int x[], int , int size)
int j, pos; /* x[pos] is the smallest element found so far */
pos = k;
for (j=k+1; j<size; j++)
if (x[i] < x[pos])
pos = j;
return pos; }

31. Selection Sort /* Sort x[0..size-1] in non-decreasing order */
int selsort (int x[], int size) {
int k, m;
for (k=0; k<size-1; k++) {
m = min_loc(x, k, size);
temp = a[k];
a[k] = a[m];
a[m] = temp; }

32. Example x: 3 12 -5 6
142 21
-17 45 x:
-17 -5 3 6 12 21
142 45 x:
-17 12 -5 6
142 21 3 45 x:
-17 -5 3 6 12 21 45
142 x:
-17 -5 12 6
142 21 3 45 x:
-17 -5 3 6
142 21 12 45 x:
-17 -5 3 6 12 21
142 45

33. Analysis How many steps are needed to sort n things ?
Total number of steps proportional to n2

34. Insertion Sort #define MAXN 100
void InsertSort (int list[MAXN], int size) ;
main () {
int index, size;
int numbers[MAXN];
/* Get Input */
size = readarray (numbers) ;
printarray (numbers, size) ;
InsertSort (numbers, size) ; }

35. void InsertSort (int list[], int size) {
for (i=1; i<size; i++)
item = list[i] ;
for (j=i-1; (j>=0)&& (list[j] > i); j--)
list[j+1] = list[j];
list[j+1] = item ; }

36. Common pitfalls with arrays in C
Exceeding the array bounds
int array[10]; for (i=0; i<=10; i++) array[i] = 0;
C does not support array declaratiions with variable expressions.
void fun (int array, int size) { int temp[size] ; }