LIST( using dynamic memory allocation)

1
LIST( using dynamic memory allocation)
2
Introduction

• We need dynamic Memory Allocation, when the data
  is dynamic in nature.
• That is, the number of data items keeps on
  changing during execution of the program.
• Such situations can be handled using dynamic data
  structures in conjunction with dynamic memory
  management techniques.
• Dynamic data structures provides flexibility in
  adding, deleting or rearranging items at runtime.
  

3
Dynamic Memory Allocation

• Dynamic memory management techniques allows us to
  allocate additional space or release unwanted
  space at runtime.
• The process of allocating memory at runtime is
  called Dynamic Memory Allocation.
• There are four library routines in C known as
  Memory Management Functions can be used for
  allocating and freeing memory during program
  execution.

4
Memory Management Functions in C

• malloc- allocates requested size of bytes and
  returns a pointer to the first byte of the
  allocated space.
• Calloc Allocates space for an array of elements
  ,initializes them to zero then returns a pointer
  to memory.
• Free-frees previously allocated space.
• Realloc modifies the size of previously
  allocated space.

5
Dynamic Memory Allocation in JAVA

• Java does not support explicit dynamic memory
  allocation and deallocation because a
  sophisticated memory management system is part of
  the JVM that executes Java programs.
• As part of the memory management system, Java
  uses a mechanism known as the garbage collector
  that periodically monitors a Java program while
  it is running.
• Whenever a variable goes out of scope it is
  eligible to be garbage collected, meaning that
  memory assigned to the variable is deallocated
  and made available for use by some other part of
  the program.
• A Java programmer never has to worry about
  manually deallocating memory.

6
Linked List

• A linked list is one of the fundamental data
  structures, and can be used to implement other
  data structures.
• It consists of a sequence of nodes, each
  containing arbitrary data fields and one or two
  references ("links") pointing to the next and/or
  previous nodes.
• A linked list is a self-referential data type
  because it contains a pointer or link to another
  data of the same type.

7
Contd..

• Several different types of linked list exist
  singly-linked lists, doubly-linked lists, and
  circularly-linked lists.
• Linked lists can be implemented in most
  languages.
• Procedural or object-oriented languages such as
  C, C, and Java typically rely on mutable
  references to create linked lists.

8
Singly-linked list

• The simplest kind of linked list is a
  singly-linked list (or slist for short)
• which has one link per node. This link points to
  the next node in the list, or to a null value or
  empty list if it is the final node.

9
Doubly Linked List

• A more sophisticated kind of linked list is a
  doubly-linked list or two-way linked list.
• Each node has two links one points to the
  previous node, or points to a null value or empty
  list if it is the first node and one points to
  the next, or points to a null value or empty list
  if it is the final node.

10
Circular-Linked List

• In a circularly-linked list, the first and final
  nodes are linked together.
• This can be done for both singly and doubly
  linked lists.
• To traverse a circular linked list, you begin at
  any node and follow the list in either direction
  until you return to the original node.
• Viewed another way, circularly-linked lists can
  be seen as having no beginning or end.

11
Linked List
Header
a1
a2
an
a3
Double Linked List
a1
a2
a3
12

• Inserting
• Whenever we insert, we create a new node
• Inserting an element X after node a1

a0
a1
an
a2
1
2
X
13
Deleting an element
p
temp
a0
a1
an
a2
While deleting element a1
Thus while printing a list. It prints a2 after a1
Tempp-gtnext P-gtnexttemp-gtnext Delete temp
14
List as Abstract data type

• List as a interface, implementation part is
  hidden.
• Implementation could be using arrays or linked
  list.
• ArrayList implements list using Arrays.
• LinkedList implements List using Dynamic Memory
  Allocation i.e. LinkedList.

15
Operations on List

• Types of Operations on list
• Insertion
• Deletion
• Search
• Print
• Isempty

16
List Interface

• interface List
• public boolean add(Object data)
• public boolean remove(Object data)
• public int indexOf(Object data)
• public Object get(int index)
• public int lastIndexOf(Object data)
• public boolean set(int index,Object data)
• public Object subList(int fromIndex,int
  toIndex)

17
Link( structure of node)

• class Link
• public Object value// data item
• public Link next // next Link in list
• public Link(Object dd) // constructor
• value dd // ('next' is
  automatically
• // set to null)
• public void displayLink() // display ourself
• System.out.print(value)
• // end class Link

18
LinkedListDemo(implements ListDemo)

• class LinkListDemo implements ListDemo
• private Link first//first link/node.
• static int size0
• public LinkListDemo()//constructor
• first null
• //all this functions implementation part is
  written
• public boolean add(Object data)
• public boolean remove(Object data).
• public int indexOf(Object data).
• public Object get(int index).

19
Contd..

• public int lastIndexOf(Object data).
• public boolean set(int index,Object data)
• public Object subList(int fromIndex,int
  toIndex)
• public void addFirst(Object data)..
• public void addLast(Object data)..
• public void removeFirst(Object data)..
• public void removeLast(Object data)..

20
Add(element)..

• Appends the element to the end of the list
• public boolean add(Object val)
• Link current first // search for Link
• Link newLink new Link(val)
• if(firstnull)
• newLink.next first // newLink --gt old first
• first newLink // first --gt newLink
• size
• else
• while(current.next!null)//traveserse till the
  end of list
• currentcurrent.next
• current.nextnewLink//point last element to
  the new link

21
Remove(element)..

• Removes the first occurrence of the element from
  the list.
• public boolean remove(Object val)
• Link current first
• Link previous first
• while(!val.equals(current.value))
• if(current.next null)
• System.out.println("element not found")
• return false
• else
• previous current // go to next
  Link
• current current.next
• // found it

22
addFirst(element)

• Inserts elements at the beginning of the list.
• public void addFirst(Object data)
• Link newLink new Link(data)
• newLink.next first // newLink --gt old
  first
• first newLink // first --gt newLink

23
The LinkedList Class

• Part of the Java API
• Implements the List interface using a
  double-linked list

24
LinkedList

• Linked list implementation of the List interface.
• Implements all optional list operations, and
  permits all elements (including null).
• In addition to implementing the List interface,
  the LinkedList class provides uniformly named
  methods to get, remove and insert an element at
  the beginning and end of the list.
• These operations allow linked lists to be used as
  a stack, queue, or double-ended queue (deque).
• This class is a member of the Java Collections
  Framework.

25
Operations in LinkedList(ADT)

• Implements all the operations in List Interface.
• Additional operations this class provides are.
• addFirst(element)-Inserts the given element at
  the beginning of this list.
• addLast(element)-Appends the given element to the
  end of this list. (Identical in function to the
  add method)
• getFirst() -Returns the first element in this
  list.
• getLast()-Returns the last element in this list.
• removeFirst() -Removes and returns the first
  element from this list.
• removeLast()-Removes and returns the last element
  from this list.
• And more.

26
References

• http//en.wikipedia.org/wiki/Linked_list
• Data Structure by Yashwanth Kanethkar.
• Data Structures and Algorithms in Java, Robert
  Lafore.
• http//www.thescripts.com/forum/thread17589.html
• http//forum.java.sun.com/thread.jspa?threadID697
  879messageID4051594
• http//www.bearcave.com/software/garbage.htm

27
ThankYou