Procedural Programming & Fundamentals of Programming

Transcription

1 Procedural Programming & Fundamentals of Programming Lecture 4 - Summer Semester 2018 & Joachim Zumbrägel Writing a computer program is only one step in the Program Development Process 2 1

2 What we know so far... (1/3) Computers should help us to solve problems First we need to understand the problem, which requires to get all relevant information Then we create a step-wise solution to it, which at its best is following a problem-solving strategy 3 What we know so far... (2/3) By means of flowcharts (for algorithm) and pseudocode (for program) we document and structure our solution approach A computer executes the program, which we write in a specific programming language 4 2

3 What we know so far... (3/3) Control structures serve to manage the order of instructions, which change data in the main memory of a computer. To organize this data and its respective manipulation, we use data types and data structures. The challenge is to develop a proper abstraction of the system in the real world into a problem model to be solved by the computer. We are responsible for the programs that we write. 5 Struct(ures) 3

4 Records (Structures) A record permits a programmer to handle a group of variables as one variable The fields / members / components of a record can be any built-in or programmer-defined data type A record can have values assigned to and read from it just like the built-in variable types A record can also be passed as an argument to a function and serve as the return value for a function 7 Structures in C A struct is a mechanism for grouping together related data items of different types. Recall: An array groups items of a single type Example: We want to represent an airborne aircraft: We can use a struct to group these data together for each plane. 8 4

5 Defining a Struct We first need to define a new type for the compiler and tell it what our struct looks like. This tells the compiler how big our struct is and how the different data items ( members ) are laid out in memory. But it does not allocate any memory. 9 Declaring and Using a Struct planea altitude flightnum: 409 flighttype planea ; Access: flighttype planeb ; Access: planea. flightnum planeb. flightnum planea. airspeed planeb. airspeed planeb flightnum: 1767 planea. altitude planeb. altitude time planea. time == planeb. time 10 5

6 Declaring and Using a Struct To allocate memory for a struct, we declare a variable plane using our new struct data type struct flight type. Memory is allocated, and we can access individual members of this variable: A struct s members are laid out in the order specified by the definition. 11 Airplane Coordinates Position time x y z 100s x0 y0 z0 200s x1 y0 z1 300s x2 y0 z2 400s x3 y0 z3 500s x4 y0 z4 600s x5 y0 z5 700s x6 y0 z6 800s x7 y0 z7 900s x8 y0 z8 1000s x9 y0 z9 12 6

7 Airplane Coordinates (in km) Position time x y z 100s s s 400s 500s 600s 700s 800s 900s 1000s 13 Airplane time Index Element of Array t 100s 0 t [0] 200s 1 t [1] 300s 2 t [2] 400s 3 t [3] 500s 4 t [4] 600s 5 t [5] 700s 6 t [6] 800s 7 t [7] 900s 8 t [8] 1000s 9 t [9] Cells in Main Memory From the previous lecture: At 100s Define an array of type flighttype: flighttype t[10]; At 200s At 300s At 400s At 500s At 600s User defined data type At 700s At 800s At 900s At 1000s 14 7

8 Declaration of User-defined Data Type struct student { int matr_num; char family_name [20]; char first_name [20]; name of the structure keyword to start the structure declaration components of the structure with different data types char study_course [20]; } ; 15 Access to Structure Components struct student { int matr_num; student_instudycourse is a structured variable consisting of four components. Cells in Main Memory char family_name [20]; student_instudycourse. matr_num student_instudycourse. family_name char first_name [20]; student_instudycourse. first_name char study_course [20]; student_instudycourse. study_course }; struct student student_instudycourse ; Access to each component 16 8

9 Dynamic Data Structures - Linked List - Linked List is a data structure in which each element is dynamically allocated and in which elements point to each other to define a linear relationship Singly- or doubly-linked Stack, queue, circular list 18 9

10 Definition of Linked List (1/2) struct listitem { struct student student_instudycourse; struct listitem *next; }; 19 Definition of Linked List (2/2) Items of list are usually same type Each item points to next item Last item points to null Need head to point to first item! 20 10

11 Head of a Linked List struct listitem { struct student student_instudycourse; struct listitem *next; }; struct listitem *head; 21 Usage of Linked Lists Not massive amounts of data Linear search is okay Sorting not necessary or sometimes not possible Can add and delete data on the fly Even from middle of list 22 11

12 Adding an Item to a List (1/3) Add an item pointed to by q after item pointed to by p Neither p nor q is NULL q p 23 Adding an Item to a List (2/3) Add an item pointed to by q after item pointed to by p q q.next = p.next p 24 12

13 Adding an Item to a List (3/3) Add an item pointed to by q after item pointed to by p q p.next = q p 25 Data structures applied in problem solving 13

14 How to cross the river? 27 Mapping information to data a state indicating the location of items 0: item is at near shore 1: item is at far shore int SHORE[4]={0,0,0,0}; Condition on state transition: Boat can only carry one or none item at a time! > relevant to identify neighboring states 28 14

15 State space model (2 4 = 16 states) (1): Boat: 0 Fox: 0 Goose: 0 Corn: (16): Boat: 1 Fox: 1 Goose: 1 Corn: 1 29 State space model (10 valid/ 6 invalid states) Boat: 0 Fox: 0 Goose: 0 Corn: Boat: 1 Fox: 1 Goose: 1 Corn:

16 Breadth-first search Breadth-first search (BFS) belongs to uninformed (or blind) searching strategies in a graph (a structure made up of nodes connected with edges) does not make use of heuristics for minimizing its computational expensiveness in solving a problem, such as in informed searching approaches begins at a root node and inspects all the neighboring nodes before expanding next level does not explore graph as far as possible along one path before backtracking, such as in depth-first search makes use of queue to manage graph traversal 32 16

17 Queue is a data structure following the FIFO (First In First Out) principle to its elements can be implemented by linked list Queue TAIL n+1 enqueue HEAD TAIL 1 TAIL TAIL n FRONT dequeue HEAD BACK 33 An algorithm for breadth-first search 1. Determine state and add it to QUEUE. 2. Pick head state from QUEUE, add it to QUEUE _visited. a) IF head== then stop and success. b) ELSE add all neighboring states of head to (tail of) QUEUE. 3. IF QUEUE == empty then fail. 4. Repeat

18 Step 1 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat 2. QUEUE QUEUE_visited Boat: 1 Fox: 1 Goose: Head of QUEUE Tail of QUEUE 35 Step 2 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited Strategy #1: Do not consider invalid states

19 Step 3 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat Boat: 1 Fox: 1 Goose: QUEUE 7 3 QUEUE_visited 7 Strategy #2: Do not consider already visited states again. 37 Step 4 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited

20 Step 5 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited Note: QUEUE_visited does NOT equals THE solution path! 39 Step 6 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited

21 Step 7 of already close to, but Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited Step 8 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat Boat: 1 Fox: 1 Goose: QUEUE (15) 10 QUEUE_visited Strategy #3: Do not consider same head state twice

22 Step 9 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat 2. 2:0001 3:0011 4: :0101 6:0110 7: :1000 9: : : : : : : Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited Step 10 of Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat 2. 2:0001 5:0101 8:1000 9:1001 3:0011 4: :0110 7: : : : : :1111 Boat: :1011 Fox: 1 Goose : 1 Corn: 1 QUEUE QUEUE_visited

23 Final Step: Success 1. Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to (tail of) LIST. 3. IF LIST == empty then fail. 4. Repeat 2. 2:0001 3:0011 4: :0101 6:0110 7: :1000 9: : : : : : : Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited Final Step: Success 1. Determine state and add it to LIST. 2. Pick head state from LIST and add it to LIST_visited. a) IF head== then stop and success. b) ELSE add all (valid) next states to the (tail tricky of) LIST. step 3. IF LIST == empty then fail. 4. Repeat 2. 2:0001 3:0011 4: :0101 6:0110 7: :1000 9: : : : : : : Boat: 1 Fox: 1 Goose: QUEUE QUEUE_visited

24 Finally Applying strategies can reduce time and space complexity of a solution approach Developing solutions is no mechanic procedure, it is a creative act For problem solvers and programmers to be effective: There is not just one way of doing it. 47 of 6th lecture 24