Cps 125 digital computation and programming
This presentation is the property of its rightful owner.
Sponsored Links
1 / 49

CPS 125: Digital Computation and Programming PowerPoint PPT Presentation


  • 68 Views
  • Uploaded on
  • Presentation posted in: General

CPS 125: Digital Computation and Programming. Arrays. Outline. Declaring and Referencing Arrays Array Subscripts Using for Loops for Sequential Access Using Array Elements as Function Arguments Array Arguments Using Character Arrays as Strings Dynamic Allocation of Arrays.

Download Presentation

CPS 125: Digital Computation and Programming

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


Cps 125 digital computation and programming

CPS 125: Digital Computation and Programming

Arrays


Outline

Outline

  • Declaring and Referencing Arrays

  • Array Subscripts

  • Using for Loops for Sequential Access

  • Using Array Elements as Function Arguments

  • Array Arguments

  • Using Character Arrays as Strings

  • Dynamic Allocation of Arrays


Array declare

Array - Declare

  • What is an array: aggregate of data items of same type

  • Why are array needed: keep a number of values (e.g. grades of students in an exam) in memory

  • Declaring an array

    int y[6]; /* declares an array of size 6 */

    Note: array index (subscript) always starts from 0

0

1

2

3

4

5


Array reference

Array - Reference

  • Array elements are individual data items

    • Each has the same type, size, and name (differentiated by an index or subscript)

    • Elements are stored in contiguous memory spaces

  • Referencing array elements

    • By index (subscript)

    • Begins with zero, ends with 1 less than number of elements


Array example

12 11 18 20 15 24

Array - Example

y[2]

y[5]

y[0]

in this case, y[0] is an int; so are y[2] and y[5]

int y[6];

the number of elements allocated; NOT an index!


Array name

Array Name

  • Array name represents address of the 1st element; which is all you need to get to the other elements!

    • y is the address of array, or the address of first element y[0]

    • y[0] is a variable

    • &y[0] is the address of y[0], is equivalent to y


Array initialization

Array Initialization

  • After declaration

    y[0]=12; y[1]=11; y[2]=18; y[3]=20; y[4]=15; y[5]=24;

  • At point of declaration

    • Can initialize every element allocated

      int y[6] = {12, 11, 18, 20, 15, 24};

    • Can initialize fewer than all elements allocated

      int y[6] = {12}; /* remaining elements are set to 0 */

    • Cannot initialize more elements than allocated

      int x[2] = {5, 8, 9};


Array initialization example

Array Initialization - Example

#define MAX 5

int num;

int u[MAX + 1];

int v[num];

int w[6] = {1, 2, 3, 4, 5, 6};

int x[ ] = {1, 2, 3, 4, 5, 6};

int y[6] = {1, 2, 3};

int z[] = {1, 2, 3};


Example

Example

double x[8] = {16.0, 12.0, 28.0, 26.0, 2.5, 12.0,

14.0, -54.5};

double sum;

x[3] = 25.0;

sum = x[0] + x[1];

sum += x[2];

x[3] += 1.0;

x[2] = x[0] + x[1];


Example1

Example

#define NUM_STUDENTS 50

int id[NUM_STUDENTS];

double gpa[NUM_STUDENTS];

id and gpa are parallel arrays


Array subscript

Array Subscript

  • Array subscript (or index)

    A constant, integer variable, or integer expression

    y[0] = 3; y[i] = 5; y[2 + 3 * x] = 10;

  • C does NO bound checking

    • Result of exceeding bounds is system dependent!

    • You typically will NOT get a runtime error - it will just allow you to overwrite unprotected areas of memory!

    • Be careful to only reference existing elements in your arrays!


Cps 125 digital computation and programming

i = 5;

printf(“%.1f”, x[i]);

printf(“%.1f”, x[i] + 1);

printf(“%.1f”, x[i] + i);

printf(“%.1f”, x[i + 1]);

printf(“%.1f”, x[i * 2]);

printf(“%.1f”, x[(int)x[4]]);

printf(“%.1f”, x[i++]);

printf(“%.1f”, x[--i]);

x[i – 1] = x[i];

x[i] – 1 = x[i];


Using for loop for sequential access

Using for Loop for Sequential Access

  • Counting loop, counter variable starts from 0 to < size of array

    #define SIZE 11

    int square[SIZE], i;

    for (i = 0; i < SIZE; ++i)

    square[i] = i * i;


Example read into array

Example – Read into Array

doubleabc[25] ;

inti ;

for (i = 0; i < 25; ++i)

{

printf (“Enter the %d element \n”, i ) ;

scanf ( “%f”, &abc[i] ) ;

}


Example print from array

Example – Print from Array

doubleabc[25] ;

inti ;

for (i = 0; i < 25; ++i)

{

printf (“The %dth element of array is %lf\n”, i, abc[i]) ;

}


Array elements as arguments

Array Elements as Arguments

  • This is similar to passing simple arguments

  • The formal parameter should be a simple variable

  • The actual parameter should be the array name followed by the particular index in []

  • Example

    void do_it(double a1, double *a2p, double *a3p);

    do_it(x[0], &x[1], &x[2]);


Cps 125 digital computation and programming

#include <stdio.h>

int odd(int num)

{

return (num % 2 == 1);

}

int main()

{

int x[4], i, oddsum = 0, evensum = 0;

printf("Enter %d integer values :", 4);

for (i = 0; i < 4; i++) {

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

if ( odd(x[i]) )

oddsum += x[i];

else

evensum += x[i];

}

printf("The sum of odd elements is : %d\n", oddsum);

printf("The sum of even elements is : %d\n", evensum);

return 0;

}


Array arguments

Array Arguments

  • The address of array is passed into function

  • In formal parameter declaration, specifying the array name followed by brackets [] (size is not necessary), e.g. int list[]

  • int *list is compatible with int list[]

  • The actual parameter is the array name (no brackets), e.g. list


Cps 125 digital computation and programming

/* Sets all elements of its array parameter to in_value. */

void fill_array (int list[], /* output - list of n integers */

int n, /* input - number of list elements*/

int in_value) /* input - initial value*/

{

int i; /* array subscript and loop control*/

for (i = 0; i < n; ++i)

list[i] = in_value;

}

Call this function: fill_array(y, 10, num);

fill_array(x, 5, 1);


Arrays as input arguments

Arrays as Input Arguments

  • In formal parameter declaration

    const element-type array-name[]

  • Array variable declared is strictly an input parameter

  • Its value cannot be modified by function

  • Still passing array address


Cps 125 digital computation and programming

int get_max(const int list[], int n)

{

int i,

cur_large; /* largest value so far*/

/* First array element is largest so far.*/

cur_large = list[0];

/*Compare remaining element to cur_large, save the larger*/

for (i = 1; i < n; ++i)

if (list[i] > cur_large)

cur_large = list[i];

return (cur_large);

}


Return an array result

Return an Array Result

void add_arrays(const double ar1[], const double ar2[],

double arsum[], int n)

{

int i;

/* Adds corresponding elements of ar1 and ar2*/

for (i = 0; i < n; ++i)

arsum[i] = ar1[i] + ar2[i];

}

Call this function: add_arrays(x, y, x_plus_y, 5);


Partially filled arrays

Partially Filled Arrays

  • A program need process many lists of similar data, with different length

  • Declare an array large enough to hold the largest data set anticipated

  • This array may be only partially filled

  • Two sizes: declared size (memory space allocated), actual size (counting elements in use)


Searching linear search

Searching (Linear Search)

  • Searching means scanning though a list of items or records to find a particular item

  • User specifies the target item

  • If the target item is found, the record or its location is returned, otherwise, an appropriate message or flag is returned

  • Linear search means searching through the list sequentially until the target item is found or the list is exhausted


Cps 125 digital computation and programming

1. Assume the target has not been found

2. Start with the initial array element

3. Repeat while the target is not found and there are more array elements

4. If current element matches the target

5. Set flag to indicate target has been found

else

6. Advance to next array element

7. If the target is found

8. Return the target index as search result

else

9. Return -1 as the search result


Sorting bubble sort

Sorting (Bubble Sort)

  • Compare adjacent pairs of an array

  • If the first is larger than second, interchange the two elements

  • Repeat the above two steps until the array is sorted in increasing order

  • After one pass, the element with the largest key has been “bubbled” to the end of the list

  • The procedure continues by successively increasing the starting point in the list by 1


Cps 125 digital computation and programming

44

33

55

22

33

44

22

55

33

22

44

55

22

33

44

55

Original array

Pass 1

Pass 2

Pass 3

Total number of pass required in bubble sort algorithm =n-1

Total number of comparisons required in first pass =n-1

Total number of comparisons required in second pass =n-2

Total number of comparisons required in third pass =n-3

Where n is size of the list (or Array).


Strings

Strings

  • Strings are arrays of char

    char str[50];

  • May vary in length – not all positions are used

  • Terminated by ‘\0’

    • Null terminating character

    • Array size must accommodate ‘\0’

  • Individual elements are char


String example

String - Example

elements past the null

are not part of the string

char name[6] = "Sam";

S a m \0

name

name[0]

name[5]

indicates end of string,

not end of array!


String initialization

String Initialization

  • Initialize

    • Can do each char separately or as a string constant

    • Initialization list of individual chars. Note null character at end – required for a string!

      char name[6] = {‘C’, ‘h’, ‘u’, ‘c’, ‘k’, ‘\0’};

    • Double quotes implies a null character at the end

      char name[6] = “Sam”;

  • Array of Strings

    char month[12][10] = {“January”, “February”, “March”, “April”, “May”, “June”, “July”, “August”, “September”, “October”, “November”, “December”};


Input output with printf scanf

Input/Output with printf & scanf

  • Placeholder %s

    • printf(“Topic: %s\n”, string_var);

    • If string_var contains no null character, printf will continue to display content of memory as characters until it encountered a null character or caused a run-time error

    • Right justification: printf(“%20s\n”, president);

    • Left justification: printf(“%-20s\n”, president);


Example with scanf

Example with scanf

scanf(“%s%d%s%d”, dept, &course_num,

days, &time);

> MATH 1270 TR 1800

> MATH 1270

TR 1800

> MATH1270 TR 1800

> MATH,1270,TR,1800

char dept[10];

Space not allocated for dept

M

A

T

H

,

1

2

7

0

,

T

R

,

1

8

0

0

\0


Cps 125 digital computation and programming

#define NUM_NAMES 30

#define NAME_LEN 25

char names[NUM_NAMES][NAME_LEN];

int age[NUM_NAMES];

for (i=0; i<NUM_NAMES; ++i) {

scanf(“%s%d”, names[i], &ages[i];

printf(“%-35s %d\n”, names[i], ages[i]);

}


String functions

String Functions

  • #include <string.h>

  • strcpy, strncpy

  • strcat, strncat

  • strlen

  • strcmp

  • strstr


Strcpy strncpy

strcpy, strncpy

  • strcpy(destination, source)

    strcpy(one_str, “Test string 1”);

  • Overwrites characters in destination with characters from source

  • Stops at ‘\0’ in source

  • strncpy(destination, source, n)

  • Same as strcpy, excepts copies up to n characters

  • No ‘\0’ appended at the end, have to assign by yourself

    destination[n] = ‘\0’;


Strcat strncat

strcat, strncat

  • strcat(destination, source)

    strcat(one_str, “ and 2”);

  • Appends characters in source to characters in destination

  • Stops at ‘\0’ in source

  • strncat(destination, source, n)

  • Same as strcat, excepts copies up to n characters

  • No ‘\0’ appended at the end, have to assign by yourself

    strcat(destination, “\0”);


Strlen

strlen

  • strlen(string)

    len = strlen(one_string);

  • Returns the number of characters in string

  • Does not include ‘\0’


Strcmp

strcmp

  • strcmp(string1, string2)

  • Compares one string to another

  • Returns

    • < 0 if string1 < string2

    • 0 if string1 == string2

    • > 0 if string1 > string2

  • strcmp(“thrill”, “throw”) strcmp(“throw”, “thrill”)

  • strcmp(“end”, “end”)

  • strcmp(“joy”, “joyous”)


Cps 125 digital computation and programming

printf("Enter list of words on as many lines as you like.\n");

printf("Separate words by at least one blank.\n");

printf("When done, enter %s to quit.\n", SENT);

for (scanf("%s", word);

strcmp(word, SENT) != 0;

scanf("%s", word))

{

/* process word */

}


Strstr

strstr

  • strstr(string1, string2);

  • Returns the position where string2 begins in string1

  • Returns NULL if string1 does not contain string2

  • char * pos;

    pos = strstr(“abcdef”, “xyz”);

    pos = strstr(“abcdef”, “cd”);


Case study

Case Study

  • Problem: A genetic engineer is developing a program to identify palindromes of a certain length in strings representing the nucleotide sequences of a portion of a DNA molecule.

    A-T-C-G-C-A-T-G-C-G-T-A-G

    T-A-G-C-G-T-A-C-G-C-A-T-C


Case study1

Case Study

  • Analysis

    Constant: STRANDSIZ 100

    Inputs: char strand1[STRANDSIZ],

    char strand2[STRANDSIZ];

    int palin_len;

    Outputs: index and value of each palindromic sequence of length palin_len


Case study2

Case Study

  • Design

    Algorithm:

    1. Get input data: complementary strands and palindrome length

    2. For each starting subscript of a substring of the desired length

    2.1 if substring from strand1 matches the reverse of corresponding substring of strand2

    2.1.1 Print the position and two substrings


Dynamic allocation of arrays

Dynamic Allocation of Arrays

  • Stack: statically allocated memory space

    • Sizes of variables in the function data areas are known when program is compiled

    • Space can be automatically made available for reuse after function call returns

  • Heap: dynamically allocated memory space

    • Spaces are allocated while program is running

    • In response to specific requests

    • Spaces should be explicitly given back for reuse


Dynamic memory allocation

Dynamic Memory Allocation

  • #include <stdlib.h>

  • double *nums_list;

    nums_list = (double *) calloc(list_size, sizeof(double));

    ……

    free(nums_list);


Stack and heap

Stack and Heap

Function Data Area

Heap

string1

array_of_nums


Cps 125 digital computation and programming

double *list;

int i, howmany;

printf(“How many numbers? => “);

scanf(“%d”, &howmany);

printf(“Enter %d numbers. => “, howmany);

for (i=0; i<howmany; ++i)

scanf(“%lf”, &list[i]);

printf(“your list is: “);

for (i=0; i<howmany; ++i)

printf(“%10.2f”, list[i]);

printf(“\n”);


Common programming errors

Common Programming Errors

  • Subscript-range error: out of range

    • Normally no run-time error, just incorrect results

    • Responsibility of programmer

    • Caused by incorrect subscript expression, a loop counter error, or a non-terminating loop

  • No & for passing array as argument even if for output

  • Use & for passing array elements as output

  • Overflow of character arrays allocated for strings

  • All strings end with the null character

  • Ensure enough stack space for large array

  • Allocate memory to array before using it


  • Login