变换双向链表答案

【问题标题】：Transform doubly linked list变换双向链表
【发布时间】：2015-07-20 11:27:11
【问题描述】：

我需要以这种方式转换 DLL：给定 n（节点数）和四个整数（a、b、c、d），表示两个区间 a、b 和 b、c。例如：

N: 7

Input list:

1 2 3 4 5 6 7

a,b = 2 3
c,d = 5 6

我需要做的是从给定的间隔交换节点，所以输出应该是这样的：

1 **5 6** 4 **2 3** 7

如您所见，元素 2 和 3 的节点与元素 5 和 6 交换了位置。

输入输入的其他方式可以是这样的：

N:5

Input: 10 50 40 25 1

a, b: 10 10
c, d: 40 1

Output: 40 25 1 50 10

这意味着间隔可以以相同的数字开始和结束。

编辑：请注意，间隔可以不同，即 a、b 可以有 3 个节点，而 c、d 可以有更多或更少，或相同数量的节点。

这是我到目前为止所做的。我只是取了给定的节点（a，b，c，d）后继者和前任者，但我需要以某种方式交换它们。这是函数的代码。

private static DLL<Integer> intervals(DLL<Integer> list, int a, int b, int c, int d) {


        DLLNode<Integer> temp = lista.getFirst();
        DLLNode<Integer> temp1;
        DLLNode<Integer> temp2;
        DLLNode<Integer> temp3;
        DLLNode<Integer> temp4;
        while(temp != null){
            if(temp.element == a){
                temp1 = temp.pred;
            }
            if(temp.element == b){
                temp2 = temp.succ;
            }
            if(temp.element == c){
                temp3 = temp.pred;
            }
            if(temp.element == d){
                temp4 = temp.succ;
            }
            temp = temp.succ;
        }
        return list;
    }

【问题讨论】：

如果b - a > 1 会发生什么？ b - a = d - c 有保证吗？
this 是对函数应该做什么的正确解释吗？
我觉得你没看明白。间隔应该由元素值组成，而不是位置。
是的@Mauris，这是正确的

标签： java list transform nodes

【解决方案1】：

您可以在返回列表之前进行以下操作。

DLLNode<Integer> a = temp1.succ;
DLLNode<Integer> b = temp2.pred;
DLLNode<Integer> c = temp3.succ;
DLLNode<Integer> d = temp4.pred;

temp1.succ = temp3.succ;
temp3.pred = temp1;

temp4.succ = a;
a.pred = temp4;

b.succ = c;
c.pred = b;

【讨论】：

【解决方案2】：

你已经接近了！假设列表如下所示：

[ ... p, a ... b, q ... r, c ... d, s ... ]
         ^^^^^^^           ^^^^^^^

您已经提取了包含p, q, r, s 的节点。现在您要交换带下划线的区域。使p = a.pred 将其succ 指向c，反之亦然。同样，将d链接到q；然后将r 链接到a 并将b 链接到s。

【讨论】：

我认为我们错过了一个案例......如果第一个节点包含该元素怎么办？那么 temp1 = temp.pred 将为空...
您必须手动处理，或者您可以将sentinel nodes 添加到 DLL 的两端。

【解决方案3】：

好的，我解决了这里是完整的代码，很容易理解。

private static DLL<Integer> intervals(DLL<Integer> list, int a, int b, int c, int d) {



        DLLNode<Integer> temp =l ist.getFirst();
        DLL<Integer> tmp2=new DLL<Integer>();
        DLL<Integer> tmp3=new DLL<Integer>();
        DLL<Integer> tmp4=new DLL<Integer>();
        DLL<Integer> newList =new DLL<Integer>();
        while(temp .element!=a)
        {
            nova.insertLast(temp .element);
            temp = temp.succ;
        }
        tmp2.insertLast(temp.element);
        temp =temp.succ;
        while(temp.pred.element!=b)
        {
            tmp2.insertLast(temp.element);
            temp=temp.succ;
        }
        while(temp.element!=c)
        {
            tmp3.insertLast(temp.element);
            pom=pom.succ;
        }
        while(temp!=null&&temp.pred.element!=d)
        {
            tmp4.insertLast(temp.element);
            temp=temp.succ;
        }

        DLLNode<Integer> node2=tmp2.getFirst();
        DLLNode<Integer> node3=tmp3.getFirst();
        DLLNode<Integer> node4=tmp4.getFirst();

        while(node4 != null)
        {
            newList.insertLast(node4.element);
            node4=node4.succ;
        }
        while(node3 != null)
        {
            newList.insertLast(node3.element);
            node3=node3.succ;
        }
        while(node2 != null)
        {
            newList.insertLast(node2.element);
            node2=node2.succ;
        }
        while(pom != null)
        {
            newList.insertLast(pom.element);
            pom=pom.succ;
        }
        list = newList;
        return list;
    }

【讨论】：