16. Linked Structures and Miscellaneous

Size: px

Start display at page:

Download "16. Linked Structures and Miscellaneous"

Ashlee Green
6 years ago
Views:

1 16. Linked Structures and Miscellaneous The main purpose of this section is to look at the cool topic of linked data structures. This is where we use one object to point to the next object in a structure of many objects. In this section, we will look at how object reference variables, which contain the address of other objects, can be used to link together interesting, useful, and high performance data structures. Linked data structures will be covered extensively in Cmpt 201, 307, and 354, but you will get a peek here in case you don t take Cmpt 201. Also, the concepts of addresses and pointers are used for other things like: Required Readings: None. Optional Readings: Ch. 10 of [Savitch2001] 16. Linked Structures and Miscellaneous Linked Data Structures Simple Static Linked List Simple List Exercises Vectors Java Collections Classes Summary/Software Engineering Process Final Exam and Office Hours: Copyright 1998 by R. Tront 16-1 Copyright 1998 by R. Tront 16-2

2 16.1 Linked Data Structures One of the lovely things you can do with reference/ pointer/address variables is to create linked data structures in RAM. You can also use linked data structures on disk, though you use the position measured down the file, rather than RAM addresses, as your link specifier. In either case, the data is not necessarily arranged in any kind of order, however the links usually have some order (perhaps increasing value of some attribute) ptrtolowest Each of the top 3 boxes represent an object record. The are called list nodes. The fact is, the data may be scattered all over the heap portion of RAM, or all over a particular file on disk. It is the links that provide the order. Since RAM and binary files allow quickly moving from one place in the heap or in a random-access file to Copyright 1998 by R. Tront 16-3 another, we usually do not draw a linked list as shown above, but in the more conceptual order shown below. ptrtofirst Note that I have changed the name of the pointer to the list head from ptrtolowest to ptrtofirst. Since a list could alternately be in decreasing integer order, this a more general name. The HUGE advantage of these links is that they are easy to change. This makes inserting a new element at the start, or into the middle of a list much faster than making room in the middle of an array for a new element (where you would painstakingly have to move all the elements in the latter portion of the array to the right). Copyright 1998 by R. Tront 16-4

3 16.2 Simple Static Linked List Now, let s look at some code for a simple list that holds integers. Note that this is not a list class, as that would mean we could create multiple lists. Instead this is the simplest list your instructor can use as a first exposure to linked list: one where the shepherd knows where a bunch of other objects (or at least where the first of many sheep that are connected together with rope/ leash). / / F I L E : S t a t i c I n t e g e r L i s t. j a v a / / = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = c l a s s L i s t N o d e { / / T h i s c l a s s p r o v i d e s t h e n o d e r e c o r d s f o r / / a n i n t e g e r l i s t. int datavalue; L i s t N o d e n e x t ; / / = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = = p u b l i c c l a s s S t a t i c I n t e g e r L i s t { / / P r o v i d e s a s i n g l e l i s t p o i n t e d t o b y a / / s t a t i c v a r i a b l e. T h i s i s l i k e s h e p h e r d / / k n o w i n g w h e r e t h e l i s t o f s h e e p a r e. s t a t i c L i s t N o d e p t r T o F i r s t ; / / p u b l i c s t a t i c v o i d m a i n ( S t r i n g [ ] a r g s ) { i n s e r t A t F r o n t ( 1 3 ) ; i n s e r t A t F r o n t ( 5 ) ; i n s e r t A t F r o n t ( 2 ) ; printlist(); Copyright 1998 by R. Tront 16-5 Copyright 1998 by R. Tront 16-6

4 There are two classes in this file (the file also continues over the following few pages). The first class, which is not public, is just for the list node records. (It would probably more appropriate for it to be a nested class, but we have not studied any of the 4 kinds of nested classes yet, so I have just defined it nonpublic. This unfortunately means that any class in the package can access it, though no other class needs to access it). The next thing is the start of the definition of my static list class. This class s only attribute is a static variable that will be used to point to the head of the list. The class also has a main program that demonstrates the use of other static functions like telling the shepherd to add a node to the front of the list, and to print an inventory of the list. Now let s look at how we would implement these functions: p u b l i c s t a t i c v o i d p r i n t L i s t ( ) { / / p r i n t s l i s t i n f r o n t - t o - b a c k o r d e r. L i s t N o d e t e m p P t r = p t r T o F i r s t ; w h i l e ( t e m p P t r! = n u l l ) { / / D o n ' t e n t e r p r i n t i n g l o o p i f l i s t / / i s e m p t y, s o u s e t o p e x i t l o o p. S y s t e m. o u t. p r i n t l n ( t e m p P t r. d a t a V a l u e ) ; / / c h a n g e t e m p P t r t o r e f e r t o n e x t //element, in preparation for next //iteration of print loop. t e m p P t r = t e m p P t r. n e x t ; Copyright 1998 by R. Tront 16-7 Copyright 1998 by R. Tront 16-8

5 The print function uses a temporary variable to point at intermediate nodes as it is iterating down the list. When you first start, you set this so called list scanner reference variable (sometimes called an iterator) to point at the first element. After a few cycles of the loop, when you are half way down the list, the situation might look like this: ptrtofirst 2 tempptr 5 13 Later, as you get to the end of the list, the algorithm finds that the next attribute of the last node is null (this is what the unconnected dot means in the above diagram). We use the special object reference value called null as a marker for the end of the list. Now let s look at the interesting part: how we build the list: / / p u b l i c s t a t i c v o i d i n s e r t A t F r o n t ( i n t n e w V a l u e ) { i f ( p t r T o F i r s t = = n u l l ) { / / i f n o e l e m e n t s i n t h e l i s t : p t r T o F i r s t = n e w L i s t N o d e ( ) ; p t r T o F i r s t. d a t a V a l u e = n e w V a l u e ; / / N o w m a r k t h i s a s l a s t n o d e i n l i s t. p t r T o F i r s t. n e x t = n u l l ; e l s e { / / p u t i n f r o n t o f f i r s t e l e m e n t. //Need temporary pointer. L i s t N o d e t e m p P t r ; / / N o w c r e a t e a n d f i l l n e w n o d e. t e m p P t r = n e w L i s t N o d e ( ) ; t e m p P t r. d a t a V a l u e = n e w V a l u e ; / / n e w n o d e s h o u l d p o i n t t o / / o l d f i r s t n o d e. tempptr.next = ptrtofirst; //head pointer can point to new node p t r T o F i r s t = t e m p P t r ; Copyright 1998 by R. Tront 16-9 Copyright 1998 by R. Tront 16-10

6 When you are inserting a new element at the front of a list (or middle, or back), you generally have to handle the special case of whether the list might be empty. In the printlist( ) function, we handled it with a top-exit loop. In the insertatfront( ) function, we handle it with an if statement. If the list is empty, then we need to create a new node that is pointed to by ptrtofirst. We also need to insert the new value in the that new node s datavalue attribute. And we need to mark this as the last node. If the list already has some values in it, we need to insert the new node in front of the currently frontmost node. And, we need to make ptrtofirst point at the new first node. BUT, we cannot overwrite the address in ptrtofirst yet, or we will lose the address of the old frontmost node. So we need a temporary object reference variable to hold either the address of the new node, or temporarily hold the value of the old first node. It doesn t really matter which of these two tiny strategies you choose, but you must program things appropriately once you have chose the strategy. I chose to have a temporary hold the address of the new first record. ptrtofirst 1 tempptr Once we construct the new first node, we can fill its datavalue and also point it at the old first node (whose address we can copy from the old value of ptrtofirst). Once I have the new node pointing to the old first node, I no longer need to remember that address in ptrtofirst. So at the end I finally update ptrtofirst so that it will contain the address of the new first node Copyright 1998 by R. Tront Copyright 1998 by R. Tront 16-12

7 16.3 Simple List Exercises Good Exercise: Add a ListNode constructor with two parameters: the value, and the address to put in the next attribute. Then rewrite the StaticIntegerList class to take as much advantage of this ListNode constructor as possible. Good exercise: Add another static attribute that always refers to the last element on the list (sometimes called the tail of the list). You must set this properly when the very first node of the list is added. Good exercise: Write a function that adds an element to the end of the list, using the above tail pointer. Good exercise: Write a function that adds an element to the end of the list without using a tail pointer. It would have to first scan the list to the end (similar to the print loop above), before adding the new element after the old last node. Good exercise: Write a function that removes the first element of the list. Note: If you have functions that both add to the end of the list and also another that removes from the front, you have just made a queue (like a line-up of people at your bank machine or movie theater ticket window). There are many situations where a computer program must use a first in, first out queue like this. Copyright 1998 by R. Tront Using an array for a queue is very slow, because when you remove an element from an array, you have to shift all the elements toward the front. This can be very slow if the array is 10,000 elements long. However, in comparison to an array, a list may take up twice as much space (100% more space) as an array, because each node requires the storage of an integer and also an object reference (i.e. address). But, if each datavalue is, say, a 1000 byte student record rather than a single integer, then the wasted space is only 0.1% rather than being 100% extra space. Good Exercise: Write a function to search the list for a certain datavalue. Good Exercise: Write a list class that, rather that using nodes that contain an integer and a next reference, instead contain a reference to an Object and a next reference. This way we would put any kind of objects in the list, making it more general purpose. Good Exercise: Write a function that searches a list for an student record with a particular student ID. Good Exercise: Write a function that adds a new record after a particular middle record. The middle record might be found with a search for a certain student number or may be just a record count (e.g. insert after the 15th record). Copyright 1998 by R. Tront 16-14

8 Hard Exercise: Insert a record before a particular searched for element. Hard Exercise: Remove the last element from a list. Moderate exercise: Rewrite the above class so the list is an object rather than a static entity. Then in an application program, you can construct and use multiple lists (e.g. the day list, the night list, the green list, etc.) Vectors Early versions of Java provided a somewhat adaptable collection class called a Vector. It was was like an expandable array, and also supported list like features. It is still used somewhat, but has generally been superceded by other new library collection classes. However, Vectors have one advantage in that they are self-protected against multiple threads of a program (or programs) trying to do things to them at the same time, and the links getting all mixed up. This is because Vectors use by default critical section protection. In the newer collection classes, critical section protection is not present by default, but can be added to any class by special constructor means. This means that they newer ones are faster that Vectors if you don t need the critical section protection. Copyright 1998 by R. Tront Copyright 1998 by R. Tront 16-16

9 16.5 Java Collections Classes Newer versions of Java come with a large library of sophisticated collection classes for lists, trees, queues, sets, hash tables, lookup tables, etc. For instance, lookup and compare ArrayList and LinkedList, both of which are new. Most collection classes used in most modern computer languages use the concept of an iterator class. An iterator is an instance of yet another class that is used to point to a particular place in a list. You can ask the iterator object to give you the data from the node it is pointing to, move ahead one node in the list, back up one node in the list, tell you whether it is currently at the head or the tail of the list, insert an element just after the node it is pointing to, rewind to point at the first element of the list. (Rewind is sort of like rewinding a tape). It is common to construct an iterator, rewind it to the beginning, and scan the list by asking the iterator to move ahead one node at a time. You will learn more about iterators in Cmpt Summary/Software Engineering Process You have had a very good introduction to programming. But software engineering is more than just programming. I chose to give you assignments that built on the previous one so that in the end you would have something pretty substantial. It is small in comparison to industrial programs (which are often 100,000 to 1,000,000 lines of code), but in the end was pretty large for first year students. You gained several benefits from this size: The program grew larger than one module, and thus you began to appreciate that architectural planning/layout of a program is a significant design issue (there are different ways to lay it out, and design is chosing between alternatives. You saw that a multi-module program needed carefully planned and specified class declarations/interfaces (not function definitions/bodies) known to programmers of other modules, in order for them to understand exactly how to access your module s variables and functions. These well-defined interfaces provides strong type checking across modules, so you don t catastrophically call a function with the wrong number or type of parameters. Copyright 1998 by R. Tront Copyright 1998 by R. Tront 16-18

10 Since you are unlikely to write 100,000 lines yourself, using other programmer s modules is an essential aspect of any large project. Finally, you gained an appreciation for maintenance. Specifically, you saw that adding features even for a reasonably well thought out increase in program functionality required rather messy changes and adjustments to the various modules. But, if the module interfaces were well thought out, and the module implementations abstract (irrelevant to the calling programmer), then often an implementation change within one module (say array to file storage) could be done without changing any calling modules. In a large project, the typical phases (called the Software Life Cycle) needed are: Requirements Elicitation - getting the customer to state exactly what she needs, or to provide you with enough documentation that you can figure out this yourself. This is NOT easy as customers often either do not know what they want, or don t describe it completely, or don t have time to tell you. Analysis - analyze the information gleaned during requirements elicitation and organize it. Generally this requires making a data model of objects and relationships. Some students on Coop work terms have worked on projects which had 1500 different object classes and their relationships. Also during analysis you have to figure out storage needs, performance needs, security needs, user interface style, training needs, etc. Design - often broken into 4 sub-phases: - External Design - what the user interface will look like during any given stage of any given operation. This is easiest documented with a draft user manual. Student s hate the idea of writing the manual first, but if you don t know what it is supposed to look like, how can you know what to program? - Architectural Design - deals with the macroscopic issues like how many processors, what data and processes on each, what subsystems for each process/program. - Module Design - designing the interfaces for the various modules, including class declarations. This includes what data and (member) functions will be exported from each class and package. And what are the function names, parameter lists, and return types. - Detailed Design - the design of the actual code with flowcharts and selecting certain algorithms (e.g. selection sort vs. quicksort). Implementation and Unit Testing - the writing of the code, and the testing by the author of individual modules. Unit testing is done by writing little main programs called drivers designed to call and test your functions. This is done before your new module is linked into the other 100,000 lines of code in the project, so you won t embarrass yourself when you code messes up the operation of the other 100,000 lines of code. Copyright 1998 by R. Tront Copyright 1998 by R. Tront 16-20

11 System Integration and Integration Testing - where you start linking things together and debugging the link errors and other inter-module incompatibilities. System and Acceptance Testing - where the system as a whole is tested. System testing is done by your company, and acceptance testing by the customer. Note that Integration and testing and system debugging can take up to 40% of the project effort. Failing to budget for this will embarrassingly cause you to be 100/(100-40) = 66% over your initial (imaginary) budget and effort estimates. Installation and Cut-Over and Training - where the system is installed for the first time at the customer site(s). The data from the customer s previous system must be transferred and (hopefully) read by your new software. And all the customer s employees must be pre-trained. Doing this for a huge system like Air Canada which must be running 24 hours a day is a nightmare for programmers. Maintenance - three kinds: debugging errors reported by your software customers, enhancing your software product, and porting your software product to new operating systems, database, network, and hardware as needed. Retirement of the software. I wish you the best of luck on the final exam, and on the rest of your education and a perhaps career deeply involved in this software life cycle! 16.7 Final Exam and Office Hours: Final Exam- Day: Time: Room: Regular Office Hours - are now ended. Special Office Hours: Marks will be posted: Where: In the on-line Gradebook. When: sometime on (Instructor s pet peeve: Don t ask me when they will be ready before this. I will you if they are ready early.) After marks are posted, office hours for appeals will be announced via . Copyright 1998 by R. Tront Copyright 1998 by R. Tront 16-22

CSE373 Fall 2013, Second Midterm Examination November 15, 2013

CSE373 Fall 2013, Second Midterm Examination November 15, 2013 Please do not turn the page until the bell rings. Rules: The exam is closed-book, closed-note, closed calculator, closed electronics. Please