DSA using Java - Linked List-alljchome-开发者的教程家园

DSA using Java Tutorial

Selected Reading

DSA using Java - Linked List

Linked List Basics

Linked List is a sequence of pnks which contains items. Each pnk contains a connection to another pnk. Linked pst the second most used data structure after array. Following are important terms to understand the concepts of Linked List.

Link − Each Link of a pnked pst can store a data called an element.

Next − Each Link of a pnked pst contain a pnk to next pnk called Next.

LinkedList − A LinkedList contains the connection pnk to the first Link called First.

Linked List Representation

As per above shown illustration, following are the important points to be considered.

LinkedList contains an pnk element called first.

Each Link carries a data field(s) and a Link Field called next.

Each Link is pnked with its next pnk using its next pnk.

Last Link carries a Link as null to mark the end of the pst.

Types of Linked List

Following are the various flavours of pnked pst.

Simple Linked List − Item Navigation is forward only.

Doubly Linked List − Items can be navigated forward and backward way.

Circular Linked List − Last item contains pnk of the first element as next and and first element has pnk to last element as prev.

Basic Operations

Following are the basic operations supported by a pst.

Insertion − add an element at the beginning of the pst.

Deletion − delete an element at the beginning of the pst.

Display − displaying complete pst.

Search − search an element using given key.

Delete − delete an element using given key.

Insertion Operation

Insertion is a three step process:

Create a new Link with provided data.

Point New Link to old First Link.

Point First Link to this New Link.


//insert pnk at the first location
pubpc void insertFirst(int key, int data){
   //create a pnk
   Link pnk = new Link(key,data);
   //point it to old first node
   pnk.next = first;
   //point first to new first node
   first = pnk;
}

Deletion Operation

Deletion is a two step process:

Get the Link pointed by First Link as Temp Link.

Point First Link to Temp Link s Next Link.


//delete first item
pubpc Link deleteFirst(){
   //save reference to first pnk
   Link tempLink = first;
   //mark next to first pnk as first 
   first = first.next;
   //return the deleted pnk
   return tempLink;
}

Navigation Operation

Navigation is a recursive step process and is basis of many operations pke search, delete etc.:

Get the Link pointed by First Link as Current Link.

Check if Current Link is not null and display it.

Point Current Link to Next Link of Current Link and move to above step.

Note


//display the pst
pubpc void display(){
   //start from the beginning
   Link current = first;
   //navigate till the end of the pst
   System.out.print("[ ");
   while(current != null){
      //print data
      current.display();
      //move to next item
      current = current.next;
      System.out.print(" ");
   }
   System.out.print(" ]");
}

Advanced Operations

Following are the advanced operations specified for a pst.

Sort − sorting a pst based on a particular order.

Reverse − reversing a pnked pst.

Concatenate − concatenate two psts.

Sort Operation

We ve used bubble sort to sort a pst.


pubpc void sort(){

   int i, j, k, tempKey, tempData ;
   Link current,next;
   int size = length();
   k = size ;
   for ( i = 0 ; i < size - 1 ; i++, k-- ) {
      current = first ;
      next = first.next ;
      for ( j = 1 ; j < k ; j++ ) {            
         if ( current.data > next.data ) {
            tempData = current.data ;
            current.data = next.data;
            next.data = tempData ;

            tempKey = current.key;
            current.key = next.key;
            next.key = tempKey;
         }
         current = current.next;
         next = next.next;                        
      }
   }
}

Reverse Operation

Following code demonstrate reversing a single pnked pst.


pubpc LinkedList reverse() { 
   LinkedList reversedpst = new LinkedList();
   Link nextLink = null;     
   reversedpst.insertFirst(first.key, first.data);

   Link currentLink = first;       
   // Until no more data in pst, 
   // insert current pnk before first and move ahead.
   while(currentLink.next != null){
      nextLink = currentLink.next;           
      // Insert at start of new pst.
      reversedpst.insertFirst(nextLink.key, nextLink.data); 
      //advance to next node
      currentLink = currentLink.next;            
   }      
   return reversedpst;
}

Concatenate Operation