Reverse-Rechte Hälfte einer verknüpften Liste

Basierend auf @passion ' s Idee. Ich habe ein übersichtlicher code.

class ListNode
{
    int val;
    ListNode next;
    ListNode(int x) { val = x; }
}


class ReverseRightHalfLinkedList 
{
    public static void main(String[] args) 
    {       
        ListNode node1 = new ListNode(2);
        ListNode node2 = new ListNode(1);
        ListNode node3 = new ListNode(3);
        ListNode node4 = new ListNode(4);
        ListNode node5 = new ListNode(5);
        ListNode node6 = new ListNode(6);
        ListNode node7 = new ListNode(7);
        ListNode node8 = new ListNode(8);
        node1.next = node2;
        node2.next = node3;
        node3.next = node4;
        node4.next = node5;
        node5.next = node6;
        node6.next = node7;
        node7.next = node8;


        ListNode res = reverse(node1);

        ListNode node = node1;
        while (node != null)
        {
            System.out.println(node.val);
            node = node.next;
        }

    }

    public static ListNode reverse(ListNode start)
    {   
        int counter = 0;
        ListNode node = start;
        ListNode pre = start;

        ListNode result = start;

        while (node!= null)//for count how many elements in linked list
        {
            counter += 1;
            node = node.next;           
        }

        for (int i=0; i< (counter / 2) ; i++)//no matter counter is even or odd, when it divided by 2, the result is even
        {   
            pre = start;
            start = start.next; 
        }


        ListNode temp = null;
        ListNode preNext = null;//this variable is used to track the next val behind pre
        //for example, 2->1->3->4->5->6->7->8
        //at this moment, pre:4, start:5
        //I treated 5->6->7->8 as an independent linkedlist
        //I reversed the linkedlist 
        //Finally, set the pre node's next value to the reversed linkedlist's head
        //The first half and second half have been connected together


        while (start != null)
        {
            temp = start.next;
            start.next = preNext;
            preNext = start;
            start = temp;
        }
        pre.next = preNext;

        return start;

    }
}

/*
* To change this license header, choose License Headers in Project Properties.
* To change this template file, choose Tools | Templates
* and open the template in the editor.
*/

package javaapplication2;

class LinkedList {

    static Node head;

    static class Node {

        int data;
        Node next;

        Node(int d) {
            data = d;
            next = null;
        }
    }

    Node rev(Node node) {
        Node prev = null;
        Node current = node;
        Node next = null;
        while (current != null) {
            next = current.next;
            current.next = prev;
            prev = current;
            current = next;
        }
        node = prev;
        return node;
    }

    Node reverse(Node node) {
        int count =0;
        Node doo = node;
        Node mid_pre = node;
        Node mid = node;
        while(doo.next != null){
            if((count & 1) == 1){
                //  mid_pre = mid;
                mid = mid.next;
            }
            doo = doo.next;
            count++;
        }
        //System.out.println(" midd ddddd :"+mid_pre.data+" "+mid.data);
        mid.next = rev(mid.next);
        return node;
    }

    void printList(Node node) {
        while (node != null) {
            System.out.print(node.data + " ");
            node = node.next;
        }

    }

    public static void main(String[] args) {
        LinkedList list = new LinkedList();
        list.head = new Node(1);
        list.head.next = new Node(2);
        list.head.next.next = new Node(3);
        list.head.next.next.next = new Node(4);
        list.head.next.next.next.next = new Node(5);
        list.head.next.next.next.next.next = new Node(6);

        //// 1 2 3 4 5 6
        System.out.println("Given Linked list");
        list.printList(head);
        head = list.reverse(head);
        System.out.println("");
        System.out.println("Reversed linked list ");
        list.printList(head);
    }
}

Hier ist ein Weg, um reverse zweiten Hälfte(rechts) der verlinkten Liste.

#include<stdio.h>
#include<stdlib.h>

struct Node{
int data;
struct Node* next;
};

void append(struct Node** head_ref, int new_data)
{

struct Node* new_node=(struct Node*)malloc(sizeof(struct Node));
new_node->data=new_data;
new_node->next=NULL;

struct Node* last=*head_ref;

if(*head_ref==NULL){
    *head_ref=new_node;
    return;
}

while(last->next!=NULL)
    last=last->next;

last->next=new_node;
return;
}

int display(struct Node* n)
{
int m=0;
printf("\n");
while(n!=NULL)
{
    printf(" %d ",n->data);
    n=n->next;
    m=m+1;
}
return m;
}

void reverse(struct Node** head_ref, int mid)
{
if(*head_ref==NULL)
{
    printf("\nEmpty List cannot be reversed");
    return;
}

struct Node* last=*head_ref;
struct Node* second_last;
struct Node* beg=*head_ref;
int c=1;
while(c<=mid){
    second_last=last;
    last=last->next;
    c=c+1;
}

struct Node* prev=NULL;
struct Node* current=last;
struct Node* next;

while(current != NULL)
{
    next=current->next;
    current->next=prev;
    prev=current;
    current=next;
}
*head_ref=beg;
second_last->next=prev;

}

int main()
{
int size;
struct Node* head=NULL;
int i,mid;
for(i=0;i<11;i++)
{
    append(&head,rand()%19 +1);
}
size=display(head);
printf("\n Size of linked list: %d",size);

if(size%2==0)
    mid=(size+1)/2;
else
    mid=size/2;

reverse(&head, mid);
display(head);
return 0;

}