Download ch3-linked list

Object Oriented Programming
Chapter 1
1
 OOP 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.
2
Abstract data types
 An 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.
3
 An 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 object
4
Some information before starting
 You 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:
1. new – takes from memory as much space as needed to store an object.

Ex : p = new int;
2. 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 can’t be the address of any
location, it should be a null address, which is simply 0.
5
Linked Lists
Chapter 3
6
Linked list
 An 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.
7
Linked list
 A 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 structure’s 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.
8
3.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.
9
 Example :
class IntSLLNode
{ public:
IntSLLNode()
{ next = 0; }
IntSLLNode(int i, IntSLLNode *ptr = 0)
{ info = i;
next = ptr; }
int info;
IntSLLNode *next;
10
};
Now, 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.
2. Then any new node is included in the list by making the next member of
the first node a pointer to the new node.
3. The second node is created by :
p -> next = new IntSLLNode (8);
1.
11
Where p -> next is the next member of the node pointed
to p (Figure 3.1d). As before four steps are executed:
1. New node is created (Figure 3.1e)
2. The constructor assign the number 8 to the info
member of this node (Figure 3.1f)
3. The constructor assign null to the next member.
(Figure 3.1g).
4. 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.1
13
 Problem :
 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.
1. If you missed a node in the chain, then a wrong
assignment is made
2. The flexibility of using linked lists is diminished .
14
 So, 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).
Figure 3.3 a singly list of integers
15
 Returen to figure 3.2 page 79.
16
Operations
 Insert
 At the Beginning (before Head)
 At End (after Tail)
 middle
 Delete
 At the Beginning (before Head)
 At End (after Tail)
 middle
 Special cases: Empty List, single-node list
 Search
17
3.1.1 Insertion
1.
inserting a new node at the beginning of a singly linked list
Figure 3.4
18
3.1.1 Insertion (cont’)
2.
inserting a new node at the end of a singly linked list
Figure 3.5
19
Insert At the beginning
Insert at the end
addToTail(int el)
{
if (tail != 0)
head = new IntSLLNode(el,head);
{ // if list is not empty;
if (tail == 0) // if list is empty
tail->next = new
IntSLLNode(el);
tail = head;
tail = tail->next; }
}
else { // if list is empty;
head = tail = new
IntSLLNode(el); }
}
addToHead(int el)
{
Complexity is O(1)
20
Complexity is O(1)
3.1.2 Deletion
1.
Deleting a node at the beginning of the list and returning
the value stored in it.
Figure 3.6
21
 There are two special cases to consider :
1. Attempt to remove a node from an empty
linked list .
1. One way is to use assert statement( with the
function isEmpty() ).
2. Or throw an exception by using throw clause(
and having a matching try-catch clause).
2. The list has one node to remove
1. The list becomes empty and tail + head set to
null.
22
3.1.2 Deletion (cont’)
2.
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
Figure 3.7
24
Cont.Figure 3.7
25
 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)
26
Delete from Head
Delete from Tail
int IntSLList::deleteFromHead() { int IntSLList::deleteFromTail() {
int e1 = head->info;
int e1 = tail->info;
IntSLLNode *tmp= head;
if (head==tail) {// one node
if (head==tail) // 1node only
delete head;
head = tail = 0;
head = tail = 0; }
else head = head->next;
else {
delete tmp;
IntSLLNode *tmp;
return e1; }
Complexity is O(1)
27
for (tmp=head; tmp->next != tail; )
tmp = tmp->next;
delete tail;
tail=tmp;
tmp->next=0; }
return e1; }
Complexity is O(n)
Finding 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 node’s 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
Figure 3.8
29
30
Complexity of deleting a node with certain
integer:
 Best Case : O(1)
 Worst Case: O(1)
 Average Case:
0+1+⋯…+(𝑛−1)
𝑛
31
=
𝑛−1
2
= 𝑂(𝑛)
Other deletion cases :
1.
2.
Remove a node from an empty list – function is exited.
Delete a node from a one-node linked list - head =tail
=null.
3.
4.
5.
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 .
6.
32
Last , the one we discussed, delete a node with a
number that is in the list
3.1.3 Search
 The searching operation does not modify linked
lists, it just scans the list to find a number.
1. If tmp is not null, el was found and true is returned .
2. If tmp is null, the search was unsuccessful and false is returned.
33
3.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
.
Figure 3.9
34
 Insert a node to the end of Doubly linked list :
1. A new node is created, and then its three
data members are initialized :
1. info member to a number,
2. next member to null,
3. prev member to value of tail
2. tail is set to point to the new node
3. The next member of the predecessor is set
to point to the new node
Complexity is O(1)
35
Figure 3.11
36
 Delete a node to the end of Doubly linked list:
1. A temporary variable (ex. el) is set to the value
in the node.
2. tail is set to its predecessor.
3. The last node is deleted.
4. The next member of the tail node is set to
null.
5. 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
el = 10;
Figure 3.12
38
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.
Figure 3.13
39
 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.
Complexity is O(1)
40
Insert a node at the front of
CSLL
Insert a node at the end of
CSLL
Figure 3.14
41
 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)
42
Figure 3.15
Complexity Analysis
Complete the missing cells
43
Operations
Insert
At Beginning (before Head)
At End (after Tail)
middle
Delete
At Beginning (before Head)
At End (after Tail)
SLL
middle
Search
O(n)
O(n)
DLL
CLL
O(1)
O(1)
0(1)
O(n)
O(1) O(n)