resourceone.info Politics Data Structures And Algorithms Schaum Series Ebook

DATA STRUCTURES AND ALGORITHMS SCHAUM SERIES EBOOK

Saturday, October 12, 2019


SCHAUM'S OUTLINE OFDATA STRUCTURES WITH JAVA Second Edition JOHN The material in this eBook also appears in the print version of this Arrays Class 29 The Sequential Search Algorithm 30 The Binary Search. Data Structures with c - By Schaum series. Ar if. Loading Preview. Sorry, preview is currently unavailable. You can download the paper by clicking the button. Data Structures With c - By Schaum Series - Free ebook download as PDF File . pdf) or Data Structures and Algorithms Made Easy-Narasimha Karumanchi.


Data Structures And Algorithms Schaum Series Ebook

Author:ROSALINA DURWARD
Language:English, Spanish, Portuguese
Country:Lesotho
Genre:Children & Youth
Pages:145
Published (Last):20.08.2016
ISBN:252-7-40349-548-9
ePub File Size:24.75 MB
PDF File Size:11.63 MB
Distribution:Free* [*Regsitration Required]
Downloads:30860
Uploaded by: SEYMOUR

Data Structures With C - By Schaum Lipschutz - Ebook download as PDF File . pdf) or view presentation slides Data Structure Schaum Series (Chapter 4 to 9) by Gitansh Data Structures and Algorithms Made Easy-Narasimha Karumanchi . Providing Important topics YouTube links for Data Structure and Algorithms” What is Dynamic Programming Bellman-Ford Algorithm-Single Source Shortest Path | Dynamic Programming . resourceone.info As of today we have 78,, eBooks for you to download for free. The study of data structures and algorithms is fundamental to computer into this course.

I found this book in the library and so liked it that wanted to have a copy in my personal library. It is definetely not for experts. For me it was light and enjoyable reading. Are you short on time and need a book that gives you quick summaries? Are you trying to find a source that gives you concise explanations of core concepts?

Don't get me wrong: It's quite comprehensive and covers a lot of topics. It provides excellent examples and many exercises are given and solved for you.

The book is written in a clear manner also. However, this is intended as a "refresher": As you can image, each topic is given 3 lines, and then an example is provided. If you decided to pick this book up because you dont want to go through your long texbtook , and you are short on time, put it back.

This isn't the right choice - this is more of a review book. I love how this book goes over in detail about what data structures mean in Java and the exercises it has to practice that understanding. Recommended for anyone who wants to do a lot of practice on the subject.

The sample codes and mainly the java generic session or any session that uses generic types that teach parameterized types are very difficult to understand due to the missing symbols. It is not only missing this symbol but the whole generic declaration in classes and in parameters type. I had to search in the internet for a tutorial on Java generic types. I am still reading this book.

Theory discussions and also practices were excellent so far and I really appreciate the author and Schaum's itself to provide CS students such a great fundamental material. Thanks much! See all 7 reviews. Amazon Giveaway allows you to run promotional giveaways in order to create buzz, reward your audience, and attract new followers and customers.

Learn more about Amazon Giveaway. This item: Set up a giveaway. Customers who viewed this item also viewed. Data Structures and Algorithms in Java 2nd Edition.

Robert Lafore. Thomas H. Schaum's Outline of Software Engineering. Pages with related products. See and discover other items: There's a problem loading this menu right now. Learn more about Amazon Prime. Get fast, free shipping with Amazon Prime. Back to top. Get to Know Us. Amazon Payment Products. English Choose a language for shopping. Amazon Music Stream millions of songs. Amazon Advertising Find, attract, and engage customers.

Amazon Drive Cloud storage from Amazon. Alexa Actionable Analytics for the Web. Sell on Amazon Start a Selling Account. AmazonGlobal Ship Orders Internationally.

Amazon Inspire Digital Educational Resources. Amazon Rapids Fun stories for kids on the go. Amazon Restaurants Food delivery from local restaurants. ComiXology Thousands of Digital Comics. DPReview Digital Photography. East Dane Designer Men's Fashion.

Shopbop Designer Fashion Brands. Deals and Shenanigans. This makes the method polymorphic, capable of printing arrays of String objects and arrays of Ratio objects. The program also uses the generic sort method that is defined in the java. Arrays class. It requires the type parameter T to be an extension of the Comparable interface, which both the String class and our Ratio class are. Inclusion polymorphism and parametric polymorphism are both special cases of universal polymorphism.

The other general kind of polymorphism is called ad hoc polymorphism which also has two special kinds, named overloading polymorphism and coercion. These are best illustrated with primitive types. Coercion occurs when a value of one type is implicitly converted to a value of another type when the context requires that other type.

These libraries are orgainzed into several package hierarchies, known collectively as the Application Programming Interface API. The two most common package hierarchies are the java and javax hierarchies, parts of which are shown in Figure 1. Review Questions 1. String class 1. Problems 1. Point amplitude: Real distanceTo Point: Real equals Point: Boolean magnitude: Real toString: String xCoordinate: Real yCoordinate: Real 1. Line contains Point: Boolean equals Line: Boolean isHorizontal: Boolean isVertical: Boolean slope: String xIntercept: Real yIntercept: Circle area: Real center: Point circumference: Real contains Point: Boolean equals Circle: Boolean radius: String CHAP.

Data Structures With c - By Schaum Series

Polynomial degree: Polynomial equals Point: Boolean sum Polynomial: Polynomial toString: String valueAt Real: Answers to Review Questions 1. The implementation stage is where the computer progam code is actually written. The behavior of a class is defined by its methods. The main method must have this header: A class member that is declared protected is accessible only from its own class and subclasses extensions.

A class member that is declared private is accessible only from its own class. A constructor is a member function of a class that is used to create objects of that class. It has the same name as the class itself, has no return type, and is invoked using the new operator. A method is an ordinary member function of a class. It has its own name, a return type which may be void , and is invoked using the dot operator. A class method is declared static and is invoked using the class name.

For example, 1. An instance method is declared without the static modifier and is invoked using the name of the object to which it is bound. Two references are equal if they refer to the same object.

In the second case, s is initialized to refer to the empty String object. With aggregation, the component elements exits outside of the collection, can be changed by other classes, and may even be components of other aggregates. For example, inheritance allows an argument of type B to be passed to a parameter of type A if B extends A. Solutions to Problems 1. The element numbers are called index numbers.

Array elements can be accessed by their index numbers using the subscript operator [], as a[0], a[1], a[2], and so on. Arrays are widely used because they are so efficient. Arrays are objects.

Arrays are created dynamically at run time. Arrays may be assigned to variables of type Object. Any method of the Object class may be invoked on an array. An array object contains a sequence of variables. The variables are called the components or elements of the array. If the component type is T, then the array itself has type T[]. An array type variable holds a reference to the array object. The component type may itself be an array type.

An array element is a component whose type is not an array type. The length of an array is its number of components. Array index values must be integers in the range Variables of type short, byte, or char can be used as indexes.

Arrays can be duplicated with the Object. Arrays can be tested for equality with the Arrays. Array objects implement Cloneable and java. Property 3 follows from Property 1. Although array types are not classes, they behave this way as extensions of the Object class.

Property 7 shows that array types are not the same as class types. They are, in fact, derived types: For every class type T there is a corresponding array type T[]. Also, for each of the eight primitive types, the corresponding array type exists. Technically, Java allows multidimensional arrays only with primitive types. But for objects, an array of arrays is essentially the same thing. Since arrays themselves are objects, an array of arrays is an array of objects, and some of those component objects could also be nonarrays.

See Example 2. Note that a consequence of Property 13 is that changing a reference component value to null has no effect upon the length of the array; null is still a valid value of a reference component. Line 4 defines x[] to have float components. Note the two different equivalent ways to declare an array: The brackets may be a suffix on the type identifier or on the array identifier. Line 5 defines args[] to have 10 String components.

Line 6 defines isPrime[] to be an array of boolean variables. Line 7 defines fib[] to be an array of 8 ints, initializing them to the 8 values listed. So for example, fib[4] has the value 3, and fib[7] has the value Line 8 defines b[][][] to be a three-dimensional array of 4 components, each of which is a twodimensional array of 10 components, each of which is a one-dimensional array of 5 component elements of type short.

Line 9 defines a[][] to be an array of five components, each of which is an array of elements of type double. Only three of the five component arrays are allocated. Then line 10 allocates a element array of doubles to a[4], and line 11 assigns 3. Line 12 defines the array objects to consist of six components, each of which is itself an array.

The components of the first four component arrays are elements nonarrays. But the components of the components b and a are not elements because they are also arrays. The actual elements of the objects array include 2, 5, and 13 components of the component fib , null components of the component a , and 2. The array a[][] defined in Example 2. The element type of an array in Java can be a primitive type, a reference type, or an array type.

The simplest, of course, are arrays of primitive type elements, such as x[], isPrime[], and fib[] in Example 2. These are arrays that can be sorted. The array b[] is a duplicate of a[]. Similarly, the array d[] is a duplicate of the array c[], each containing three String elements. In both cases, the duplication is obtained by invoking the clone method. Since it returns a reference to an Object, it must be cast to the array type being duplicated, int[] or String[].

The last part of the example shows that the cloned array d[] is indeed a separate copy of c[]: The name of this class is Arrays, and it is defined in the java. Arrays Class This program imports the Arrays class from the java.

It also imports the static print method from Example 2. At line 7, the call Arrays. At line 9, the Arrays. The second argument, 44, is the search target. The method returns the index 2, which is assigned to k at line 9. Line 11 verifies that 44 is indeed the value of a[2].

The method is invoked again at line 13, this time searching for the target The output from line 17 shows how the Arrays. It filled the eight-element array b[] with the argument It will return true only if the two arrays have the same element type as a[] and b[] do: The java. Arrays class is outlined in more detail in page It is also the least efficient.

It simply examines each element sequentially, starting with the first element, until it finds the key element or it reaches the end of the array.

If you were looking for someone on a moving passenger train, you would use a sequential search. Here is the sequential search algorithm: Return 1.

It is implemented in Example 2. The method returns —1 when the target is not in the array: The sequential search is correct. This means that it works. The following argument is a proof of that fact. Only step 4 executes, immediately returning 1. This satisfies the postconditions: If s0 z x, then the loop terminates, step 4 executes, and 1 is returned, and that satisfies the postcondition because the single element of the sequence is not equal to x. We want to apply the First Principle of Mathematical Induction to deduce that the loop invariant must be true on every iteration of the loop.

See page That requires the verification of the invariant on the first iteration and the deduction of the invariant on iteration i from the corresponding invariant on iteration i 1. If s0 z x, then the loop continues on to a second iteration. Thus, si z x. This means that, on average, the running time is proportional to the number of elements in the array.

So if everything else is the same, then applying the sequential search to an array twice as long will take about twice as long, on average.

If x is in the sequence s, then it must be in the subsequence ss. Let si be the middle element of ss. The binary search is correct. The loop invariant is true on the first iteration because the current subsequence is the same as the original sequence.

On every other iteration, the current subsequence was defined in the preceding iteration to be the half of the previous subsequence that remained after omitting the half that did not contain x. So if x was in the original sequence, then it must be in the current subsequence.

Thus the loop invariant is true on every iteration. Since the original sequence has only a finite number of elements, the loop cannot continue indefinitely.

Consequently, the algorithm terminates either by returning i from within the loop or at step 6 or step 7 where 1 is returned. Otherwise, the loop terminates when hi CHAP. This means that, on average, the running time is proportional to the logarithm of the number of elements in the array. So if everything else is the same, if it takes an average of T milliseconds to run on an array of n elements, then will take an average of 2T milliseconds to run on an array of n 2 elements. For example, if it takes 3 ms to search 10, elements, then it should take about 6 ms to search ,, elements!

Each iteration of the loop searches a subarray that is less than half as long as the subarray on the previous iteration. Thus the total number of iterations is no more than the number of times that the length n can be divided by 2. That number is lgn.

And the total running time is roughly proportional to the number of iterations that the loop makes. Review Questions 2. Problems 2. The interpolation search can be shown to run in O lglgn time. If it took 5 ms to run on an array of 1, elements, how long would you expect it to take to run on an array of 1,, elements on the same computer? Use the following algorithm to compute and print a sieve of size Initialize p[0] and p[1] to be false, and all other p[i] to be true.

Repeat step 3 for each i from 3 to n, incrementing by 2.

If there is a prime d the square root of i that divides i, set p[i] false. Vector object. BitSet object. Use these definitions: Write a program that tests the Goldbach conjecture for all even numbers less than Use the Primes class from Problem 2.

Your first 10 lines of output should look like this: These numbers are called Fermat primes. Write a program that finds all the Fermat primes that are in the range of the int type.

Your first 5 lines of output should look like this: This particular function was of interest to mathematicians because it produces an unusual number of prime numbers. Write a program that finds all the Babbage primes that are less than 10, Your first five lines of output should look like this: The twin primes conjecture is that there are infinitely many twin primes.

Write a program that finds all the twin primes that are less than The square numbers are 1, 4, 9, 16, 25,. He believed that most of these n are also primes, now CHAP. For example, is palindromic. Write a program that checks each of the first 10, prime numbers and prints those that are palindromic.

Answers to Review Questions 2. An array element is a component that is not itself an array type. So in a two-dimensional array a[][], the components of a[] are its row arrays, and the elements of a[][] are double variables.

A Java array has only one index variable. However, since a components indexed by that variable can itself be an array with an index , the original array appears to have more than one index.

This give the programmer some control over the consequences of such a run-time error. It depends upon how close their indexes are to multiples of midpoints of subintervals. For example, if the binary search is applied in an array of 10, elements, searching for a value that is repeated at locations 0—99, the search would return the index 77 on the 7th iteration.

Solutions to Problems 2. So an array with twice as many elements would take twice as long to process: So an array with elements would take twice as long to process: So an array with 1,, elements would also take about 2 ms to process.

But if you want to maintain an ordered list that allows quick insertions and deletions, you should use a linked data structure.

This chapter shows how to do that. This suggests that we should keep our arrays in sorted order. But inserting new elements in an ordered array is difficult. The main problem is that we have to shift all the larger elements forward to make room for the new element to be placed in its correct ordered position.

This can be done by the insert method shown in Example 3. The code at lines 4—7 searches the array for the correct position for x to be inserted.

Data Structures with Java 2e By John R hubbard, Schaum's Outline Series.pdf

The arraycopy method is a static method in the System class. It is usually the most efficient way to copy elements between arrays or within a single array. Its five arguments are: Finally, x is inserted into a[i] at line 9, as shown in Figure 3. Figure 3. So this is a 4 n operation. Deleting an element is simply the reverse of the insertion process. So deletion is also a 4 n operation. This solution requires more space a second array and makes the code a bit more complicated.

But it eliminates the need to move the elements. It allows the elements to be stored at an arbitrary position in the array, using the auxiliary index array to locate them for ordered access.

Data Structures With C – by Schaum Series PDF

The main idea is shown in Figure 3. So if we save the order of the index numbers 3, 5, 1, 4, 6 , then we can access the elements in order: An index array is an array whose elements are index values for another array. By storing the index numbers 3, 5, 1, 4, 6 in an index array k[] shown in Figure 3. The reason we wanted to allow the element to be stored in arbitrary positions in the first place was to simplify the insertion and deletion operations.

We wanted to avoid having to shift segments of a[] back and forth. But the solution shown in Figure 3. If we had to insert the element 50, we could put it at position a[0] or a[2] or any place after a[6], but we would then have to insert its index into the index array k[] between k[2] and k[3] to keep track of the order of the elements.

A better solution is to use the same array positions in the index array k[] as we are using in the data array a[].

Since the index array is keeping track of the correct order of the index numbers of the data elements, it can be used to do the same for the index numbers themselves. The starting index 3 is stored in k[0]. That begins the chain of indexes: The index 0 signals the end of the ordered sequence. The index sequence 0, 3, 5, 1, 4, 6 gives us the data elements in order: The extra variable free, shown Figure 3. The value 7 means that k[7] and a[7] should be used next.

The implementation of an index array solves the problem of having to shift segments of array elements back and forth during deletions and insertions. Then just follow these three steps: This improves the insert method shown in Example 3. At line 6, x is inserted in the next free location in the array a[]. At line 7, the index of the next location after x is stored in k[free]. At line 8, the index of x is copied into k[i], and then free is incremented to the index of the next free location.

In practice, we would probably include a resize method. Their relative positions in the index array match the positions of the corresponding data elements. So we can combine them into a single array of data-address pairs, as shown in Figure 3. Fortunately, Java allows an even better solution, one that allows us to eliminate both arrays! Taking an object-oriented point of view, we see in Figure 3.

Each object contains a data element and the address of the next object in the sequence. In Java, objects are directly accessed by their addresses. Here, the arrows represent object references i. The Java runtime system does all the rest of the bookkeeping. The code is given in Example 3. Its next field is declared to have type Node. Each Node object contains a field that is a reference to a Node object. The other field in the Node class is its data field, declared at line 2 here to be an int.

Of course in general this field could be any type we want whatever type values we have to store in the list. The Node class in Example 3. Note that, since we have explicitly defined a constructor that takes at least one argument, the compiler will not implicitly define a no-argument constructor.

Therefore, since we have not explicitly defined a no-argument constructor, none will exist. That means that the only way a Node object can be created is with the one-argument constructor at line 5 ; that is, we must provide a data value for each new Node object that we create.

Its data field contains the integer 22, and its next field contains a reference to another Node object not shown. Although it is common to use an arrow like this to represent an object reference, it is good to keep in mind that the actual value of the reference is the memory address of the object to which it refers. In other programming languages, such variables are called pointers; hence their common depiction as arrows.

Recall that in Java each reference variable either locates an object or is null. The value null means that the variable does not refer to any object. The memory address that is stored in a null reference variable is 0x0 the hexadecimal value 0 ; no Figure 3. Example 3. The result is shown in Figure 3. Note that the start variable is merely a reference to the Node object. Also note that the next reference in the Node object is null, indicated by the black dot with no arrow emanating from it.

In Java, every class field that is an object reference i. In the figures that follow, each Node object is shown as a box with two parts: This simply abbreviates the versions shown in Figure 3. Continuing the code in Example 3. Now the list has two nodes, as shown in Figure 3. To do that, we have to assign it to the next field of the node that contains But the only node to which we have external access i.

Its name is start. So we have to use the expression start. Similarly, the fourth node is added at line 4 using the expression start. That finally gives us the five-node list shown in Figure 3. The code in Example 3. Obviously, if we wanted to build a linked list of 50 nodes, this approach would be unworkable.

Since it will refer to individual nodes, it should be declared to be a Node reference, like this: Node p; And since our only access to the nodes is from the start node, we should initialize p like this: This same assignment can thus be executed as many times as is needed to advance through the linked list.

But one big advange is that it is easily managed within a loop. For example, the same list can be built with the three lines of code in Example 3. Each step in the execution of this code is shown in Figure 3. The reference variable p is analogous to an array index i: It advances through the nodes of a linked list just as i advances through the elements of an array.

Consequently, it is natural to use p in a for loop, just as we would use the array index i. For example, compare Example 3. Then the for loop at lines 5—7 constructs the other four nodes. The second for loop at lines 8—10 prints the node data in the first five lines of output. The third for loop at lines 11—13 gives the actual memory addresses of the five Node objects. When you use an object reference like p in a string expression such as System.

Book Details

Unless it has been overridden, the version of the toString method that is defined in the Object class will execute, as it did in the program in Example 3. So the last five lines of output report that the five Node objects are stored at the hexadecimal memory addresses 0xc1, 0x3f5d07, 0xf4a24a, 0xcac, and 0xa These then are the actual values stored in the reference variables start, start.

You can see from Figure 3. Showing the actual memory address values instead requires more effort to see which node references which. Moreover, those memory address values are runtime dependent: They will be different on different computers, and maybe even on the same computer at different times.

One final note: When i is 1, that evaluates to 33; when i is 4, it evaluates to After the value is obtained, it is passed to the Node class constructor at line 5 of Example 3. That constructs a node with that value in its data field and null in its next field. The constructor returns a reference to the Node object.

It is that reference that is assigned first to p. The key is that the assignments are made from right to left. So we know that p is not updated until after its next field is. So, first the next field is set to point to the new node, and then the loop control variable p is advanced to that next node.

To simplify the process, we add a two-argument constructor to our Node class, as shown in Example 3. This allows us to create the node and insert it all at once. It shows next as a reference to a Node object and x as an int with value Passing these two arguments to the constructor creates a new Node object that contains 50 and whose next field points to the same object that the given next pointer points to.

The constructor then returns a reference to the new Node object, which is assigned to q. To appreciate its simplicity, compare it with the equivalent method in Example 3. The variable p is declared at line 4 to be a reference to Node objects. It is initialized to point to the start node, which contains 22 in Figure 3. The loop control condition p.

But inside the loop, at line 6, the condition will stop the loop prematurely, before p reaches any nodes that should come after the new node. This is how the list remains in ascending order: New elements are always inserted between the elements that are less than it and those that are greater than it. On each iteration of the while loop, this assignment moves p to point to the next node in the list.

The actual insertion is done by the statement at line 9. The expression new Node x,p. The statement at line 7 assigns it to p. This changes the next pointer of the p node the node containing At that point, p. Once we understand this process, we might as well use the power of Java and write it in the single statement p. To see why that precondition is needed, look at what the method would do if x were 20 instead of In that case, the break condition at line 6 would be true on the first iteration of the while loop, leaving p pointing at the start node when the new node gets inserted at line 9.

The result, as shown in Figure 3. The problem is that we lack a node to precede the new one. This uses a little extra space, but it allows the insert method in Example 3.

The other solution is to modify the insert method in Example 3. This is done in Example 3. There are two situations in which the insert should be done at the front of the list: Both conditions are handled at line 4. In the first case, we could simply reset start to a new node containing x, like this: In the second case, we also have to assign the new node to start, but we also have to connect it to the rest of the list.

But the only reference we have to the beginning of the list is start itself, so we would have to hold that reference in a temporary variable before reassigning start to the new node. Note that unlike the simpler version in Example 3. The same is true for deletion. Like the insert method, the delete method has two main parts: It also handles the special case at the front of the list separately. Also, if the first element is greater than x, then since the list is sorted, all the elements must be greater than x, so x is not in the list.

Both of 1 2 these cases are handled first at line 5.

If the first element in the list equals x, then it is deleted at line 8. This is done by returning start. If it finds one greater, then the method breaks at line 12 and returns without changing the list. If it finds an element equal to x, then it deletes it at line This is illustrated in Figure 3.

A class that is a member of another class is called a nested class. This is an important example of the information hiding principle that we have applied in other contexts. If X is any type class or interface and Y is any other type nested within X, then every member of X is accessible from Y and every member of Y is accessible from X. This is illustrated in Example 3.

The Main class in Example 3. Both classes have a private int field. Main declares and initializes m at line 2; Nested declares and initializes n at line The Nested class also defines a private method f at line Outside of Nested; nested. That instantiates the Nested class at line 5. The private field n of the Nested class is accessed at line 6, and the private method f of the Nested class is accessed at line 7.

This shows that private members of a nested class are accessible from its enclosing class. Symmetrically, the private members of the enclosing class are accessible from within its nested class, as demonstrated by line The UML symbol for the nesting of one class inside another uses a circle with a plus sign inside in place of the arrowhead, as shown in Figure 3. Since all members of a Figure 3. Normally, a nested class should be declared static unless its instances need to access nonstatic members of its enclosing class.

A nested class that is nonstatic is called an inner class. The Node class defined in Example 3. So it should be nested inside its List class. Moreover, since nodes have no need to access List methods or fields, the Node class should be declared as a static nested class.

This is done at line 12 in Example 3. A developer could change the implementation without having to modify any code outside of that class. Problems 3. Changing one list should have no effect upon the other. Note that the two lists must be completely independent of each other. Note that no new nodes are created by this method. Note that the three lists should be completely independent of each other. Changing one list should have no effect upon the others.

Answers to Review Questions 3. To find the th element, you have to move sequentially through the first 99 elements. Its main purpose is to provide a unified framework for implementing common data structures so that the resulting classes can be used in a consistent, efficient, and intuitive manner.

This chapter outlines how these types can be used. The JCF specifies four general types of collections: List, Queue, Set, and Map.

These are defined as interfaces and are extended and implemented with other interfaces and classes in the java. The relationships among the main classes and interfaces in the JCF are summarized in Figure 4. The interfaces are shown on the right in italics, and the classes that implement them are on their left. The dashed lines indicate direct implementation.

Inheritance, both between classes and between interfaces is shown by solid lines. For example, the AbstractList class extends the AbstractCollection class, and the List interface extends the Collection interface. Note that some of the class names have the prefix Abstract, which indicates that they include abstract methods that are implemented by their subclasses.

A list is a sequence of elements. A queue is a first-in-first-out collection, like a waiting line. A set is an unstructured collection of distinct elements. These are more specialized types.

A Deque is a doubleended queue, allowing insertions and deletions at both ends. The SortedSet and SortedMap interfaces work only with objects that can be compared, like strings. The JCF implements the interfaces with several different data structures. The simplest structure is an indexed structure, that is, an array, which is used by the ArrayList, the ArrayDeque, the HashSet, and the HashMap classes.

Other implementations use a linked structure. The specialized EnumSet and EnumMap classes use a bit string. These twelve implementations are summarized in Table 4. They are the Vector, Stack, Dictionary, and Hashtable classes. It specifies 15 methods, as shown in the Javadoc page in Figure 4. Some of these methods are obvious: The equals and hashCode methods are inherited from the Object class and are meant to be overridden.

The add method may work differently for different implementations. For collections that prohibit duplicate elements, this method should add the specified object only if it is not already an element. For collections that allow duplicate elements, the method should add the specified CHAP. Collection interface object, possibly as a duplicate. In either case, the method should return true if and only if it changed the collection.

For example, if an implement prohibits null elements, then the method should throw a NullPointerException if the argument is null. In that case, it would implement the method like this: Note the parameter specifier: The containsAll method is to the addAll method as the contains method is to the add method. In particular, it should return true if invoked immediately after a call to the addAll method with the same Collection argument.

The iterator method returns an Iterator object that is bound to its implicit argument. Iterators are outlined on page The Collection interface specifies three optional removal methods. The remove method deletes one instance of its specified object, if it is an element.

The removeAll method deletes all the elements that are equal to elements in its specified collection. The retainAll method deletes all the elements that are not equal to elements in its specified collection. Note that the addAll , the retainAll , and the removeAll methods are equivalent to the set-theoretic union, intersection, and complement operators, respectively. These are illustrated in Figure 4.

Figure 4. The array returned by the no-argument version has type Object[]. The array returned by the oneargument version has the same array type as the argument. The Collection interface can be used directly as a specification for a Bag class. A bag is an unordered collection that allows duplicate elements.

Its instances represent ordinary sets of unique elements no duplicates. In fact, a set can be defined simply as a collection of unique elements. It extends the AbstractSet class. That class implements the Set interface, which extends the Collection interface. See Figure 4. The AbstractSet class implements the equals method, the hashCode method, and the removeAll method, designating the other 12 methods as abstract. This means that the concrete EnumSet, HashSet, and TreeSet classes have their own specialized implementations of those 12 methods.

The HashSet class gets its name from the fact that collections of this type maintain no order among their elements; they are all mixed up, like hash. The isEmpty method is tested at line 4 and again at line At line 5, the collection is loaded with five elements. This is done by the static addAll method defined in the java. Collections class. Note that the order with which the five elements are printed at line 6 is different from the order with which they were added to the set.

The size and contains methods are tested at lines 7—9. The add method is tested at line 11, and the remove method is tested at line At line 15, the one-argument toArray method is used to generate a String array of the same elements that are in the collection. The for loop at lines 16—18 confirms that the array contains the same elements. Lines 20—21 create and load a second set, named g8. This is then used together with the set collection to test the retainAll , removeAll , and addAll methods at lines 23— Finally, the clear method is tested at line Specifying the element type this way causes the compiler to prevent any non-String objects from being inserted into the collection, making it type-safe.

The JCF uses type parameters in most of its classes and interfaces. Whatever type that is, it must also be the type for the parameter o in the offer method at line 2 and the return type for the other four methods specified at lines 3—6.

Related titles

Like a method parameter, it stands for a type that can be substituted for it. The actual type that is substituted for the type parameter is called a type argument. For example: DEC, 25 ; System. It has two type parameters: S and T. In the code at lines 14, 15, 17, 22, and 26, these two type parameters are used as place holders for actual types.

But the construct is required when the constructor is invoked, as at line 3. Recompile with Xlint: You can avoid that simply by specifying an element type; even Object itself, like this: This allows the type parameter E to be used in place of an actual type in the method block at line 8.

Note that if we used Collection instead of Collection at line 1, then the method would only apply to collections whose element type is specified as Object. For example, if you wanted to restrict the print method in Example 4. It acts like a finger, pointing to one element at a time, much like the cursor of a text editor points to one character at a time. And like a cursor, an iterator has the capability of moving from one element to the next and of deleting its current element.

The analogy between iterators and cursors is not complete. Most iterators cannot jump around the way cursors can. On the other hand, it is possible to have several independent iterators traversing the same collection. Moreover, it is possible to have several different iterator classes defined for the same collection class, each with its own traversal algorithms.

The requirements for an iterator are specified in the java. Iterator interface, shown in Figure 4. Iterator interface The next method returns the current element of the collection to which the iterator is bound. Each time the next method is invoked, it advances the iterator to the next element in the collection.

The hasNext method returns true unless the iterator has reached the end of its traversal. This predicate is used to determine whether the next method can be called again.

The remove method deletes the last element returned by the next method. This means that next must be called before each call to remove , designating the element to be deleted. It returns a new iterator, bound to the collection and initialized to its first element. MZ it1. BR it1. PT it1. CV The Iterator object it1 is instantiated at line 6 and returned by the iterator method.

Bound to the port collection, it visits the elements in the same order as they were printed at line 5. Note that this order is not the same as the order in which the elements were added to the collection. Since the collection is a set, its elements have no intrinsic order. It is the iterator itself that computes the traversal sequence. You can see from the output from line 5 that the toString method invoked implicitly by the println method uses the same traversal sequence, obviously using its own iterator to build the string.

At line 11, the last next call was at line 10, which returned the MO element; so MO is deleted by remove at line Similarly, at line 14, the last next call was at line 13, which returned the GW element; so GW is deleted by remove at line These deletions are evident from the output produced by the while loop at lines 17— Notice that that loop uses the independent iterator it2 to traverse the collection.

Note that the code at lines 16—19 make a complete traversal of the collection. This is guaranteed by the instantiation of the new iterator at line 16 and the use of the hasNext method to control the loop.

The last output, generated at line 21, confirms that the two iterators it1 and it2 are independent.We want to apply the First Principle of Mathematical Induction to deduce that the loop invariant must be true on every iteration of the loop. Amazon Second Chance Pass it on, trade it in, give it a second life. For example, if an implement prohibits null elements, then the method should throw a NullPointerException if the argument is null. If you decided to pick this book up because you dont want to go through your long texbtook , and you are short on time, put it back.

A char cannot be used where a boolean is expected, and a Ratio object cannot be used where a Person object is expected. At line 10, the binarySearch method searches for the string "CN".

Note that this implements the empty stack as a single dummy node with its prev and next links pointing to the node itself.