UNIT I LINEAR DATA STRUCTURES – LIST

CS8391-DATA STRUCTURES
Unit - I
Dr. A. Kathirvel
Professor, Dept of CSE, M N M J E C, Chennai

UNIT I LINEAR DATA STRUCTURES – LIST
 Abstract Data Types (ADTs) List ADT array based
implementation – linked list implementation –– singly
linked lists- circularly linked lists- doubly-linked lists –
applications of lists –Polynomial Manipulation – All
operations (Insertion, Deletion, Merge, Traversal)
 TEXTBOOKS:
1. Mark Allen Weiss, “Data Structures and Algorithm
Analysis in C”, 2nd Edition, Pearson Education,1997.
2. Reema Thareja, “Data Structures Using C”, Second Edition,
Oxford University Press, 2011
12 July 2018
2
MNMJEC, Chennai - 600 097

12 July 2018MNMJEC, Chennai - 600 097
3
Topics
 Introduction
 Definitions
 Classification of Data Structures
 Arrays and Linked Lists
 Abstract Data Types [ADT]
 The List ADT
 Array-based Implementation
 Linked List Implementation
 Doubly Linked Lists

4
Data Structure [Wikipedia]
 Data Structure is a particular way of storing and
organizing data in a computer so that it can be used
efficiently.
 Different kinds of data structures are suited to different
kinds of applications.
 Storing and retrieving can be carried out on data
stored in both main memory and in secondary memory.

5
Merriam-Webster's Definition
 Way in which data are stored for efficient search and
retrieval.
 The simplest data structure is the one-dimensional
(linear) array.
 Data items stored non-consecutively in memory may be
linked by pointers.
 Many algorithms have been developed for storing data
efficiently

6
Algorithms [Wikipedia]
 An algorithm is a step-by-step procedure for
calculations.
 An algorithm is an effective method expressed as a
finite list of well-defined instructions for calculating a
function.
 The transition from one state to the next is not
necessarily deterministic; some algorithms incorporate
random input.

7
Merriam-Webster's Definition
 Procedure that produces the answer to a question or
the solution to a problem in a finite number of steps.
 An algorithm that produces a yes or no answer is called
a decision procedure; one that leads to a solution is a
computation procedure.
 Example: A mathematical formula and the instructions in
a computer program

8
Data Structure Classification
 Primitive / Non-primitive
 Basic Data Structures available / Derived from Primitive
Data Structures
 Homogeneous / Heterogeneous
 Elements are of the same type / Different types
 Static / Dynamic
 memory is allocated at the time of compilation / run-time
 Linear / Non-linear
 Maintain a Linear relationship between element

9
ADT - General Concept
 Problem solving with a computer means processing
data
 To process data, we need to define the data type and
the operation to be performed on the data
 The definition of the data type and the definition of the
operation to be applied to the data is part of the idea
behind an Abstract Data Type (ADT)

10
ADT - General Concept
 The user of an ADT needs only to know that a set of
operations are available for the data type, but does
not need to know how they are applied
 Several simple ADTs, such as integer, real, character,
pointer and so on, have been implemented and are
available for use in most languages

11
Data Types
 A data type is characterized by:
 A set of values
 A data representation, which is common to all these values,
and
 A set of operations, which can be applied uniformly to all
these values

12
Primitive Data Types
 Languages like „C‟ provides the following primitive
data types:
 boolean
 char, byte, int
 float, double
 Each primitive type has:
 A set of values
 A data representation
 A set of operations
 These are “set in stone”.

13
ADT Definition [Wikipedia]
 In computer science, an abstract data type (ADT) is a
mathematical model for a certain class of data
structures that have similar behavior.
 An abstract data type is defined indirectly, only by the
operations that may be performed on it and by
mathematical constraints on the effects (and possibly
cost) of those operations.

14
ADT Definition [Wikipedia]
 An ADT may be implemented by specific data types or
data structures, in many ways and in many
programming languages; or described in a formal
specification language.
 example, an abstract stack could be defined by three
operations:
 push, that inserts some data item onto the structure,
 pop, that extracts an item from it, and
 peek, that allows data on top of the structure to be
examined without removal.

15
Definition from techforum4you
 Abstract data types or ADTs are a mathematical
specification of a set of data and the set of operations
that can be performed on the data.
 They are abstract in the sense that the focus is on the
definitions and the various operations with their
arguments.
 The actual implementation is not defined, and does not
affect the use of the ADT.

16
ADT in Simple Words
 Definition:
 Is a set of operation
 Mathematical abstraction
 No implementation detail
 Example:
 Lists, sets, graphs, stacks are examples of ADT along
with their operations

17
Why ADT?
 Modularity
 divide program into small functions
 easy to debug and maintain
 easy to modify
 group work
 Reuse
 do some operations only once
 Easy to change the implementation
 transparent to the program

18
Implementing an ADT
 To implement an ADT, you need to choose:
 A data representation
 must be able to represent all necessary values of the ADT
 should be private
 An algorithm for each of the necessary operation:
 must be consistent with the chosen representation
 all auxiliary (helper) operations that are not in the contract
should be private
 Remember: Once other people are using it
 It‟s easy to add functionality

19
The List ADT
 The List is an
 Ordered sequence of data items called
elements
 A1, A2, A3, …,AN is a list of size N
 size of an empty list is 0
 Ai+1 succeeds Ai
 Ai-1 preceeds Ai
 Position of Ai is i
 First element is A1 called “head”
 Last element is AN called “tail”

20
Operations on Lists
 MakeEmpty
 PrintList
 Find
 FindKth
 Insert
 Delete
 Next
 Previous

21
List – An Example
 The elements of a list are 34, 12, 52, 16, 12
 Find (52) -> 3
 Insert (20, 4) -> 34, 12, 52, 20, 16, 12
 Delete (52) -> 34, 12, 20, 16, 12
 FindKth (3) -> 20

22
List - Implementation
 Lists can be implemented using:
 Arrays
 Linked List
 Cursor [Linked List using Arrays]

23
Arrays
 Array is a static data structure that represents a
collection of fixed number of homogeneous data items
or
 A fixed-size indexed sequence of elements, all of the
same type.
 The individual elements are typically stored in
consecutive memory locations.
 The length of the array is determined when the array is
created, and cannot be changed.

24
Arrays
 Any component of the array can be inspected or
updated by using its index.
 This is an efficient operation
 O(1) = constant time
 The array indices may be integers (C, Java) or other
discrete data types (Pascal, Ada).
 The lower bound may be zero (C, Java), one (Fortran),
or chosen by the programmer (Pascal, Ada)

25
Different Types of Arrays
 One-dimensional array: only one index is used
 Multi-dimensional array: array involving more than one
index
 Static array: the compiler determines how memory will
be allocated for the array
 Dynamic array: memory allocation takes place during
execution

26
One Dimensional Static Array
 Syntax:
 ElementType arrayName [CAPACITY];
 ElementType arrayName [CAPACITY] =
{ initializer_list };
 Example in C++:
 int b [5];
 int b [5] = {19, 68, 12, 45, 72};

27
Array Output Function
void display(int array[],int num_values)
{
for (int I = 0; i<num_values; i++)
cout<< array[i] << “ ”;
}

28
List Implemented Using Array

29
Operations On Lists
 We‟ll consider only few operations and
not all operations on Lists
 Let us consider Insert
 There are two possibilities:
 Ordered List
 Unordered List

30
Insertion into an Ordered List

31
Insertion in Detail

32
Insertion

33
Deletion

34
Find / Search
 Searching is the process of looking for a specific
element in an array
 For example, discovering whether a certain score
is included in a list of scores.
 Searching, like sorting, is a common task in
computer programming.
 There are many algorithms and data structures
devoted to searching.
 The most common one is the linear search.

35
Linear Search
 The linear search approach compares the given
value with each element in the array.
 The method continues to do so until the given
value matches an element in the list or the list is
exhausted without a match being found.
 If a match is made, the linear search returns the
index of the element in the array that matches the
key.
 If no match is found, the search returns -1.

36
Linear Search

37
Linear Search Function
int LinearSearch (int a[], int n, int key)
{
int i;
for(i=0; i<n; i++)
{
if (a[i] == key)
return i;
}
return -1;
}

38
Using the Function
 LinearSearch (a,n,item,loc)
 Here "a" is an array of the size n.
 This algorithm finds the location of the element "item"
in the array "a".
 If search item is found, it sets loc to the index of the
element; otherwise, it sets loc to -1
 index=linearsearch(array, num, key)

39
PrintList Operation
int myArray [5] = {19,68,12,45,72};
/* To print all the elements of the array
for (int i=0;i<5;i++)
{
printf("%d", myArray[i]);
}

40

41
Implementing Deletion

42
Deletion - Another Method

43
PrintList O(N)
Find
Insert O(N) (on avarage half
Delete needs to be moved)
FindKth
Next O(1)
Previous
Operations Running Times

44
Disadvantages of Using Arrays
 Need to define a size for array
 High overestimate (waste of space)
 insertion and deletion is very slow
 need to move elements of the list
 redundant memory space
 it is difficult to estimate the size of array

45
Linked List
 Series of nodes
 not adjacent in memory
 contain the element and a pointer to a node
containing its succesor
 Avoids the linear cost of insertion and deletion!

46
Singly Linked List

47
Doubly Linked List

48
Singly Linked List

49
Singly-linked List - Addition
 Insertion into a singly-linked list has two special cases.
 It's insertion a new node before the head (to the very
beginning of the list) and after the tail (to the very end
of the list).
 In any other case, new node is inserted in the middle of
the list and so, has a predecessor and successor in the
list.

50
Empty list case
 When list is empty, which
is indicated by (head ==
NULL) condition, the
insertion is quite simple.
 Algorithm sets both head
and tail to point to the
new node.

51
Add first
 In this case, new node is inserted right before the
current head node.

52
Add First - Step 1
 It can be done in two steps:
 Update the next link of the new node, to point to the current
head node.

53
Add First - Step 2
 Update head link to point to the new node.

54

55
Add last
 In this case, new node is inserted right after the current
tail node.
 Update the next link of the current tail node, to point to the
new node.
 Update tail link to point to the new node.

56

57
Insert - General Case
 In general case, new node is always inserted
between two nodes, which are already in the list.
Head and tail links are not updated in this case.
 We need to know two nodes "Previous" and "Next",
between which we want to insert the new node.
 This also can be done in two steps:
 Update link of the "previous" node, to point to the new node.
 Update link of the new node, to point to the "next" node.

58

59
Singly-linked List - Deletion
 There are four cases, which can occur while removing
the node.
 We have the same four situations, but the order of
algorithm actions is opposite.
 Notice, that removal algorithm includes the disposal of
the deleted node - unnecessary in languages with
automatic garbage collection (Java).

60
List has only one node
 When list has only one
node, that the head
points to the same node
as the tail, the removal is
quite simple.
 Algorithm disposes the
node, pointed by head
(or tail) and sets both
head and tail to NULL.

61
Remove First
 In this case, first node (current head node) is removed
from the list.
 Update head link to point to the node, next to the head.
 Dispose removed node.

62

63
Remove Last
 In this case, last node (current tail node) is removed
from the list. This operation is a bit more tricky, than
removing the first node, because algorithm should find
a node, which is previous to the tail first.
 It can be done in three steps:
 Update tail link to point to the node, before the tail. In
order to find it, list should be traversed first, beginning from
the head.
 Set next link of the new tail to NULL.

64

65
Remove - General Case
 In general case, node to be removed is always located
between two list nodes. Head and tail links are not
updated in this case.
 We need to know two nodes "Previous" and "Next", of
the node which we want to delete.
 Such a removal can be done in two steps:
 Update next link of the previous node, to point to the next
node, relative to the removed node.

66

67
Advantages of Using Linked Lists
 Need to know where the first node is
 the rest of the nodes can be accessed
 No need to move the elements in the list for
insertion and deletion operations
 No memory waste

68
Arrays - Pros and Cons
 Pros
 Directly supported by C
 Provides random access
 Cons
 Size determined at compile time
 Inserting and deleting elements is time
consuming

69
Linked Lists - Pros and Cons
 Pros
 Size determined during runtime
 Inserting and deleting elements is quick
 Cons
 No random access
 User must provide programming support

70
Application of Lists
 Lists can be used
 To store the records sequentially
 For creation of stacks and queues
 For polynomial handling
 To maintain the sequence of operations for do /
undo in software
 To keep track of the history of web sites visited

71
Why Doubly Linked List ?
 given only the pointer location, we cannot access its predecessor in
the list.
 Another task that is difficult to perform on a linear linked list is
traversing the list in reverse.
 Doubly linked list A linked list in which each node is linked to both
its successor and its predecessor
 In such a case, where we need to access the node that precedes a
given node, a doubly linked list is useful.

72
Doubly Linked List
 In a doubly linked list, the nodes are linked in both
directions. Each node of a doubly linked list contains
three parts:
 Info: the data stored in the node
 Next: the pointer to the following node
 Back: the pointer to the preceding node

73
Operations on Doubly Linked Lists
 The algorithms for the insertion and deletion operations
on a doubly linked list are somewhat more complicated
than the corresponding operations on a singly linked
list.
 The reason is clear: There are more pointers to keep
track of in a doubly linked list.

74
Inserting Item
 As an example, consider the Inserting an item.
 To link the new node, after a given node, in a singly
linked list, we need to change two pointers:
 newNode->next and
 location->next.
 The same operation on a doubly linked list requires four
pointer changes.

75
Singly Linked List Insertion

76
Doubly Linked List Insertion

77
The Order is Important

78
Doubly Linked List - Deletion
 One useful feature of a doubly linked list is its
elimination of the need for a pointer to a node's
predecessor to delete the node.
 Through the back member, we can alter the next
member of the preceding node to make it jump over
the unwanted node.
 Then we make the back pointer of the succeeding node
point to the preceding node.

79
Doubly Linked List - Deletion

80
Special Cases of Deletion
 We do, however, have to be careful about the end
cases:
 If location->back is NULL, we are deleting the first node
 if location->next is NULL, we are deleting the last node.
 If both location->back and location->next are NULL, we
are deleting the only node.

Circular Linked Lists
 In linear linked lists if a list is traversed (all the
elements visited) an external pointer to the list must
be preserved in order to be able to reference the
list again.
 Circular linked lists can be used to help the traverse
the same list again and again if needed. A circular
list is very similar to the linear list where in the
circular list the pointer of the last node points not
NULL but the first node.

A Linear Linked List

 In a circular linked list there are two methods to know
if a node is the first node or not.
 Either a external pointer, list, points the first node or
 A header node is placed as the first node of the
circular list.
 The header node can be separated from the others
by either heaving a sentinel value as the info part or
having a dedicated flag variable to specify if the
node is a header node or not.

PRIMITIVE FUNCTIONS IN
CIRCULAR LISTS
 The structure definition of the circular linked lists
and the linear linked list is the same:
struct node{
int info;
struct node *next;
};
typedef struct node *NODEPTR;

CIRCULAR LISTS
The delete after and insert after functions of the linear lists and the circular lists are
almost the same.
The delete after function: delafter( )
void delafter(NODEPTR p, int *px)
{
NODEPTR q;
if((p == NULL) || (p == p->next)){ /*the empty list
contains a single node and may be pointing itself*/
printf(“void deletionn”);
exit(1);
}
q = p->next;
*px = q->info; /*the data of the deleted node*/
p->next = q->next;
freenode(q);
}

CIRCULAR LISTS
The insertafter function: insafter( )
void insafter(NODEPTR p, int x)
{
NODEPTR q;
if(p == NULL){
printf(“void insertionn”);
exit(1);
}
q = getnode();
q->info = x; /*the data of the inserted node*/
q->next = p->next;
p->next = q;
}

CIRCULAR LIST with header node
The header node in a circular list can be specified by a
sentinel value or a dedicated flag:
Header Node with Sentinel: Assume that info part contains
positive integers. Therefore the info part of a header
node can be -1. The following circular list is an example
for a sentinel used to represent the header node:
struct node{
int info;
struct node *next;
};

Header Node with Flag: In this case a extra variable
called flag can be used to represent the header node. For
example flag in the header node can be 1, where the
flag is 0 for the other nodes.
struct node{
int flag;
int info;
struct node *next;
};

Example
 Consider a circular linked list with a header node,
where each node contains the name, account
number and the balance of a bank customer. The
header node contains a sentinel account number to
be -99.
 (a) Write an appropriate node structure definition
for the circular linked list.
 (b) Write a function to display the full records of
the customers with negative balance.

a) struct node{
char Name[15]; int AccNo;
float Balance;
struct node *next;
};
b) Assume that the list pointer points the header with the sentinel account number -99.
void DispNegBalanca(NODEPTR *plist)
{
NODEPTR p;
p=*plist;
if(p == NULL){
printf(“There is no list!n”);
exit(1);
}
p=p->next;
while(p->AccNo!=-99){
if(p->Balance < 0.0)
printf(“The Customer Name:%snThe Account No:%dnThe
Balance:%.2fn”, p->Name, p->AccNo, p->Balance);
p=p->next;
}
}

Example
Write a function that returns the average of the
numbers in a circular list. Assume that the following node
structure is used, where the flag variable is 1 for the
header node and 0 for all the other nodes.
struct node{
int flag;
float info;
struct node *next;
};

float avList(NODEPTR *plist)/*assume that plist points the
header node*/
{
int count=0;
float sum =0.0;
NODEPTR p;
p=*plist;
if((p == NULL)){
printf(“Empty listn”);
exit(1);
}
do{
sum=sum + p->info;
p =p->next;
count++;
}while(p->flag !=1);
return sum/count;
}

Polynomials (1/9)
 Representing Polynomials As Singly Linked Lists
 The manipulation of symbolic polynomials, has a classic example of list
processing.
 In general, we want to represent the polynomial:
 Where the ai are nonzero coefficients and the ei are nonnegative
integer exponents such that
em-1 ＞ em-2 ＞ … ＞ e1 ＞ e0 ≧ 0 .
 We will represent each term as a node containing coefficient and
exponent fields, as well as a pointer to the next term.
01
01)( ee
m xaxaxA m
 


Polynomials (2/9)
 Assuming that the coefficients are integers, the type
declarations are:
typedef struct poly_node *poly_pointer;
typedef struct poly_node {
int coef;
int expon;
poly_pointer link;
};
poly_pointer a,b,d;
 Draw poly_nodes as:
coef expon link
123 814
 xxa
b x x x  8 3 1014 10 6

Polynomials (3/9)
 Adding Polynomials
 To add two polynomials,we examine their terms starting at
the nodes pointed to by a and b.
 If the exponents of the two terms are equal
1. add the two coefficients
2. create a new term for the result.
 If the exponent of the current term in a is less than b
1. create a duplicate term of b
2. attach this term to the result, called d
3. advance the pointer to the next term in b.
 We take a similar action on a if a->expon > b->expon.
 Figure 4.12 generating the first three term of
d = a+b (next page)

Operating On Polynomials
 With linked lists, it is much easier to perform
operations on polynomials such as adding and
deleting.
 E.g., adding two polynomials a and b
a.first 143 2 8 1 0 0
b.first 148 -3 10 10 6 0
p
q
(i) p->exp == q->exp
c.first 11 14 0

a.first 143 2 8 1 0 0
b.first 148 -3 10 10 6 0
p
q
(ii) p->exp < q->exp
c.first 11 14 0 -3 10 0

a.first 143 2 8 1 0 0
b.first 148 -3 10 10 6 0
p
q
(iii) p->exp > q->exp
c.first 11 14 0 -3 10 2 8 0

Polynomials
(5/9)
 Add two
polynomials

Polynomials (6/9)
 Attach a node to the end of a list
void attach(float coefficient, int exponent, poly_pointer *ptr){
/* create a new node with coef = coefficient and expon = exponent, attach it to the
node pointed to by ptr. Ptr is updated to point to this new node */
poly_pointer temp;
temp = (poly_pointer) malloc(sizeof(poly_node));
/* create new node */
if (IS_FULL(temp)) {
fprintf(stderr, “The memory is fulln”);
exit(1); }
temp->coef = coefficient; /* copy item to the new node */
temp->expon = exponent;
(*ptr)->link = temp; /* attach */
*ptr = temp; /* move ptr to the end of the list */
}

Polynomials (7/9)
 Analysis of padd
1. coefficient additions
0  additions  min(m, n)
where m (n) denotes the number of terms in A (B).
2. exponent comparisons
extreme case:
em-1 > fm-1 > em-2 > fm-2 > … > e1 > f1 > e0 > f0
m+n-1 comparisons
3. creation of new nodes
extreme case: maximum number of terms in d is m+n m + n
new nodes
summary: O(m+n)
))(())(( 0101
0101
ff
n
ee
m xbxbxBxaxaxA nm
 
 

Polynomials (8/9)
 A Suite for Polynomials
e(x) = a(x) * b(x) + d(x)
poly_pointer a, b, d, e;
...
a = read_poly();
b = read_poly();
d = read_poly();
temp = pmult(a, b);
e = padd(temp, d);
print_poly(e);
temp is used to hold a partial result.
By returning the nodes of temp, we
may use it to hold other polynomials
read_poly()
print_poly()
padd()
psub()
pmult()

Polynomials (9/9)
 Erase Polynomials
 erase frees the nodes in temp
void erase (poly_pointer *ptr){
/* erase the polynomial pointed to by ptr */
poly_pointer temp;
while ( *ptr){
temp = *ptr;
*ptr = (*ptr) -> link;
free(temp);
}
}

Questions and Discussion
12 July 2018
109
MNMJEC, Chennai - 600 097

UNIT I LINEAR DATA STRUCTURES – LIST

More Related Content

What's hot (20)

Similar to UNIT I LINEAR DATA STRUCTURES – LIST (20)

More from Kathirvel Ayyaswamy (20)

Recently uploaded (20)

UNIT I LINEAR DATA STRUCTURES – LIST