反转单链表

ListNode是单链表节点的数据结构,实现见如下代码:package List;

/** * Created by Administrator on 2015/10/10. */public class ListNode {    //节点的值    private char data;    //节点的后续节点    private ListNode next;

    public ListNode(char data, ListNode next) {        this.data = data;        this.next = next;    }    public ListNode(ListNode next){        this.next=next;    }

    public char getData() {        return data;    }

    public void setData(char data) {        this.data = data;    }

    public ListNode getNext() {        return next;    }

    public void setNext(ListNode next) {        this.next = next;    }}那么对于链表的反转操作及其测试用例如下:
package List;

/** * Created by Administrator on 2015/10/10. */public class NodeUtil {    public static void printList(ListNode head){        if(head.getNext()==null){            System.out.println("此链表为空!");        }else{           ListNode p=head.getNext();           while (p.getNext()!=null){               System.out.print(p.getData()+"->");               p=p.getNext();           }        System.out.print(p.getData());        }

    }    //反转链表    public static ListNode reverseLinkedList(ListNode head){        ListNode p=head.getNext();        ListNode q=p.getNext();        p.setNext(null);        while (q.getNext()!=null){            ListNode nextQ=q.getNext();            q.setNext(p);            p=q;            q=nextQ;        }        q.setNext(p);        ListNode root=new ListNode(q);        return root;    }    //测试    public static void main(String[] args){        ListNode D=new ListNode(‘D‘,null);        ListNode C=new ListNode(‘C‘,D);        ListNode B=new ListNode(‘B‘,C);        ListNode A=new ListNode(‘A‘,B);        ListNode head=new ListNode(A);        System.out.println("反转链表之前");        printList(head);        System.out.println();        System.out.println("反转链表之后");        ListNode root=reverseLinkedList(head);        printList(root);    }}
时间: 2024-10-21 17:32:33

反转单链表的相关文章

递归、非递归 反转单链表

定义链表结构 struct ListNode { int val; ListNode *next; ListNode(int v) : val(v), next(NULL) {} }; 非递归反转单链表 ListNode* reverse(ListNode *root) { if (root == NULL || root->next == NULL) return root; ListNode *cur = root->next; root->next = NULL; while (c

C语言:【单链表】逆置反转单链表

#include<stdio.h> #include<assert.h> #include<stdlib.h> typedef int DataType; typedef struct SListNode {     DataType data;     struct SListNode* next; }SListNode; SListNode* BuyNode(DataType x) {     SListNode* next = (SListNode*)malloc

【LeetCode-面试算法经典-Java实现】【092-Reverse Linked List II(反转单链表II)】

[092-Reverse Linked List II(反转单链表II)] [LeetCode-面试算法经典-Java实现][所有题目目录索引] 原题 Reverse a linked list from position m to n. Do it in-place and in one-pass. For example: Given 1->2->3->4->5->NULL, m = 2 and n = 4, return 1->4->3->2->

算法题:反转单链表

说明:本文仅供学习交流,转载请标明出处,欢迎转载! 题目:存在一个单链表,头指针为head,实现单链表的反转Node *Reverse(Node *head).  该算法的求解办法有很多,如: 方法1:先顺序变量单链表,将结点保存到栈中,在从栈中弹出结点,重新建立一个新的单链表: 方法2:用<剑指offer>里面给出的算法,用三个指针来实现: 方法3:采用递归实现,是方法2的递归实现形式. 本文主要给出方法2和方法3,在给出具体的代码之前,先要注意几个问题:          (1)如果hea

反转单链表并验证(详解)

单链表优点: 可以动态增加和删除. 不需要定义初始大小. 点链表缺点: 不能随机访问.需要逐个遍历直到找到目标项. 用到动态内存分配和指针,代码复杂度提升,内存泄漏和内存段错误风险提升. 开销大较大,因为是动态分配内存.而且每项需要存储一个额外的指针. 定义单链表: ------------------------------ ------------------------------ | | | \ | | | | val | next |--------------| val | next

Leetcode25---&gt;Reverse Nodes in k-Group(以k个节点为段,反转单链表)

题目: 给定一个单链表,一次反转k个节点,最终返回翻转后的链表的头节点:如果链表不足k个,则不变 举例: Given this linked list: 1->2->3->4->5 For k = 2, you should return: 2->1->4->3->5 For k = 3, you should return: 3->2->1->4->5 解题思路: 1.  首先要确定链表的头节点newHead;即如果链表的节点个数大

高效代码之反转单链表

单链表的反转是经常用到的 那么单链表的高效转换就很重要了.这里记录一下.方便用时查阅. struct ListNode { int m_nValue; ListNode * m_pNext; }; //实现如下: //反转链表需要3个指针 //1.指向当前元素pNode //2.指向当前元素的前一个元素pPrev //3.指向当前元素的后一个元素pNext ListNode* ReverseList(ListNode* pHead) { ListNode* pReverseHead = NULL

反转单链表(C++)

普通的单链表反转算法 大学的时候也做过好几次单链表的反转,记得当时都是用三个变量不断修改next的值然后实现反转. 1 ListNode* reverseList(ListNode* head) { 2 ListNode *pre = NULL,*tmp,*cur = head; 3 while(cur != NULL){ 4 tmp = cur->next; 5 cur->next = pre; 6 pre = cur; 7 cur = tmp; 8 } 9 return pre; 10 }

反转单链表——16

定义一个函数,输入一个链表的头结点,反转该链表并输出反转后链表的头结点. 要反转一个单链表也就是使链表中的结点逆置,但并不是遍历链表每一次都将结点重新创建进行头插,这样就是重新创建一个单链表了而不是将原有的单链表逆置:因此,可以想到用多个指针来操控,既要防止找不到下一个结点的问题,也要解决逆置链表的链接问题: 程序设计如下: #include <iostream> #include <assert.h> using namespace std;   template <cla