Question

给定单链接列表，删除右侧具有更大值的所有节点。这不是一个家庭作业，它在接受采访时被问到我。

e.g。

输入：

2 ---→4 ---→2 ---→1 ---→3 ---大于0

然后输出应该是

4 ---→3 ---＆GT; 0

输入：

30 ---→40 ---→50 ---→60

然后输出应该是

60

我的方法如下：

1. reverse the link list
2. maintain the max value if the current node is less than max than remove else move next
3. reverse again

但是面试官让我对此进行优化。我认为他的期待与@Trying提到的相同。

Answer 1

时间复杂度O（N）。如果您有任何疑问，请告诉我。感谢。

Node delete(Node n){
        if(n==null){
            return null;
        }
        Node t = delete(n.next);
        if(t==null){
            return n; // i.e. right most node so just return this
        }
        else{
            Comparable c = (Comparable)n.k;
            if(c.compareTo((Comparable)t.k)<0){ //no need of this node so return t.
                return t;
            }
            else{
                n.next=t; //valid node so change the next pointer of current node
                return n;
            }
        }
    }

Answer 2

解决问题，并从解决方案中借鉴。

decreasingList(List list) {
    if list empty then return empty

    List restSolution = decreasingList(list.next)
    ... list.first ... // What now

问问自己，restSolution和list.first应该返回什么。

这使得计算机科学比数学更有趣：懒惰，做一点点，并委派工作。

很抱歉认为这是作业

static class List {
    int value;
    List next;

    List(int value, List next) {
        this.value = value;
        this.next = next;
    }

    static List makeList(int... values) {
        List list = null;
        List tail = null;
        for (int value: values) {
            List node = new List(value, null);
            if (tail == null) {
                list = node;
            } else {
                tail.next = node;
            }
            tail = node;
        }
        return list;
    }

    @Override
    public String toString() {
        if (next == null) {
            return String.valueOf(value);
        }
        return String.valueOf(value) + "-->" + next.toString();
    }
}

static List decreasingList(List list) {
    if (list == null) {
        return null;
    }
    List rest = decreasingList(list.next);
    if (rest != null && list.value < rest.value) {
        return rest;
    }
    list.next = rest;
    return list;
}

public static void main(String[] args) {
    List list = List.makeList(2, 4, 2, 1, 3, 0);
    System.out.println("List: " + list);
    list = decreasingList(list);
    System.out.println("Decreasing: " + list);
}

递归可能会像你一样解决：通过遍历nexts并更改前一个节点的下一个来反转。然后在尾巴回去。

static List decreasingList(List list) {
    List prior = null;
    while (list != null) {
        List next = list.next;
        list.next = prior;
        prior = list;
        list = next;
    }
    list = prior; // The reversed list.

    prior = null;
    while (list != null) {
        List next = list.next;
        list.next = prior;
        if (prior == null || list.value > prior.value) {
            prior = list;
        }
        list = next;
    }
    list = prior;
    return list;
}

删除右侧具有更大值的所有节点（链接列表）

2 个答案: