我正在尝试编写一个subList方法，该方法返回一个由当前对象列表组成的列表，该列表包含在索引fromIndex和toIndex之间。
例如，如果我有一个由组成的列表
3 5 7 9 11 20 23
我打电话给subList(0,3)，我应该得到一个新的列表
3 5 7 9
返回。
我正在使用helper方法来帮助编写方法。我编写此方法的逻辑是，我将头节点分配给索引fromIndex处的节点，同时将列表中的最后一个节点分配给位于索引toIndex处的节点。感谢您的帮助！
编辑：我创建了一个添加方法，它将节点添加到列表中。我仍在尝试编写自己的subList方法。
第二版：我更新了一些代码，可以在底部看到（忽略上面的旧代码）。fromIndex和toIndex包含在新的子列表中。
private class Node<N extends Comparable<N>> {
private N data;
private Node<N> next;
}
private Node<L> head;
public List() {
head=null;
}
public void add(Node<L> node) {
Node<L> add = new Node<L>();
add.data = node.data;
add.next = null;
getFinal().next = add;
}
public Node<L> getFinal(){
Node<L> node = head;
while (node.next != null) {
node = node.next;
}
return node;
}
public int size() {
if (head == null) return 0;
int counter = 0;
for (Node<L> curr = head; curr != null; curr = curr.next)
counter++;
return counter;
}
public List<L> subList(int fromIndex, int toIndex)
throws IndexOutOfBoundsException {
List<L> n=new List<L>();
Node<L> tail= new Node<L>();
n.head=nthItem(fromIndex);
tail=n.getFinal();
tail=nthItem(toIndex);
return n;
}
public Node<L> nthItem(int index) {
if (index < 0 || index >= size())
throw new IndexOutOfBoundsException();
Node<L> ptr = head;
int i = 0;
while (ptr != null) {
if (i == index) return ptr;
i++;
ptr = ptr.next;
}
throw new IndexOutOfBoundsException();
}
更新代码
private void add(Node<L> node) {
if(head==null){
head=node;
} else {
getFinal().next = node;
}
}
public List<L> subList(int fromIndex, int toIndex)
throws IndexOutOfBoundsException {
if(fromIndex<0 || fromIndex>size()-1 || toIndex<0 || toIndex>size()-1){ //size() is 1 bigger than max index so I subtract 1 from size() to equal them out
throw new IndexOutOfBoundsException();
}
List<L> n=new List<L>();
Node<L> startNode = head;
int counter=0;
while(startNode!=null){
if(counter>=fromIndex && counter<=toIndex){ //fromIndex and toIndex are inclusive so I've added the equals to them. However, it enters an infinite loop, which I do not understand why.
n.add(startNode);
}
startNode=startNode.next;
counter++;
}
return n;
}
问题1-为什么要这样做？LinkedList很好，不需要重写。。。
点2（或b）-您的子列表函数创建一个新列表，设置其头部，然后设置一个临时变量以包含子列表的所需尾部。。。
在链表中，如果有一个节点，则该节点表示从该点起该列表的其余部分。要解决您的问题，您需要克隆所有节点来创建子列表，将最后一个克隆的尾部设置为null。
但为什么要这样做呢？
---编辑-澄清答案
public List<L> subList(int fromIndex, int toIndex) {
Node<L> currentInOriginal = nthItem(fromIndex);
int count = (toIndex - fromIndex) + 1;
List<L> newSubList = new List<L>();
newSubList.head = new Node<L>(current.data);
Node<L> lastItemInList = newSubList.head;
int soFar = 1;
currentInOriginal = currentInOriginal.next;
while(currentInOriginal!=null && soFar<count) {
lastItemInList.next = new Node<L>(currentInOriginal.data);
listItemInList = lastItemInList.next;
currentInOriginal=currentInOriginal.next;
soFar++;
}
return newSubList;
}
也许你已经知道了，但是，你试过LinkedList.sublist()吗？这里有一个例子：
import java.util.LinkedList;
import java.util.List;
public class GetSubListLinkedListJavaExample {
public static void main(String[] args) {
//create LinkedList object
LinkedList lList = new LinkedList();
//add elements to LinkedList
lList.add("1");
lList.add("2");
lList.add("3");
lList.add("4");
lList.add("5");
System.out.println("LinkedList contains : " + lList);
/*
* To get a sublist from Java LinkedList, use
* List subList(int start, int end) method.
*
* This method returns portion of list containing element from start index
* inclusive to end index exclusive.
*/
List lst = lList.subList(1,4);
System.out.println("Sublist contains : " + lst);
/*
* Please note that sublist is backed by the original list, so any changes
* made to sublist will also be reflected back to original LinkedList
*/
//remove element from sublist
lst.remove(2);
System.out.println("Sublist now contains : " + lst);
System.out.println("Original LinkedList now contains : " + lList);
}
}
/*
Output would be
LinkedList contains : [1, 2, 3, 4, 5]
Sublist contains : [2, 3, 4]
Sublist now contains : [2, 3]
Original LinkedList now contains : [1, 2, 3, 5]
*/
希望能有所帮助。
克莱门西奥·莫拉莱斯·卢卡斯。
您的方法不正确，必须从head开始循环，如果索引在fromIndex和toIndex之间，则返回所有值。在开始之前，您还需要验证提供的索引是否有效。
这条线上有东西
public List<L> subList(int fromIndex, int toIndex)
throws IndexOutOfBoundsException {
if(fromIndex<0 || fromIndex>size() || toIndex<fromIndex || toIndex>size()){
throw new IndexOutOfBoundsException();
}
List<L> n=new List<L>();
Node<L> startNode = head;
int counter=0;
while(startNode!=null){
if(counter>fromIndex && counter<toIndex){
n.add(startNode);
}
startNode=startNode.next;
counter++;
}
return n;
}
在本文中，我们检查fromIndex和toIndex是否有效，如果无效，则抛出异常。我们循环浏览整个列表&放入仅在提供的索引之间的元素。
根据评论
是的，您的Add也不正确。您要做的是首先设置头节点。
public void add(Node<L> node) {
if(head==null){
head=node;
} else {
getFinal().next = node;
}
}
使用java 8 Stream函数，您可以从任何给定类型的List中获取子列表
如果您想要特定类型的List，而不是List<>然后可以将方法中的返回类型强制转换为特定类型的List
获取任意类型给定列表的子列表，如ArrayList、LinkedList、ArrayDeque以下方法可用于获取任何类型的子列表
package com.techsqually.datastructure.collections.lists.linkedlist;
import java.util.LinkedList;
import java.util.List;
import java.util.stream.Collectors;
public class LinkedListTest {
public static void main(String[] args) {
LinkedList<Integer> giveString = new LinkedList<>();
giveString.add(1);
giveString.add(2);
giveString.add(3);
giveString.add(4);
giveString.add(3);
giveString.add(5);
System.out.println(giveString);
System.out.println(getSubList(giveString,0,3));
}
public static List getSubList(LinkedList<Integer> givenList, int startIndexInclusive, int endIndexExclusive){
return givenList.stream().collect(Collectors.toList()).subList(startIndexInclusive,endIndexExclusive);
}
}
输出：
[1,2,3,4,3,5]
[1,2,3]