Java Challenge в LinkedList

Question

Вопрос 4: Учитывая целочисленный массив, преобразуйте его в связанный список с каждым узлом, содержащим одну последовательность.

Sample Input : [1, 3, 4, 5, 8, 9, 11, 13, 14, 15, 16, 20, 23, 30,31,32] 
Sample Linked List : [1] -> [3,4,5] -> [8,9] -> [11] -> [13,14,15,16]->[20]->[23]->[30,31,32] 

Вопрос может, кажется легким, но это немного трудно answer.Can кто писать код выше в Java без использования Collection или LinkedList?

Ниже приведен код для определения последовательности (что может помочь).

class Sequence { 
    public static String detectSequence(int seq[]) { 
     String result = ""; 
     for (int i = 0; i < seq.length - 1; i++) { 
      if (seq[i + 1] == seq[i] + 1) { 
       result += seq[i] + " "; 
       if (i != seq.length - 2) { 
        if (seq[i + 1] != seq[i + 2] - 1) { 
         result += seq[i + 1]; 
        } 
       } 
      } else { 
       result += " "; 
      } 
     } 
     if (seq[seq.length - 1] == seq[seq.length - 2] + 1) { 
      result += seq[seq.length - 1]; 
     } 
     return result; 
    } 
} 
class Question1 { 
    public static void main(String[] cla) { 
     int seqArray[] = { 
      4, 1, 2, 3, 4, 5, 8, 4, 7, 4, 5, 6, 7, 7, 7, 7, 7, 10, 11, 13, 1, 2, 3, 4 
     }; 
     String res = Sequence.detectSequence(seqArray); 
     System.out.println(res); 
    } 
} 

Answer 1

просто дать вам начать ...

public YourLinkedList splitToSequences(int[] array) { 
    YourLinkedList list = new YourLinkedList(); 

    if(array.length > 0) { 
     YourSequence sequence = new YourSequence(); 
     int currentNumber; 
     int lastNumber = array[0]; 
     sequence.add(lastNumber); 

     for(int index = 1; index < array.length; index++) { 
      currentNumber = array[index]; 
      if(currentNumber != lastNumber + 1) { // curentNumber breaks the sequence 
       list.add(sequence);    // save the old sequence to list 
       sequence = new YourSequence(); // and start a new one 
      } 
      sequence.add(currentNumber); 
     } 

     list.add(sequence); 
    } 
    return list; 
} 

Теперь иди и выяснить ваши связанный список и последовательность классов и сделать материал для печати ...

Минималистичный реализация связанный список

public class MyLinkedList<T1> { 
    private MyLinkedListItem<T1> first = null; 
    private MyLinkedListItem<T1> last = null; 

    public MyLinkedList() { 
    } 

    public void add(T1 item) { 
     MyLinkedListItem<T1> newItem = new MyLinkedListItem<T1>(item); 
     if (first == null) { 
      first = newItem; 
     } else { 
      last.setNext(newItem); 
     } 
     last = newItem; 
    } 

    @Override 
    public String toString() { 
     StringBuffer buffer = new StringBuffer(); 

     if(first != null) { 
      MyLinkedListItem<T1> current = first; 

      while(current.hasNext()) { 
       buffer.append(current.toString()); 
       buffer.append(" -> "); 
       current = current.getNext(); 
      } 

      buffer.append(current.toString()); 
     } 

     return buffer.toString(); 
    } 

    private class MyLinkedListItem<T2> { 
     private T2 data; 
     private MyLinkedListItem<T2> next = null; 

     public MyLinkedListItem(T2 data) { 
      this.data = data; 
     } 

     public boolean hasNext() { 
      return next != null; 
     } 

     public MyLinkedListItem<T2> getNext() { 
      return next; 
     } 

     public void setNext(MyLinkedListItem<T2> next) { 
      this.next = next; 
     } 

     @Override 
     public String toString() { 
      return data.toString(); 
     } 
    } 
} 

Answer 2

Сначала код, разделяющий массив в нескольких кусках, может быть записан usin g итератор, чтобы избежать смешивания этого алгоритма с кодом, который создает связанный список. Тогда есть способ реализовать простой связанный список в функциональном режиме (так что весь список является неизменным).

Очевидно, что этот код не читается, но весело!

import java.util.Arrays; 
import java.util.Iterator; 
import java.util.function.Consumer; 
import java.util.function.Function; 
import java.util.stream.IntStream; 

public class LinkedConsecutiveInts { 
    private static Iterator<int[]> iterator(int[] array) { 
    return new Iterator<int[]>() { 
     private int index; 

     @Override 
     public boolean hasNext() { 
     return index < array.length; 
     } 

     @Override 
     public int[] next() { 
     int first = array[index]; 
     int value = first + 1; 
     int i = 1; 
     for(; index + i < array.length && array[index + i] == value++; i++) { 
      // empty 
     } 
     index += i; 
     return IntStream.range(first, first + i).toArray(); 
     } 
    }; 
    } 

    interface Seq<T> { 
    void forEach(Consumer<? super T> consumer); 

    default <U> Seq<U> map(Function<? super T, ? extends U> mapper) { 
     return consumer -> forEach(e -> consumer.accept(mapper.apply(e))); 
    } 

    default String joining(String separator) { 
     StringBuilder builder = new StringBuilder(); 
     forEach(e -> builder.append(e).append(separator)); 
     if (builder.length() != 0) { 
     builder.setLength(builder.length() - separator.length()); 
     } 
     return builder.toString(); 
    } 

    static <T> Seq<T> from(Iterator<? extends T> it) { 
     if (!it.hasNext()) { 
     return consumer -> { /* empty */ }; 
     } 
     T element = it.next(); 
     Seq<T> next = from(it); 
     return consumer -> { consumer.accept(element); next.forEach(consumer); }; 
    } 
    } 

    public static void main(String[] args) { 
    int[] values = { 1, 3, 4, 5, 8, 9, 11, 13, 14, 15, 16, 20, 23, 30, 31, 32 }; 

    Seq<int[]> seq = Seq.from(iterator(values)); 
    System.out.println(seq.map(Arrays::toString).joining(" -> ")); 
    } 
}