在单个遍历链表中从开始和结束交换第 k 个位置答案

【问题标题】：Swap kth position from start and end in a single traverse linked list在单个遍历链表中从开始和结束交换第 k 个位置
【发布时间】：2014-04-19 06:07:39
【问题描述】：

我遇到了以下实现，用于在单次遍历中交换链表中从开始到结束的第 k 个位置。

node *list;
node *p, *q, *r;
p = q = r = list;

i = 1;

while(p != NULL)
{
    if(i != k)
    {
        q = q->next;
        i++;
    }//q will eventually point to kth node from starting

    if(i == k)
    {
        r = r->next
    }//r will eventually point to kth node from end

    p = p->next;

}

 Swap q & r elements

但我觉得这不是正确的实现，有人可以看看它并验证它是否正确吗？

如果错了，我需要做出哪些改变？

【问题讨论】：

你知道列表的大小吗？
请自行测试代码，而不是询问它是否适用于Stack Overflow。感觉和 Stack Overflow 都不能很好地替代您的编译器。
是的@arunmoezhi，我预先知道尺寸。
如果是双向链表，可以双向遍历找到第K个元素，然后交换它们的值
对于大小为 N 的单链表，找到第 K 个元素，然后找到第 N-K+1 个元素并交换它们的值

标签： c data-structures linked-list

【解决方案1】：

这个问题主要与寻找正确的节点和各自的前一个节点有关。那么基本上有两种情况，节点是开始节点和结束节点，或者它们是中间节点。

首先调整前一个指针指向交换目标，然后交换目标的下一个指针。就是这样……以下是完整的java代码供参考->

JAVA 代码

public class SwapKthNodeTest {

    public static void main(String[] args) {

        Test10Node();
        System.out.println();
        Test2Node();
    }

    private static void Test2Node() {
        Node head = Node.getNodeListHead(2);
        Node.ToString(head);
        int k = 1;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);
        k = 2;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);
    }

    public static void Test10Node(){
        Node head = Node.getNodeListHead(10);
        Node.ToString(head);
        int k = 2;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);
        k=1;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);
        k=3;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);
        k=4;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);
        k=5;
        head = Node.SwapKthNodeFromStartNEnd(head, k);
        Node.ToString(head);

    }

}

class Node {
    int val;
    Node next;
    Node(int val, Node next) {
        this.val = val;
        this.next= next;
    }
    public static int length(Node head){
        Node trav = head;
        int count = 0;
        while(trav != null){
            count++;
            trav = trav.next;
        }
        return count;
    }
    public static void ToString(Node head) {
        // just print the list which we created
        Node trav = head;
        while(trav != null){
            System.out.print(trav.val+" ");
            trav = trav.next;
        }
    }

    public static Node SwapKthNodeFromStartNEnd(Node head, int k) {
        System.out.println();

        int len = Node.length(head);
        if( k > len)    return head;

        // would be the same thing just making it reverse
        // to make process more cleaner
        if( k == len)   k = 1;

        Node x = head, y = head, t = head;
        Node xp = null, yp = null;
        int i = 1;

        while (i++ < k) {
            xp = x;
            x  = x.next;
            t  = t.next;
        }

        while(t.next != null){
            yp = y;
            y  = y.next;
            t  = t.next;
        }

//      System.out.println("x= "+x.val+" y= "+ y.val);
//      if(xp != null)  System.out.println("xp= "+xp.val);
//      if(yp != null)  System.out.println("yp= "+yp.val);

        // first adjust previous pointer of two nodes
        // later swap the next pointers of both nodes

        // CASE-1: case nodes have previous pointer
        // and they are not start and end node 
        if(xp != null && yp != null ){
            xp.next = y;
            yp.next = x;
        }
        // CASE-2: x and y nodes are first and last
        // this case xp is null
        else if (xp == null && yp != null){
            head    = y;
            yp.next = x;
        }

        t      = y.next;
        y.next = x.next;
        x.next = t;

        return head;
    }


    public static Node getNodeListHead(int nodes){
        int idx = nodes-1;
        Node head = new Node(nodes, null);
        while(idx >= 1){
            head = new Node(idx, head);
            idx--;
        }


        return head;
    }
}

【讨论】：

【解决方案2】：

请参阅 geeks4geeks 了解所有边界情况：

http://www.geeksforgeeks.org/swap-kth-node-from-beginning-with-kth-node-from-end-in-a-linked-list/

【讨论】：

请自行回答。

【解决方案3】：

对于大小为 N 的单链表，找到 Kth 元素，然后找到 N-K+1 th 元素并交换它们的值正如乔纳森所说，您必须处理特殊情况并跟踪其他指针以进行交换。但关键是您必须将Kth 元素与N-K+1th 元素交换

【讨论】：