Survey
* Your assessment is very important for improving the workof artificial intelligence, which forms the content of this project
Download 1LinkedList
Transcript
LIST( using dynamic
memory allocation)
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.
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.
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.
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.
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.
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.
Singly-linked list
The simplest kind of linked list is a singlylinked 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.
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.
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.
Linked List
Header
a2
a1
a3
an
Double Linked List
a1
a2
a3
Inserting
Whenever we insert, we create a new node
Inserting an element X after node a1
a0
a1
a2
2
1
X
an
Deleting an element
p
a0
temp
a1
a2
While deleting
element a1
Thus while printing a list. It prints a2 after a1
Temp=p->next;
P->next=temp->next;
Delete temp;
an
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.
Operations on List
Types of Operations on list
Insertion
Deletion
Search
Print
Isempty
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);
}
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)
} // end class Link
public void displayLink() // display ourself
{
System.out.print(value+”=“);
}
LinkedListDemo(implements
ListDemo)
class LinkListDemo implements ListDemo
{
private Link first;//first link/node.
static int size=0;
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){….}
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){..}
}
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(first==null)
{
newLink.next = first; // newLink --> old first
first = newLink; // first --> newLink
size++;
}
else
{
while(current.next!=null)//traveserse till the end of list
{
current=current.next;
}
current.next=newLink;//point last element to the new link
}
Size++;
return true;//return true when the element is inserted.
}
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
if(current == first) // if first Link,
first = first.next; // change first
else // otherwise,
previous.next = current.next; // bypass it
size--;
return true;
}
addFirst(element)
Inserts elements at the beginning of the
list.
public void addFirst(Object data)
{
Link newLink = new Link(data);
newLink.next = first; // newLink --> old first
first = newLink; // first --> newLink
}
The LinkedList Class
Part of the Java API
Implements the List interface using a
double-linked list
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.
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….
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/thread1
7589.html
http://forum.java.sun.com/thread.jspa?th
readID=697879&messageID=4051594
http://www.bearcave.com/software/garba
ge.htm
