how to sort both numerically and alphabetically in a doubly linked list

I want to make a doubly linked list that works with a two step sorting algorithm, first of all, we have some movies on the list. These movies will be sorted by year in the list (each new data will be sorted as well), if the years are the same, those years will be sorted alphabetically.

public static Node insertionSort(Node headRef) {
		
	    Node sorted = null;

	    Node current = headRef;
	    
	    while (current != null) {
	    	
	        Node next = current.next;

	        current.prev = current.next = null;
	 
	        sorted = sortedInsert(sorted, current);
	 
	        current = next;
	    	
	    }
	   
	    headRef = sorted;
	     
	    return headRef;
		
		
	}

public static Node sortedInsert(Node headRef, Node newNode) {
		
		 Node current;
		 
		 if (headRef == null) {
			 
			 headRef = newNode; 
		 } else if ((headRef).movie.releaseDate > newNode.movie.releaseDate) {
			 
			 newNode.next = headRef;
			 newNode.next.prev = newNode;
		     headRef = newNode;
		     
		} else if ((headRef).movie.releaseDate == newNode.movie.releaseDate) {

		
			int i = 0;
			boolean permission = true;
			
			do {
				

				char character = headRef.movie.movieName.charAt(i);
				int value = character;
				
				char character2 = newNode.movie.movieName.charAt(i);
				int value2 = character2;
				
				if(value > value2) {
					
					 newNode.next = headRef;
					 newNode.next.prev = newNode;
				     headRef = newNode;
				     
				     permission = false;
					
				} else if(value == value2) {
					i++;
					
				} 
				
				
			} while(permission);
		
		}
		
		 else {
			
			current = headRef;
		
		    while (current.next != null && current.next.movie.releaseDate < newNode.movie.releaseDate)
		            current = current.next;
		
		    newNode.next = current.next;

		    if (current.next != null)
		    	newNode.next.prev = newNode;
		 
		   current.next = newNode;
		   newNode.prev = current;
		   
		}
		    return headRef;

	}

First, I did some research on the internet, then I wrote two methods. actually the "else if ((headRef).movie.releaseDate == newNode.movie.releaseDate)" part of the method is mine. Before writing this section I was getting the following results.

1997 Titanic

1997 Fast & Furious

1999 The Matrix

2014 The Hobbit: The Battle of the Five Armies

2014 Interstellar

After my correction, I got the following results.

1997 Titanic

1999 The Matrix

2014 The Hobbit: The Battle of the Five Armies

2014 Interstellar

A movie disappeared and they are still not in alphabetical order. This is very difficult for me, I'm new.What can I do to solve this.

I think the issue is at the final else because you don't apply the alphabetical order when you check the releaseDate.

To unify the comparison in one place it is better to let the Movie class to implement Comparable<Movie> which defines a compareTo method, this will let you use the same conditions everywhere

Comparable marks the object that it can be compared with other objects based on the compareTo function which returns:

• 0 if the two objects are equal
• negative number if the first object is smaller than the second one
• positive number if the first object is larger than the second one

And in this function you can define your own logic of which fields you can compare

class Movie implements Comparable<Movie>{

    ...

    @Override
    public int compareTo(Movie o) {
      if (releaseDate > o.releaseDate) {
        return 1;
      } else if (releaseDate < o.releaseDate) {
        return -1;
      }
      // Alphabetical order.
      return movieName.compareTo(o.movieName);
    }
}

And to simplify the code a bit this is another version of your code:

public static Node sortedInsert(Node headRef, Node newNode) {
    if (headRef == null) {
      // No head then consider the new Node as the head
      headRef = newNode;
    } else if (headRef.movie.compareTo(newNode.movie) > 0) {
      // Insert at the start position  
      newNode.next = headRef;
      newNode.next.prev = newNode;
      headRef = newNode;
    } else {
      // Search for the Node with movie > newNode.movie
      Node current = headRef;
      while(current.next != null && current.next.movie.compareTo(newNode.movie) < 0) {
        current = current.next;
      }

      newNode.next = current.next;
      current.next = newNode;
      newNode.prev = current;
    }

    return headRef;
  }

1997 Fast & Furious
1997 Titanic
1999 The Matrix
2014 Interstellar
2014 The Hobbit: The Battle of the Five Armies

Some comments regarding your code:

1. You should add an outer container class to hold the head/tail references, and then make the insert method a non-static member.
2. You're doing your own string comparison, which is unnecessary - the String class already implements Comparable (and therefore has a compareTo method).
3. You should make your list type generic, so it can be used with any element type (i.e. not just Movies). It would also be advisable to make the ordering on the list configurable (by accepting a Comparator argument).
4. Double-linked lists are a bit tedious due to to having to handle insertion for the various edge case (empty list, one element list, value inserted at the head/tail). The implemention becomes much more simple if you add dummy nodes to mark the head and the tail of the list.

Bearing all of that in mind, then the list can be implemented as follows:

public class NodeList<T> {
private static class Node<T> {
final T value;
Node<T> next;
Node<T> prev;
private Node(T value, Node<T> next, Node<T> prev) {
this.value = value;
this.next = next;
this.prev = prev;
next.prev = this;
prev.next = this;
}
private Node() {
value = null;
}
}
private final Comparator<T> comp;
private final Node<T> beforeHead = new Node<>();
private final Node<T> afterTail = new Node<>();
public NodeList(Comparator<T> comp) {
this.comp = comp;
this.beforeHead.next = afterTail;
this.afterTail.prev = beforeHead;
}
public void insert(T value) {
for (Node<T> node = beforeHead; node.next != afterTail; node = node.next) {
if (comp.compare(value, node.next.value) < 0) {
new Node<T>(value, node.next, node);
return;
}
}
new Node<T>(value, afterTail, afterTail.prev);
}
}

To test it it helps if we make it Iterable:

public class NodeList<T> implements Iterable<T> {
// as before.
@Override
public Iterator<T> iterator() {
return new Iterator<T>() {
Node<T> node = beforeHead.next;
@Override
public boolean hasNext() {
return node != afterTail;
}
@Override
public T next() {
final T value = node.value;
node = node.next;
return value;
}
};
}
}

and then test it like this:

public static class Movie {
public final int year;
public final String name;
public Movie(int year, String name) {
this.year = year;
this.name = name;
}
public int year() { return year;}
public String name() { return name;}
public String toString() {
return year + " " + name;
}
}
public static void main(String[] args) {
final NodeList<Movie> movies = new NodeList<>(Comparator.comparing(Movie::year).thenComparing(Movie::name));
movies.insert(new Movie(1997, "Titanic"));
movies.insert(new Movie(1999, "The Matrix"));
movies.insert(new Movie(2014, "The Hobbit: The Battle of the Five Armies"));
movies.insert(new Movie(1997, "Fast & Furious"));
movies.insert(new Movie(2014, "Interstellar"));
movies.forEach(System.out::println);
}

which outputs the following:

1997 Fast & Furious
1997 Titanic
1999 The Matrix
2014 Interstellar
2014 The Hobbit: The Battle of the Five Armies

It's probably worth noting that insertion sorts are relatively inefficient for anything oher than small lists.