链表逆置For Java

Java版链表逆置

定义数据结构:

/**
 * 链表的数据结构
 */
class LinkedListArray {
    /**
     * value
     */
    Object value;

    /**
     * 下个节点
     */
    LinkedListArray next = null;

    public void setValue(Object value) {
        this.value = value;
    }

    public void setNext(LinkedListArray next) {
        this.next = next;
    }

    public Object getValue() {
        return value;
    }

    public LinkedListArray getNext() {
        return next;
    }
}

链表逆置方法:

/**
 * Created by hyson on 15/7/14.
 */
public class ListReverse {
    public static void main(String[] args) {
        LinkedListArray llr1 = new LinkedListArray();
        llr1.setValue("链");
        LinkedListArray llr2 = new LinkedListArray();
        llr2.setValue("表");
        LinkedListArray llr3 = new LinkedListArray();
        llr3.setValue("逆");
        LinkedListArray llr4 = new LinkedListArray();
        llr4.setValue("置");
        llr1.setNext(llr2);
        llr2.setNext(llr3);
        llr3.setNext(llr4);

        print(llr1);
        llr1 = reverse(llr1);
        print(llr1);
    }

    public static void print(LinkedListArray head) {
        LinkedListArray tmp = head;
        while (tmp != null) {
            System.out.print(tmp.getValue());
            tmp = tmp.next;
        }
        System.out.println();
    }

    /**
     * 链表逆置
     * @param listHead 表头
     * @return 逆置的链表
     */
    public static LinkedListArray reverse(LinkedListArray listHead) {
        LinkedListArray lastList,//剩余链表
                tmpList, //暂存链表
                result;//结果链表引用
        lastList = listHead;
        tmpList = result = null;//暂存链表与结果集初始化为空
        while (lastList != null) {
            tmpList = lastList.next;//暂存链表暂存除首节点外的剩余链表
            lastList.next = result;//将首节点放入剩余链表头
            result = lastList;//引用指向链表第一个位置
            lastList = tmpList;//剩余链表引用重新指向暂存的剩余链表
        }
        return result;
    }

}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-04 17:18:04

链表逆置For Java的相关文章

java实现单链表逆置

1 class LNode 2 { 3 public LNode next; 4 public int data; 5 } 6 /*逆置链表*/ 7 class Nizhi 8 { 9 private static LNode head = new LNode();; 10 private static LNode node; 11 private static LNode tail; 12 private static int index; 13 private static LNode ne

单链表逆置Java

package com.kpp; /** * 单链表逆置 * 将单链表从第一个结点和第二个节点之间断开,然后将第2,3...个结点依次插入第一个结点之前 * @author kpp * */ class LNode{ private String data; private LNode next; } public class LinkedListReverse { private static void reverse(LNode head){ if(head == null||head.ne

单链表逆置

重写单链表逆置,熟能生巧- #include <iostream> #include <cstdlib> using namespace std; typedef struct List{ int num; struct List *next; }ListNode,*pListNode; void display(ListNode *pHead) { while(pHead) { cout<<pHead->num<<"--"; pH

03 单链表逆置

单链表逆置 方法: <1>断开第一个数据节点和第二个数据节点的链接 <2>将后面的节点通过头插法的思想插在头节点后面 1 #include <stdio.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 // 数据结构 6 typedef struct node 7 { 8 int data; 9 struct node *next; 10 }linkList; 11 12 // 创建单链表,并

c++中的双向链表写法,主要实现(增删查改,链表逆置,构造函数,运算符重载,等)

本文主要内容 1)介绍c++中双向链表的写法. 2)实现双向链表中数据的增.删.查.改.链表逆置.链表输出 3)介绍类中构造函数.析构函数.运算符重载函数的写法 接下来介绍双向链表的成员函数:这写函数放在头文件中,方便编写 #pragma once #include<iostream> using namespace std; #include<assert.h> typedef int DataType; class ListNode  //节点 { public: ListNo

链表——逆置

给定程序中,函数fun的功能是将带头结点的单向链表逆置,即若原链表中从头至尾结点数据与依次为2.4.6.8.10,逆置后,从头至尾结点数据依次为10.8.6.4.2. 请在程序的下画线处填入正确的内容并将下画线删除,使程序得出正确的结果. 试题程序. 1 #define N 5 2 typedef struct node 3 { 4 int data; 5 struct node *next; 6 } NODE; 7 void fun(NODE *h) 8 { 9 NODE *p, *q, *r

数据结构-链表逆置(c++模板类实现)

链表结点类模板定义: 1 template <class T> 2 class SingleList; 3 template <class T> 4 class Node 5 { 6 private: 7 T element; 8 Node<T> *link; 9 friend class SingleList<T>; 10 }; 链表类末班定义: 1 template <class T> 2 class SingleList 3 { 4 pub

C语言单链表逆置的代码实现 (简单易懂版)

嗯,,这是自己写的第一篇博客哈,写的不好大家不要见怪,主要是想把自己的一些思想分享给大家.也欢迎大家指出错误,一同进步. 话不多说,直接先说想法.要把一个单链表逆置,可以大致分为下列几步.先创建一个链表.然后要考虑到链表的逆置实现.最后是链表的输出.有了这样过几步大概的想法之后,我们便要来一步步的实现啦.嗯,,创建链表就不说了,大家都会.  然后呢就是链表的逆置,这里我是采用的就地逆置法,,嗯,反正我是这么叫的,大家可以参考一下.当然啦,你得考虑到函数的形参和返回值以及指针的交接,这里如果出了问

PTA 链表逆置

6-3 链表逆置 (20 分) 本题要求实现一个函数,将给定单向链表逆置,即表头置为表尾,表尾置为表头.链表结点定义如下: struct ListNode { int data; struct ListNode *next; }; 函数接口定义: struct ListNode *reverse( struct ListNode *head ); 其中head是用户传入的链表的头指针:函数reverse将链表head逆置,并返回结果链表的头指针. 裁判测试程序样例: #include <stdi