Cps 125 digital computation and programming
Download
1 / 49

CPS 125: Digital Computation and Programming - PowerPoint PPT Presentation


  • 100 Views
  • Uploaded on

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.

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 ' CPS 125: Digital Computation and Programming' - ali-newton


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

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 24

  • 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 24

  • 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 24

#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 24

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 24

#define NUM_STUDENTS 50

int id[NUM_STUDENTS];

double gpa[NUM_STUDENTS];

id and gpa are parallel arrays


Array subscript
Array Subscript 24

  • 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!


i = 5; 24

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 24for 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 24– Read into Array

double abc[25] ;

int i ;

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

{

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

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

}


Example print from array
Example 24– Print from Array

double abc[25] ;

int i ;

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 24

  • 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]);


#include <stdio.h> 24

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 24

  • 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


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

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 24

  • 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


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

{

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 24

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 24

  • 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) 24

  • 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


1. Assume the target has not been found 24

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) 24

  • 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


44 24

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 24

  • 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 24

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 24

  • 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 24printf & 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 24scanf

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


#define NUM_NAMES 30 24

#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 24

  • #include <string.h>

  • strcpy, strncpy

  • strcat, strncat

  • strlen

  • strcmp

  • strstr


Strcpy strncpy
strcpy, strncpy 24

  • 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 24

  • 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 24

  • strlen(string)

    len = strlen(one_string);

  • Returns the number of characters in string

  • Does not include ‘\0’


Strcmp
strcmp 24

  • 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”)


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 like.\n");

  • 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 like.\n");

  • 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 like.\n");

  • 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 like.\n");

  • 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 like.\n");

  • 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 like.\n");

  • #include <stdlib.h>

  • double *nums_list;

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

    ……

    free(nums_list);


Stack and heap
Stack and Heap like.\n");

Function Data Area

Heap

string1

array_of_nums


double *list; like.\n");

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 like.\n");

  • 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


ad