★ CALL US 9953330565 ( HOT Young Call Girls In Badarpur delhi NCR
lec4.ppt
1. Data Structures
data object
set or collection of instances
integer = {0, +1, -1, +2, -2, +3, -3, …}
daysOfWeek = {S,M,T,W,Th,F,Sa}
2. Data Object
instances may or may not be related
myDataObject = {apple, chair, 2, 5.2, red, green, Jack}
3. Data Structure
Data object +
relationships that exist among instances
and elements that comprise an instance
Among instances of integer
369 < 370
280 + 4 = 284
4. Data Structure
Among elements that comprise an instance
369
3 is more significant than 6
3 is immediately to the left of 6
9 is immediately to the right of 6
5. The relationships are usually specified by
specifying operations on one or more
instances.
add, subtract, predecessor, multiply
Data Structure
6. Linear (or Ordered) Lists
instances are of the form
(e0, e1, e2, …, en-1)
where ei denotes a list element
n >= 0 is finite
list size is n
7. Linear Lists
L = (e0, e1, e2, e3, …, en-1)
relationships
e0 is the zero’th (or front) element
en-1 is the last element
ei immediately precedes ei+1
8. Linear List Examples/Instances
Students in COP3530 =
(Jack, Jill, Abe, Henry, Mary, …, Judy)
Exams in COP3530 =
(exam1, exam2, exam3)
Days of Week = (S, M, T, W, Th, F, Sa)
Months = (Jan, Feb, Mar, Apr, …, Nov, Dec)
14. Linear List Operations—
add(theIndex, theElement)
add an element so that the new element has
a specified index
L = (a,b,c,d,e,f,g)
add(0,h) => L = (h,a,b,c,d,e,f,g)
index of a,b,c,d,e,f, and g increase by 1
15. Linear List Operations—
add(theIndex, theElement)
L = (a,b,c,d,e,f,g)
add(2,h) => L = (a,b,h,c,d,e,f,g)
index of c,d,e,f, and g increase by 1
add(10,h) => error
add(-6,h) => error
17. Linear List Abstract Data Type
AbstractDataType LinearList
{
instances
ordered finite collections of zero or more elements
operations
isEmpty(): return true iff the list is empty, false otherwise
size(): return the list size (i.e., number of elements in the list)
get(index): return the indexth element of the list
indexO f(x): return the index of the first occurrence of x in
the list, return -1 if x is not in the list
remove(index): remove and return the indexth element,
elements with higher index have their index reduced by 1
add(theIndex, x): insert x as the indexth element, elements
with theIndex >= index have their index increased by 1
output(): output the list elements from left to right
}
18. Linear List as Java Interface
An interface may include constants
and abstract methods (i.e., methods
for which no implementation is
provided).
19. Linear List as Java Interface
public interface LinearList
{
public boolean isEmpty();
public int size();
public Object get(int index);
public int indexOf(Object elem);
public Object remove(int index);
public void add(int index, Object obj);
public String toString();
}
20. Implementing An Interface
public class ArrayLinearList implements LinearList
{
// code for all LinearList methods must be provided here
}
21. Linear List As An Abstract Class
An abstract class may include
constants, variables, abstract
methods, and nonabstract methods.
22. Linear List As Java Abstract Class
public abstract class LinearListAsAbstractClass
{
public abstract boolean isEmpty();
public abstract int size();
public abstract Object get(int index);
public abstract int indexOf(Object theElement);
public abstract Object remove(int index);
public abstract void add(int index,
Object theElement);
public abstract String toString();
}
23. Extending A Java Class
public class ArrayLinearList
extends LinearListAsAbstractClass
{
// code for all abstract classes must come here
}
24. Implementing Many Interfaces
public class MyInteger implements Operable, Zero,
CloneableObject
{
// code for all methods of Operable, Zero,
// and CloneableObject must be provided
}
25. Extending Many Classes
NOT PERMITTED IN JAVA
A Java class may implement as many
interfaces as it wants but can extend at most
1 class.
26. Data Structures In Text
All but 1 of our data structures are specified as Java
interfaces.
Exception is Graph in Chapter 17.
Java specifies all of its data structures as interfaces.
java.util.List
Editor's Notes
Any set or collection is a data object.
The instances of integer and daysOfWeek are related. In the former, all instances
are whole numbers, whereas in the latter all instances name days of the week. The instances of myDataObject don’t seem to be related.
You can have ordering relationships –2 before –1 before 0 before 1 etc (relational operators such as <, >, =, etc). Elements could be related by operations such as add, subtract, etc.
A data object is a set of instances; an instance of a linear list is an ordered set of elements.
Size of Students in COP3530 is 240, Exams is 3, DOW is 7, and Months is 12. Notice that Days of Week is used as an example of both a data object and of a linear
list. As a data object, {S, M, T, …} and {M, W, S, …} describe the same data object with 7 allowable instances S, M, T, … As a linear list (S, M, T, …) and (M, W, S, …) are two different instances of a linear list. Linear List itself may be viewed as data object, which is simply the set of all possible linear list instances.
The index of a nonexistent element is defined to be –1. When theElement is in the list an index between 0 and size()-1 is the result. So –1 would be an invalid index and is used to represent the case when theElement is not in the list
Should add comments that describe the parameters, return value, and functionality of each method. Looks a lot like the abstract data type specification but the data types, return type specification, name of output method (toString) are all peculiar to Java.
So an abstract class is more general than an interface. In addition to having the permissible components of an interface (constants and abstract methods), we can have variables and nonabstract methods.
In the case of a linear list, the main difference between the interface and abstract class specification is the use of the keyword interface vs the keywords abstract class. All methods of the abstract class have been declared as abstract to indicate that we are not providing their implementation here. In the case of an interface it isn’t required (though permissible) to declare each method abstract. This is because all methods listed in an interface are, by default, abstract.
Since ArrayLinearList is not declared as an abstract class, it must provide an implementation for all abstract methods of the class it extends (I.e., of LinearListAsAbstractClass).
Since a class can extend only one other class, it is prudent to save your single extension chip for cases when you really need it (I.e., when you must inherit method implementations from an existing class). In the case of the graph data structure, we combine the specification of the data structure with the implementation of some methods and specification of certain variables into an abstract class.
Java.util.list is a java interface specification for a linear list. Has all our methods plus more.
