Question

我需要检查存储在LinkedList中的数字是否顺序。

示例集是：123、124、125、1900、1901。

如果代码遇到123，它将检查下一个124，直到125，然后停止，因为自然计数时1900不是125之后的下一个数字，因此它将停止。所以我需要获取first（123）和last序列（125）的索引。然后进入下一个序列1900和1901。

    for(int o = 0; o < zeroIndex.size(); o++)
    {
        if(-1 == (zeroIndex.get(o) - zeroIndex.get(o+1)))
        {
            System.out.println(zeroIndex.get(o) + "trailing");
        }
    }

Answer 1

    String serialIndex = "";
    for(int o = 1; o < zeroIndex.size(); o++)
        {serialIndex += "("+Integer.toString(o-1);
            while(i<zeroIndex.size() && zeroIndex.get(o-1)+1 == zeroIndex.get(o))
            {  i++;
                //System.out.println(zeroIndex.get(o) + "trailing");
            }
         serialIndex = serialIndex+Integer.toString(i-1)+"),";
     }
     System.out.println(serialIndex);

我们将循环到链表，并检查前一个是否小于当前值。如果此条件为true，我们将递增i，否则将中断并循环将其添加到ans

例如

123、124、125、1900、1901。我们将从
124 -----我们的 serialIndex 字符串将为（0 ，并且124比123大1，因此我们将i递增。当达到1900时，我们将中断while循环（如1900）不是1大于125，现在我们的serialIndex字符串将为b （0,2）。
最后，我们将serialIndex字符串设置为（0,2），（3,4）

我没有完整的代码要测试，所以这是我能做的最好的。如果遇到任何错误，请告诉我。

Answer 2

这适用于O（n）

import java.util.LinkedList;

public class TestLinkedList {

    public static void main(String[] args) {

        LinkedList<Integer> a = new LinkedList<Integer>();
        a.add(124);
        a.add(125);
        a.add(126);
        a.add(1900);
        a.add(1901);

        int index = 0;
        int index1 = 0;

        for (int i = 0; i < a.size(); i++) {
            if (i+1 < a.size() && a.get(i) + 1 == a.get(i + 1)) {
                index1 = i + 1;
            } else {
                if (index != index1) {
                    System.out.println(index + " " + index1);
                }
                index = i+1;
                index1 = i+1;
            }
        }

    }

}

输出

0 2
3 4

Answer 3

这里是一个简单的示例。首先，创建我们的列表。

List<Integer> a = new LinkedList<Integer>();
a.add(124);
a.add(125);
a.add(126);
a.add(1900);
a.add(1901);

所以，现在我们有了列表，让我们开始吧。首先，声明我们的变量

int current; //will hold the current value during the iteration   
int indexStart = 0; //the index of the beginning of the current sequence
int previous = a.get(0); //the previous value

int length = a.size(); //the length (optionnal, but this will be used later)

然后，这是有趣的par（经过充分评论）

//Iterate from 1 to the end (0 is already in `previous`
for(int i = 1 ; i < length; ++i){
    //get the current value
    current = a.get(i); 

    //if the sequence is broken, print the index and print also the sublist using `List.subList`.
    if(current != previous + 1){ 
        System.out.format("Sequence from %d to %d%n", indexStart, i - 1);
        System.out.println(a.subList(indexStart, i));

        //reset the start of the current sequence
        indexStart = i; 
    }

    //update the previous value with the current for the next iteration.
    previous = current;
}

//Print the last sequence.
System.out.format("Sequence from %d to %d%n", indexStart, length - 1);
System.out.println(a.subList(indexStart, length));

这将打印：

从0到2的顺序
  [124，125，126]
  从3到4的顺序
  [1900，1901]

这很简单，只需迭代循环并保留先前值和当前值即可检查序列是否正确。

请注意，在使用LinkedList的情况下，我会使用Iterator，但是我需要使用int index，这样可以提供更长的解决方案，因此为了简单起见，我使用了{ {1}}。

如何检查数字是否在LinkedList中按顺序排列

3 个答案: