Abstract data types; static and dynamic data
structures.
Static arrays; arrays as arguments and parameters.
Default arguments.
Binary and linear search (recursive and non-recursive).
Insertion sort and selection sort (recursive and non-recursive) for
use with linked lists and with arrays.
Header files and breaking the program to 3 parts (specification part
of the class, implementation part of the class, and the driver
program).
Templates for use in classes and for stand-alone (independent)
functions.
Exceptions and exception handling (including the general exception,
built-in exception classes and user-defined exception classes).
Overloaded operators (including overloading the assignment operator,
==, !=, etc, for use with objects and other things).
Constructors (including the copy constructor) and destructors.
Methods to access or modify data members of a class.
Const and static methods.
Derived classes; this pointer.
Friends: classes declaring other classes or stand-alone functions as
friends.
Polymorphism; static and dynamic binding.
Abstract methods and classes.
Virtual and pure virtual methods.
Inheritance (private, protected, public, virtual) and multiple
inheritance.
Constructors and destructors and inheritance.
Applications on the above 10 items.
Pointers; pointers by value and by reference.
Functions returning pointers; pointers and array arguments; pointers
and reference arguments.
The new and delete operators.
Dynamic arrays and dynamic data.
Recursion (among the examples, there is an example to convert a number
from any number system to any other number system) and computing the
running time of recursive functions/methods.
Running time and Big O notation.
Computing the running time (including the running time for recursive
functions/methods).
Stacks and queues (with templates and exception classes) and their
applications. All the standard methods/constructors/destructors for stacks
and queues are implemented. Different implementations of some methods are
presented.
Trees; binary trees; binary search trees (all with templates and
exception classes); tree traversals; methods (iterative and recursive,
different implementations of the same methods, combining two or more
methods in one) for them. The methods implemented include constructors,
destructors, finding whether a value is in the tree or not, retrieving a
node; finding the level of a node, counting the number of levels, counting
the number of nodes, printing all the nodes at a given level, finding the
depth/height of the tree, finding the sum of the nodes, finding the
min/max, printing in inorder, preorder, and postorder, insertion of a node
in the tree, deletion (two different deletion procedures are covered) of a
node from the tree, destroying the tree, testing if the tree is full or
empty, making the tree empty.
Sorted/unsorted lists implemented with static arrays and dynamic
arrays, and as linked lists (all implemented with templates and exception
classes).
Linked lists (sorted and unsorted); linear linked lists; circular
linked lists; doubly linked lists; other kinds of linked lists; methods
(iterative and recursive, different implementations of the same methods,
combining two or more methods in one) for them. Methods implemented
include constructors, destructors, sorting the linked list (if it is
unsorted) by selection sort, recursive selection sort, and insertion sort,
finding whether an elemnt is in the list or not, retrieving an element
from the list, retrieving the element at a given position; finding the
length of the list, printing the elements of the list in order and in
reverse order, insertion of an element in the list, insertion of an
element in the list at a specified position/location, deletion of an
element from the list, deletion of the element at a given position,
destroying the list, testing if the list is full or empty, making the list
empty.
Other topics.
Remarks:
A large percentage of the stuff covered is not in the
textbook.
The restrictions in the textbook on the insertion, deletion,
retrieval, etc, methods for trees, lists, stacks, queues, and other data
structures, were removed. In other words, we implemented more efficient
methods than those in the textbook.
Many topics in the textbook were generalized.
Many topics in the textbook were presented as they are and then with
modifications.