arrays
Download
Skip this Video
Download Presentation
ARRAYS

Loading in 2 Seconds...

play fullscreen
1 / 35

ARRAYS - PowerPoint PPT Presentation


  • 103 Views
  • Uploaded on

ARRAYS. Lecture 15 12.2.2002. Arrays as parameters of functions. An array passed as a parameter is not copied. An array name is a constant whose value serves as a reference to the first (index 0) item in the array. Arrays as parameters of functions.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'ARRAYS' - maia


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
arrays

ARRAYS

Lecture 15

12.2.2002.

arrays as parameters of functions
Arrays as parameters of functions
  • An array passed as a parameter is not copied.
  • An array name is a constant whose value serves as a reference to the first (index 0) item in the array.
arrays as parameters of functions1
Arrays as parameters of functions
  • Since constants cannot be changed, assignments to array variables are illegal.
  • Only the array name is passed as the value of a parameter, but the name can be used to change the array’s contents.
  • Empty brackets [] are used to indicate that the parameter is an array. The no of elements allocated for the storage associated with the array parameter does not need to be part of the array parameter.
slide4
#define MAXS 10

int main () {

int numbers[MAXS];

int k, size = 10;

for (k=0; k

numbers[k] = k+1;

}

printf (“Before : \n”) ;

printarray (numbers, size) ;

change (numbers, size) ;

printf (“After : \n”) ;

printarray (numbers, size) ;

}

slide5
void change (int list[], int num) {

int k;

for (k=1; k

list[k] += list[k-1] ;

}

}

void printarray (int list[], int num) {

int k;

for (k=0; k

printf (“%d “, list[k]) ;

}

printf (“\n”) ;

}

slide6
Output

Before:

1 2 3 4 5 6 7 8 9 10

After:

1 3 6 10 15 21 28 36 45 55

array operations
Array operations

#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) ;

}

array operations1
Array operations

int readarray (int x[], int size) {

int i;

for (i=0; i

scanf(“%d”, &x[i]) ;

return size;

}

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;

}

int getelement (int x[], int size, int pos){

if (pos

return -1;

}

slide10
void reverse (int x[],

int size) {

}

int findmax (int x[], int size) {

}

slide11
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;

}

strings
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

searching
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
linear search
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

return pos;

return -1;

}

linear search1
Linear Search

int x= {12,-3, 78,67,6,50,19,10} ;

Trace the following calls :

search (x, 8,6) ;

search (x,8,5) ;

searching a sorted array
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.
binary search strategy
Binary Search Strategy
  • What we want : Find split betwen values larger and smaller than x :

0

L

R

x:

n

<=key

>key

  • Situation while searching :

0

L

R

n

x:

<=key

?

>key

  • Step : Look at [(L+R)/2]. Move L or R to the middle depending on test.
binary search
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 (_________________) {

}

____________________ ;

}

binary search1
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 (_________________) {

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;

binary search loop termination
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

binary search return result
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;

binary search initialization
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;

binary search examples
Binary Search Examples

-17 -5 3 6 12 21 45 63 50

Trace :

binsearch (x, 9, 3);

binsearch (x, 9, 145);

binsearch (x, 9, 45);

is it worth the trouble
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 ?
sorting
Sorting
  • Given an array x[0], x[1], ... , x[size-1]
    • reorder entries so that

x[0]<=x[1]<= . . . <=x[size-1]

sorting problem
Sorting Problem
  • What we want : Data sorted in order

sorted : x[0]<=x[1]<= . . . <=x[size-1]

size

0

x:

  • Initial conditions :

size

0

unsorted

x:

selection sort
Selection Sort
  • General situation :

k

0

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.

mval

0

k

size

x:

smallest elements, sorted

subproblem
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

if (x[i] < x[pos])

pos = j;

return pos;

}

selection sort1
Selection Sort

/* Sort x[0..size-1] in non-decreasing order */

int selsort (int x[], int size) {

int k, m;

for (k=0; k

m = min_loc(x, k, size);

temp = a[k];

a[k] = a[m];

a[m] = temp;

}

}

example
Example

x:

x:

3

12

-5

6

142

21

-17

45

-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

analysis
Analysis
  • How many steps are needed to sort n things ?
    • Total number of steps proportional to n2
insertion sort
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) ;

printarray (numbers, size) ;

}

slide34
void InsertSort (int list[], int size) {

for (i=1; i

item = list[i] ;

for (j=i-1; (j>=0)&& (list[j] > i); j--)

list[j+1] = list[j];

list[j+1] = item ;

}

}

common pitfalls with arrays in c
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] ; . . .}
ad