_{###########################}

_{Cpsc331 Lecture 1.}

_{Material relevant to the very start of Chapter 3}

_{##########################}

_{What is a Data Structure?}

_{First of all, what we are going to be talking about is a data-items storage structure, but it is convenient to abbreviate the name to just data structure.}

_{Unfortunately, this shorter term data structure can now be confused with the idea of the structure of data, for the term is sometime used with that meaning in mind.}

_{Data Structure Definition:}

_{A data-items storage structure, or data structure,}

_{is an organized arrangement of storage receptacles (in a computer memory, or on disk, or on plain paper, etc) for storing data items.}

_{A data structure is thus a container for data, and can be empty, full, or partly full.}

_{When we say a data structure is organized (that is, has multiple organs), we mean that it may be made up of substructures, each of which is also a data structure.}

_{Many different kinds of arrangement of the storage receptacles are possible, so that there are many kinds of data structure.}

_{***An array in main memory is a well-known data}

_{structure example, and can be empty or full.}

_{***An array of arrays is another data structure,}

_{this one containing sub data structures (the inner arrays).}

_{***A computer file on disk is another data structure,}

_{containing records as sub data structures.}

_{###############################}

_{Data Structure Analogies}

_{A. We can have a personal items structure (like a lady's purse) as an arrangement of storage receptacles for personal items. Many arrangements (i.e. purse designs) are possible. Thus a lady's purse holds personal items, just as a data structure holds data items.}

_{A. We can have a food items structure (or supermarket structure), as an organized arrangement of receptacles for storing food items, organized into shelving units, display cases, and refrigerated units. Many arrangements are possible (supermarket structure design).}

_{A (supermarket) food items structure is thus a container for food items, and can be empty, full, or partly full. It is an organized structure because, for example, a shelving unit will be a food items substructure within the overall food items structure, and will itself have substructures, such as individual shelves.}

_{#############################}

_{Data structures versus Data items}

_{Always be careful distinguish between a data structure and the data items it contains.}

_{For example, we could copy the contents of an array into a stack, and also into a queue. Three different data structures could now be holding an identical set of data items.}

_{Conversely, over the execution time period of a program, an array could hold three different sets of data. One data structure, three sets of data.}

_{Analogously, a lady would never confuse the personal items in her purse with the purse itself.}

_{################################}

_{Efficient Data Structures}

_{A good data structure is an efficient data structure.}

_{An efficient data structure}

_{1. Allows (close to) the fastest possible access}

_{to data items, for the purposes intended}

_{2. Consumes (close to) the least possible storage space}

_{Analogously, supermarkets are very good and very visible examples of efficient structures for food items. You have fast access, and they make optimum use of the floor space.}

_{######################################}

_{Efficient programs and algorithms}

_{Most importantly:}

_{An efficient data structure will permit efficient programs and algorithms.}

_{An efficient program or algorithm is one where:}

_{(a) the task is carried out in the least number of possible steps, and therefore in the least time}

_{(a) the task is carried out with the least possible use of resources, particularly storage space resources}

_SO:

_{EFFICIENT DATA STRUCTURES}

_{ARE A REQUIREMENT FOR}

_{EFFICIENT PROGRAMS OR ALGORITHMS}

_{###########################################}

_Algorithm:

_{Definition: A stepwise procedure for performing a task in a finite amount of time, that is, a useful sequence of processing steps.}

_{For any given task there will be many possible algorithms, some more efficient, i.e. requiring fewer steps and less space for data structures, than others. For example, there are many different algorithms for sorting an array of data items.}

_{[Primarily, though, we are interested in the number of steps in an algorithm, since this will be directly proportional to the Running Time on a computer.]}

_{Analogously, there are many different ways (algorithms)}

_{for cutting the grass on a lawn with a lawn mower, e,g. turn-in-spiral method, up-turnright-down method, up-back-turnright method, etc., some more efficient (less distance traveled) than others.}

_{##########################################}

_{TRANSIENT VERSUS}

_{PERMANENT DATA STRUCTURES}

_{A data structure can be}

_{(a) transient}

_{i.e. it is created when a program starts}

_{and is destroyed when the program ends.}

_{Most data structures in main memory are}

_{transient, for example, an array of data.}

_{(b) Permanent}

_{i.e. it already exists when a program starts}

_{and is preserved when the program ends.}

_{Most data structures on disk are}

_{permanent, for example, a file of data, or}

_{a cross-linked data file collection (a database).}

_{In this course we are mostly concerned with the transient data structures common in main memory.}

_{[ Other courses deal with files, and with advanced data structures like databases.]}

_{##################################}

_{DATA [STRUCTURE] TYPES}

_{A data structure type, called a data type, is an abstraction of, that is, what is common to all members of, a set of data structures of the same type. Each specific data structure is then an instance of the general data structure type.}

_{In a program, such as a C, Pascal, or Java program, a data structure type is used as a template for the manufacture of specific data structures of that type, (by allocating the right number and size of memory receptacles).}

_{Java Data Structure instances}

_{public class Sailor {}

_{String name;}

_{String position;}

_{double salary;}

_{int seasSailed;}

_{} // data structure type specified}

_{class executionClass {}

_{public static void main (String[] args ) {}

_{Sailor s1, s2; // two record data structure}

_{// instances created.}

_{s1.salary = 3567.72;}

_{. . .}

_{s2.seasSailed = 7;}

_…

_}}

_{##################################}

_{ABSTRACT DATA [STRUCTURE] TYPE (ADT)}

_{An abstract data structure type, abbreviated to abstract data type, or to the acronym ADT, is an abstraction of, that is, what is common to members of, a set of data structures of the same type, plus a set of procedures (or methods) that can be used to manipulate the contents of any instance of a data structure of that type. Each specific ADT instance will have the use of the associated set of procedures, and is an instance of the abstract data type.}

_{In a Java program, the implementation of an ADT is called a class, and is used as a template for the manufacture of specific ADT instances or class instances, (by allocating the right number and size of memory receptables).}

_{An ADT instance is still primarily a container for data items, and if access to the data items is via the associated set of procedures only, the data items are said to be encapsulated.}

_{Java ADT (or class) instances}

_{public class Sailor {}

_{String name;}

_{String position;}

_{double salary;}

_{int seasSailed;}

_{Sailor (. . .) { . . . . .}; //constructor}

_{public void upSalaryBy (double raise) { . . . . .};}

_{public int getSeasSailed() {. . . . .};}

_{public void promoteTo (String newposition) { . . .};}

_etc

_}

_{//ADT template or class specified above}

_{//ADT or class instances s1, s2 created and used below}

_{public class executionClass {}

_{public static void main (String[] args ) {}

_{Sailor s1, s2; // two ADT}

_{// instances created.}

_{s1.salary = 3567.72;}

_{. . .}

_{s1.upSalaryBy (105.10) ; //new salary 3672.82}

_{. . .}

_{s2.seasSailed = 7;}

_…

_{System.out.println (s2.getSeasSailed);}

_}}

_{Java ADT or class instances with encapsulation of the data items}

_{public class Sailor {}

_{private String name;}

_{private String position;}

_{private double salary;}

_{private int oceansSailed;}

_{Sailor (. . .) { . . . . .}; //constructor}

_{public void upSalaryBy (double raise) { . . . . .};}

_{public int getSeasSailed() {. . . . .};}

_{public void promoteTo (String newposition) { . . .};}

_etc

_}

_{/* ADT template or class specified above}

_{ADT or class instances s1, s2 created and}

_{attempted used below */}

_{public class executionClass {}

_{public static void main (String[] args ) {}

_{Sailor s1, s2; // two ADT}

_{// instances created.}

_{s1.salary = 3567.72; //illegal--encapsulated}

_{. . .}

_{s1.upSalaryBy (105.10) ;}

_{. . .}

_{s2.seasSailed = 7; //illegal--encapsulated}

_…

_{System.out.println (s2.getSeasSailed); }}}

_{Material Relevant to around page 103 in Chapter 3 follows.}

_{Estimating steps in a program}

_Example

_{public class ArrayMaxProgram {}

_{public static void main (String[] args ) {}

_{int[] num =}

_{{ 10, 15, 3, 5, 56, 107, 22, 16, 85};}

_{int returnedMax;}

_{long startTime, endTime;}

_{startTime = System.currentTimeMillies();}

_{//returns about one trillion}

_{returnedMax = arrayMax (num n, n);}

_{endTime = System.currentTimeMillies();}

_{System.out.println ("elapsed time : " +}

_{(endTime - startTime)}

_{+ " milliseconds" );}

_{System.outprintln ("Max value: " + returnedMax);}

_}

_{/* * * * * * * * */}

_{// returns maximum value in array of n elements}

_{static int arrayMax ( int[] A,}

_{int n)}

_{

_{max = A[0]; // 1 time, 2 steps}

_{for ( int i = 1; i < n; i++ ) /* 1 time; 2 steps}

_{n times; n steps}

_{( n-1) times 2(n-1) steps (NOTE: respectively.) */}

_{{ if ( max < A[i] ) / / (n -1) times 2(n -1) steps}

_{max = A[i]; }; /* worst case:( n-1) times 2(n-1) steps}

_{best case: 0 times */ 0 steps}

_{return max; } // 1 time 1 step ???}

_{//worst case TOTAL 7n -1 steps}

_{S = f(n) = 7n -1 steps}

_}

_{[More About this in Lecture 2]}

_{###############################}