LinkedList中的Java挑战

问题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]

这个问题看起来很简单，但回答起来有点困难。有人能在不使用

Collection

或

LinkedList

的情况下用Java编写上述代码吗

下面是检测序列的代码（这可能会有所帮助）

类序列{
公共静态字符串检测序列（int-seq[]）{
字符串结果=”；
对于（int i=0；i

只是给你一个开始

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;
}

publicYourLinkedList拆分序列（int[]数组）{
YourLinkedList=新建YourLinkedList（）；
如果（array.length>0）{
YourSequence=新的YourSequence（）；
int-currentNumber；
int lastNumber=数组[0]；
顺序。添加（最后一个编号）；
for（int index=1；index

现在去找出你的链表和序列类，然后做打印工作

链表的最简实现

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();
        }
    }
}

公共类MyLinkedList{
private MyLinkedListItem first=null；
私有MyLinkedListItem last=null；
公共MyLinkedList（）{
}
公共作废添加（T1项）{
MyLinkedListItem newItem=新建MyLinkedListItem（项目）；
if（first==null）{
第一个=新项目；
}否则{
last.setNext（newItem）；
}
最后一个=新项目；
}
@凌驾
公共字符串toString（）{
StringBuffer=新的StringBuffer（）；
如果（第一个！=null）{
MyLinkedListItem当前=第一个；
while（current.hasNext（））{
append（current.toString（））；
buffer.append（“->”）；
current=current.getNext（）；
}
append（current.toString（））；
}
返回buffer.toString（）；
}
私有类MyLinkedListItem{
私人T2数据；
private MyLinkedListItem next=null；
公共MyLinkedListItem（T2数据）{
这个数据=数据；
}
公共布尔hasNext（）{
返回下一步！=null；
}
公共MyLinkedListItem getNext（）{
下一步返回；
}
public void setNext（MyLinkedListItem next）{
this.next=next；
}
@凌驾
公共字符串toString（）{
返回data.toString（）；
}
}
}

首先，可以使用迭代器编写将数组分成若干块的代码，以避免将此算法与创建链表的代码混合使用。 然后，有一种方法可以以函数的方式实现一个简单的链表（因此整个链表是不可变的）

显然，这段代码不可读，但很有趣

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(" -> "));
  }
}

导入java.util.array；
导入java.util.Iterator；
导入java.util.function.Consumer；
导入java.util.function.function；
导入java.util.stream.IntStream；
公共类链接的执行者{
专用静态迭代器迭代器（int[]数组）{
返回新的迭代器（）{
私有整数索引；
@凌驾
公共布尔hasNext（）{
返回索引void forEach（consumer）当我说你需要弄清楚你的类时，这就是我的意思。上面的代码只是给你一个方向。
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(" -> "));
  }
}