Object Oriented Programming

Object oriented programming

Chapter 1Object Oriented Programming 1OOP revolves around the concept of an objects.Objects are created using the class definition.Programming techniques may include features such as Data abstraction.Encapsulation.Polymorphism.Inheritance. Many modern programming languages now support OOP. 2Abstract data typesAn outline of the program containing its requirements should precede the coding process for a project. Then, in the later stage, the implementation may start with specific data structure. First, specify each task in terms of inputs and outputs.Be concerned with what the program should do. For example, if an item is needed to accomplish some tasks, the item is specified by the operations performed on it not by its structure.When the implementation starts, it decides which data structure to use to make the execution more efficient.

3An item specified in terms of operations is called an abstract data type. ADT- An abstract data type can be defined by the operations that are done on the data regardless of its type.ADT- A set of data values and associated operations that are precisely specified independent of any particular implementation.ADT- Mathematical description of an object with set of operations on the object4Some information before startingYou already learned that addresses of variables can be assigned to pointers.However, pointers can refer to unknown locations that are accessible only through their addresses not by names. These locations must be set by the memory manager dynamically during the run of the program.To dynamically allocate and de-allocate memory, two functions are used: new takes from memory as much space as needed to store an object.Ex : p = new int; delete return the space that is accessible from p and is no longer needed. Ex : delete p; Note : an address has to be assigned to a pointer, if it cant be the address of any location, it should be a null address, which is simply 0.

5Chapter 3Linked Lists 6Linked listAn array is a very useful data structure in programming languages . However, it has at least two limitations:Fixed size: the size has to be known at compile time data is separated in the computer by the same distance. Insertion is a problem (shifting is required) that can be overcome by using linked structure. Linked List (LL): is a collection of nodes storing data and links (using addresses) to next nodes.7Linked listA linked list is a data structure that consists of a sequence of data records such that in each record there is a field that contains a reference (i.e., a link) to the next record in the sequence.

The most flexible linked structures implementation is by using pointers.

Linked lists are among the simplest and most common data structures; they provide an easy implementation for several important abstract data structures, including stacks, queues and arrays.83.1 Singly Linked Lists Linked list a data structure that composed of nodes, each node holding some information and a pointer to another node in the list.Singly linked list a node has a link only to its successor in the sequence of nodes in the list.Note :Only one variable is used to access any node in the list.The last node on the list can be recognized by the null pointer.9Example :class IntSLLNode{ public: IntSLLNode() { next = 0; } IntSLLNode(int i, IntSLLNode *ptr = 0) { info = i; next = ptr; }

int info; IntSLLNode *next; }; 10Now, how to create the linked list Create a new node by executing the declaration and assignment : IntSLLNode *p = new IntSLLNode(10);This statement create a node on the list and make p points to it.The constructor assigns the number 10 to the info member of this node.The constructor assigns null to its next member.Then any new node is included in the list by making the next member of the first node a pointer to the new node.The second node is created by : p -> next = new IntSLLNode (8); 11Where p -> next is the next member of the node pointed to p (Figure 3.1d). As before four steps are executed:New node is created (Figure 3.1e)The constructor assign the number 8 to the info member of this node (Figure 3.1f)The constructor assign null to the next member. (Figure 3.1g).The new node is included in the list by making the next member of the first node a pointer to the node (Figure 3.1h). p -> next -> next = new IntSLLNode (50);12

FIGURE 3.113Problem :The longer the linked list, the longer the chain of nexts to access the nodes at the end of the list when using pointers.In this example p -> next -> next -> next allow us to access the next member of the 3rd node on the list.If you missed a node in the chain, then a wrong assignment is made The flexibility of using linked lists is diminished .

14So, other ways of accessing nodes are needed. One of them is : To keep two pointers: one to the first node(Head), and one to the last(Tail).

Returen to figure 3.2 page 79.

Figure 3.3 a singly list of integers1516

Operations17InsertAt the Beginning (before Head)At End (after Tail) middleDeleteAt the Beginning (before Head)At End (after Tail) middleSpecial cases: Empty List, single-node listSearch3.1.1 Insertion inserting a new node at the beginning of a singly linked list

18Figure 3.4 3.1.1 Insertion (cont) inserting a new node at the end of a singly linked list

19Figure 3.5 Insert At the beginning Insert at the end addToTail(int el) { if (tail != 0) { // if list is not empty; tail->next = new IntSLLNode(el); tail = tail->next; } else { // if list is empty; head = tail = new IntSLLNode(el); } }

Complexity is O(1)

addToHead(int el) { head = new IntSLLNode(el,head); if (tail == 0) // if list is emptytail = head; }

Complexity is O(1)203.1.2 Deletion Deleting a node at the beginning of the list and returning the value stored in it.

21Figure 3.6 There are two special cases to consider :Attempt to remove a node from an empty linked list .One way is to use assert statement( with the function isEmpty() ).Or throw an exception by using throw clause( and having a matching try-catch clause).The list has one node to remove The list becomes empty and tail + head set to null.

223.1.2 Deletion (cont) Deleting a node from the end of the list and returning the value stored in it.

Problem :Tail has to be moved backward by one node? The predecessor has to be found, how?Use a temporary variable tmp that scans the list within for loop.

23

24Figure 3.7 25

Cont.Figure 3.7 In removing the last node, the two special cases are the same as in deleteFromHead().The list is empty or a single-node list becomes empty. (slide no. 21)

26Delete from HeadDelete from Tailint IntSLList::deleteFromTail() { int e1 = tail->info; if (head==tail) {// one nodedelete head;head = tail = 0; } else { IntSLLNode *tmp; for (tmp=head; tmp->next != tail; )tmp = tmp->next; delete tail; tail=tmp; tmp->next=0; } return e1; }Complexity is O(n)

int IntSLList::deleteFromHead() { int e1 = head->info; IntSLLNode *tmp= head; if (head==tail) // 1node only head = tail = 0;else head = head->next;delete tmp;return e1; }

Complexity is O(1)27Finding and deleting a node with certain integer:In this case, a node is removed from the list by linking its predecessor to its successor. So, Either scan the list and then scan it again to find the nodes predecessor.Or use two pointers variable(ex, pred and tmp) using for loop so that they point to first and second nodes of the list. 28

29Figure 3.8

30Complexity of deleting a node with certain integer:31Other deletion cases :Remove a node from an empty list function is exited.Delete a node from a one-node linked list - head =tail =null.Remove the first node of the list updating head.Remove the last node of the list updating tail. Delete a node with a number that is not in the list do nothing .Last , the one we discussed, delete a node with a number that is in the list 323.1.3 Search The searching operation does not modify linked lists, it just scans the list to find a number.

If tmp is not null, el was found and true is returned .If tmp is null, the search was unsuccessful and false is returned.

333.2 Doubly Linked Lists (DLL) To avoid singly linked list problem, the linked list is redefined so that each node in the list has two pointers, one to the successor and one to the predecessor. This list is called a doubly linked list .

34Figure 3.9 Insert a node to the end of Doubly linked list :A new node is created, and then its three data members are initialized :info member to a number, next member to null,prev member to value of tailtail is set to point to the new nodeThe next member of the predecessor is set to point to the new nodeComplexity is O(1)

35

36 Figure 3.11 Delete a node to the end of Doubly linked list:A temporary variable (ex. el) is set to the value in the node. tail is set to its predecessor.The last node is deleted.The next member of the tail node is set to null.Return the copy of the object stored in the removed node.Complexity is O(1)Note : before deleting, check if the list is empty.

37

38Figure 3.12 el = 10;3.3 Circular Lists (CLL)A list where nodes form a ring ; each node has a successor.For example: Several processes are using the same resources for the same amount of time, and each process need a fair share of the resources.

39Figure 3.13 Use only one permanent pointer, tail, to the list even though operations on the list require access to the tail and its successor, the head.

40Complexity is O(1)

Insert a node at the front of CSLLInsert a node at the end of CSLL

41Figure 3.14 Deletion of a node requires a loop to reach predecessor of Tail - O(n)A circular doubly linked list can avoid this problems in deletion and insertion to circular singly linked list and complexity becomes O(1)

42Figure 3.15 43OperationsSLLDLLCLLInsertAt Beginning (before Head)O(1)At End (after Tail)O(1)middleDeleteAt Beginning (before Head)0(1)At End (after Tail)O(n) O(1)O(n)middleO(n)SearchO(n)Complexity AnalysisComplete the missing cells