【链表】实现单链表的逆序

 1 public class Main {
 2
 3     // 就地逆序法
 4     public Node reverse(Node head) {
 5         // no need to reverse
 6         if (head == null || head.next == null || head.next.next == null) {
 7             return head;
 8         }
 9
10         // pointer
11         Node pre = head;
12         Node cur = head.next;
13         Node nex = head.next.next;
14
15         while (nex != null) {
16             if (cur == head.next)  // the first node‘s next node is null
17             {
18                 cur.next = null;
19             } else {
20                 cur.next = pre;
21             }
22
23             pre = cur;
24             cur = nex;
25             nex = nex.next;
26         }
27
28         cur.next = pre;
29         head.next = cur;
30
31         return head;
32     }
33
34     // 插入法
35     public Node reverse2(Node head) {
36         if (head == null || head.next == null) {
37             return head;
38         }
39
40         Node p1 = head.next;
41
42         Node p = null;
43
44         while (p1.next != null) {
45             p = p1.next;
46             p1.next = p.next;
47             p.next = head.next;
48             head.next = p;
49         }
50
51         return head;
52     }
53
54     public Node createListNodes() {
55         Node node7 = new Node(7, null);
56         Node node6 = new Node(6, node7);
57         Node node5 = new Node(5, node6);
58         Node node4 = new Node(4, node5);
59         Node node3 = new Node(3, node4);
60         Node node2 = new Node(2, node3);
61         Node node1 = new Node(1, node2);
62         Node head = new Node(0, node1); // head pointer
63
64         return head;
65     }
66
67     public static void main(String[] args) {
68         Main main = new Main();
69         Node node = main.reverse(main.createListNodes());
70
71         if (node == null) {
72             System.out.println("head is null");
73             return;
74         }
75
76         while (node.next != null) {
77             System.out.println(node.next.data);
78             node = node.next;
79         }
80
81         Node node2 = main.reverse2(main.createListNodes());
82
83         if (node2 == null) {
84             System.out.println("head is null");
85             return;
86         }
87
88         while (node2.next != null) {
89             System.out.println(node2.next.data);
90             node2 = node2.next;
91         }
92     }
93
94 }

原文地址:https://www.cnblogs.com/jiangyi-uestc/p/10051358.html

时间: 2024-08-03 05:19:20

【链表】实现单链表的逆序的相关文章

设计鲁棒性的方法:输入一个链表的头结点,逆序遍历打印该链表出来

之前有过整理链表等的概念和基本算法.比较重要的是插入,删除,遍历,建表(尾插法,头插法) 回忆链表尾部插入结点:  1 #include <iostream> 2 using namespace std; 3  4 typedef struct Node{ 5     int data;//数据域 6     Node *next;//指针域 7 } Node, *List; 8  9 //在单链表的末位添加一个结点10 void addNode(List *head, int value)1

数据结构 链表_单链表的接口定义

链表可以说是一种最为基础的数据结构.链表由一组元素以一种特定的顺序组合或链接而成,在维护数据的集合时很有用.这一点同我们常用的数组很相似.然而,链表在很多情况下比数组更有优势.特别是在执行插入和删除操作时链表拥有更高的效率.链表需要动态的开辟存储空间,也就是存储空间是在程序运行时分配的.由于在很多应用中数据的大小在编译时并不能确定,因此这种动态分配空间的特性也是链表的一个优点. 单链表介绍 单链表(简称为链表)由各个元素之间通过一个指针彼此链接起来而组成.每个元素包含两个部分:数据成员和一个称为

(单链表)单链表的整体逆序和局部逆序

题目一:将单链表翻转. 思路:有三种方式. 一:用数组存储单链表的值,然后重新逆序赋值,效率较低. 二:利用三个指针,在原来的基础上进行逆序.这种方法比较实用,效率也高. 三:从第2个节点到第N个节点,依次逐节点插入到第1个节点(head节点)之后,最后将第一个节点挪到新表的表尾.需要新建一个链表,这种方法和第二种差不多. 这里我就写出第二种方法,比较实用. 代码(方法二): struct ListNode { int val; ListNode *next; ListNode(int x) :

用单链表来实现数据的逆序

#include<stdio.h>#include<stdlib.h> typedef struct node{ int data;//节点数据 struct node *next;//节点指针,该指针指向该节点的下一节点}listnode,*list;//list指向该节点//初始化单链表list initlist(void){ list mylist=malloc(sizeof(listnode));//malloc分配空间,创建节点,以此为头节点,并用指针mylist指向它

链表——将单链表从m到n的结点位置翻转

题目:反转链表从m-n位置的结点 For example: Given1->2->3->4->5->NULL, m = 2 and n = 4, return1->4->3->2->5->NULL. 从第二到第四的结点被反转了. 其中m和n满足条件: 1 ≤ m ≤ n ≤ length of list. 思路: 仍是逆序,仍考虑到用辅助空间stack. 将m-n的结点依次入栈,并标记与入栈结点相邻的前后两个结点pfirst和psecond (若

【数据结构-链表】单链表

链表 特点 链表是通过任意的存储单元来存储线性表中的数据元素 链表组成 链表是由很对节点组成 带有头结点的单链表 typedef struct{ struct node *head;//链表的头结点 }LinkList; 节点结构 typedef struct node{ int data; struct node *next; }Node; 链表的插入操作 首先得到插入位置的节点n 得到插入位置的前一个节点pre 讲新插入的节点的next指针指向n pre节点的next指向n /** * 在p

【算法设计-链表】单链表与双向循环链表

1.单链表代码:包含了尾插法,插入,删除操作. 有头结点的单链表也是为了在第一个位置插入和删除时候容易,不需要另外讨论 #include<stdio.h> #include<stdlib.h> typedef struct Linklist { int key; Linklist *next; }Linklist; Linklist* create_end() { Linklist *head=(Linklist *)malloc(sizeof(Linklist)); Linkli

Python与数据结构[0] -&gt; 链表[0] -&gt; 单链表与带表头单链表的 Python 实现

单链表 / Linked List 目录 单链表 带表头单链表 链表是一种基本的线性数据结构,在C语言中,这种数据结构通过指针实现,由于存储空间不要求连续性,因此插入和删除操作将变得十分快速.下面将利用Python来完成单链表的实现. 1 单链表 不带表头的单链表通常形式如下, node_1 -> node_2 -> node_3 -> node_4 完整代码 1 class Node: 2 def __init__(self, val=None, nxt=None): 3 self.v

数据结构:链表(单链表)

一.链表 概念:链表[Linked List]是由一组不必相连(可连续可不连续)的内存结构(节点),按照特定的顺序链接在一起的抽象数据类型: 分类:链表常用的大概有三类:单链表.双向链表.循环链表(这篇文章主要讲单链表) 操作:链表的核心操作主要有三个(查找遍历.插入.删除) 二.单链表 上图就是一个单链表的数据结构了,从上图可以看出,每个节点包含两个重要的元素(data.next),那么什么是单链表呢? 概念:各个内存结构通过一个Next指针链接在一起,每个内存结构都存在后续的内存结构(链尾除

[程序员代码面试指南]链表问题-单链表的选择排序(选择排序)

题意 给定一个无序单链表的头节点head,实现单链表的选择排序. 题解 按选择排序方法:每次从原链表找出最小值,从原链表删除,插入新的有序链表. 时间复杂度O(n^2) 额外空间复杂度O(1) 代码 public class Main { public static void main(String args[]) { Node n1=new Node(2); Node n2=new Node(1); Node n3=new Node(3); n1.next=n2; n2.next=n3; No