dlinkedlistt.java

labs to practise link list and double link list

package myList;

public class DLinkedListT
{
	
// really simple, contains just one reference to head element	
	
DElemT head;
DElemT tail;

DLinkedListT()	//simple constructor
 {
	System.out.println("constructing new DoublyLinkedList for Title");
	head = new DElemT();
	tail = new DElemT();
	head=null;
	tail=head;
 }

//*********************************************

public boolean emptyList()
 {
  return head == null;
 }

//*********************************************

public void setHead(DElemT h)
 {
  head = h;
  tail = h;
 }
public void insert(DElemT d)
{
	tail.next = d;
	d.previous = tail;
	d.next = head;
	head.previous =d;
	tail = d;
}

public void delete(DElemT d)
{
	d.previous.next = d.next;
	d.next.previous = d.previous;
}
//*********************************************
/*
public DElemT getHead()
 {
  return head;
 }
*/
//*********************************************
/*
public void insertFirst(DElemT el)
 {
  el.setNext(head);
  el.setPrevous(head.previous);
  head.previous = el;
  head = el;
 }
*/
//*********************************************

/*
public DElemT lastNode()
 {
  // returns last DElemTent of list, null if empty list	

  DElemT l;
  if (emptyList()) return null;
  l = head;
  while (l.getNext() != null) l = l.getNext();
  return l;
 }
*/
//*********************************************

/*
public void insertLast(DElemT l)
 {
  // for an empty list insertlast is insertfirst!
	
  if (emptyList()) 
   insertFirst(l);
  else		//define the next-reference of the last DElemTent
	  {
	  	tail.next = l;
	  	l.previous = tail;
	  	tail = l;
	  	l.next = head;
	  	head.previous = tail;
	  }
 }
*/
//*********************************************
/*
public void removeFirst(DElemT d)
 {
  //pre: list not empty!
  //post: first DElemTent removed and returned in d
	
  if (!emptyList())
  {
   d.setTitle(head.getTitle());
   d.setNext(head.getNext());
   head = head.getNext();
  }
  else System.out.println("removeFirst: Error: empty list!");
*/
//*********************************************
/*
public void removeLast(DElemT d)
 {
  //pre: list not empty!
  //post: last DElemTent removed and returned in d
		
  DElemT l, l1;
  
  if (!emptyList())
  {l = head; l1 = l;
   if (l.getNext() == null)
    {
	 head = null;  
    }
   else
    {   
     while (l.getNext()!= null)
      {
	   l1 = l; l = l.getNext();	 
      }
     l1.setNext(null);
    }
    d.setTitle(l.getTitle());
    d.setNext(null);
  }
  else System.out.println("removeLast: Error: empty list!");
 }
*/
//*********************************************
/*
public DLinkedListT copyList()
 {
  //returns the copy of the list as theNewList	
	
  DLinkedListT theNewList;
  DElemT copy, old;
  
  theNewList = new DLinkedListT(); // make a new list
  if (!emptyList())
  {
   copy = new DElemT(); 
   theNewList.setHead(copy);	//define the new head	  
   old = head;	 
   copy.setTitle(old.getTitle()); //copy the title
   while(old.getNext() != null)
   {
	copy.setNext(new DElemT());	//there is another DElemTent to copy
								//next is set to null in the constructor!
	copy = copy.getNext();		//move to the next destination
	old = old.getNext();		//move to next source DElemTent
	copy.setTitle(old.getTitle());// copy the title
   }
  }
  return theNewList;
 }
*/
//*********************************************
/*
public DElemT first()
{
 //pre: list not empty
 //post: list unchanged head DElemTent returned	
 if (!emptyList()) System.out.println("First: Error: Empty List!!");
 return head;
}
*/
//*********************************************
/*
public DLinkedListT tail()
{
 //pre: list not empty
 //post: list unchanged, reference to tail returned
	
 DLinkedListT l;	
 if (emptyList()) 
 {System.out.println("Tail: Error: Empty List!!");
  return null; 
 }
 else 
 {
  l = new DLinkedListT();
  l.setHead(head.getNext());
  return l;
 }
}
*/
/*
public DElemT lookForTitle(String t)
{
 //pre: list not empty.
 //post: list unchanged, if found elent with matching key returned
 //                      if not found return null
	
 DElemT l;	
 if (emptyList())
 {
  System.out.println("lookForTitle: Error: Empty List!!");
  return null;
 }
 else
 {
  l = head;
  while ((l != null) && (l.getTitle().equals(t) == false))
   l = l.getNext();
  if (l != null)	//found it
  return l;
  else				//too bad
  {
   System.out.println("lookForTitle Error: Title not found!!");
   return null;
  }
 }
}
*/
}