单向链表的逆置

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

typedef struct list LIST;
struct list
{
    int data;
    struct list *next;
};

void print_list(struct list *p)
{

    struct list *head = p;
    while (head)
    {
        printf("data = %d\n", head->data);
        head = head->next;
    }

}

//单向链表的逆置
void reverse(struct list *p)
{
    if (p == NULL)
        return;

    if (p->next == NULL || p->next->next == NULL)
        return;

    struct list *last = p->next;

    struct list *cur = p->next;
    struct list *pre = p;
    struct list *next = NULL;

    while (cur)
    {
        next = cur->next;
        cur->next = pre;
        pre = cur;
        cur = next;
    }
    p->next = pre; //未逆置前的首节点指向尾节点
    last->next = NULL;
}

int main()
{
    struct list* p1 = calloc(1, sizeof(struct list));
    struct list* p2 = calloc(1, sizeof(struct list));
    struct list* p3 = calloc(1, sizeof(struct list));
    struct list* p4 = calloc(1, sizeof(struct list));
    struct list* p5 = calloc(1, sizeof(struct list));
    p1->data = 1;
    p1->next = p2;

    p2->data = 2;
    p2->next = p3;

    p3->data = 3;
    p3->next = p4;

    p4->data = 4;
    p4->next = p5;

    p5->data = 5;
    p5->next = NULL;

    reverse(p1);
    print_list(p1);

    free(p5);
    free(p4);
    free(p3);
    free(p2);
    free(p1);
    return 0;
}

原文地址:https://www.cnblogs.com/dquery/p/8977970.html

时间: 2024-10-21 14:20:31

单向链表的逆置的相关文章

如何在时间复杂度为O(n)空间复杂度为O(1)的情况下完成链表的逆置

问题如题目,首先分析,链表的反转的空间复杂度如果为常数级,那么不可能完成从堆中申请数据来完成链表的反转工作,所以问题就转化为了如何将原链表修改/拆解为逆置的链表: 函数形式假定如下  void Inverse(List*&head)//////修改原链表为逆置 第一种办法最简单,就是在创建一个局部变量 List*tail 作为产生的新链表的“尾部”,再设置一个“游标”指针用于指向当前正在访问的链表单元,然后按顺序循环遍历链表,在遍历的同时将正在访问的链表单元添加到新链表尾部的“tail”指针前面

数据结构实验之链表三:链表的逆置

数据结构实验之链表三:链表的逆置 Time Limit: 1000MS Memory limit: 65536K 题目描述 输入多个整数,以-1作为结束标志,顺序建立一个带头结点的单链表,之后对该单链表的数据进行逆置,并输出逆置后的单链表数据. 输入 输入多个整数,以-1作为结束标志. 输出 输出逆置后的单链表数据. 示例输入 12 56 4 6 55 15 33 62 -1 示例输出 62 33 15 55 6 4 56 12 提示 不得使用数组. 来源 示例程序 /*************

(转)单链表的逆置

对于单链表的逆置有两种方法可以实现: (1)利用辅助指针 基本思想:在遍历结点过程中,设置辅助指针,用于记录先前遍历的结点.这样依次编译的过程中只需修改其后继结点的next域即可. 实现代码: 1 typedef int DataType; //类型定义 2 typedef struct node{ //单链表定义 3 DataType data; 4 struct node* next; 5 }LinkedNode,*LinkList; 6 void ReverseList(LinkList&

数据结构与算法-链表就地逆置

链表操作,单链表就地逆置 void Inverse(LinkList &L) { LNode *p, *q; p = L->next; /*记录第一个结点地址*/ L->next = NULL; /*把链表设置成空表*/ while (p != NULL) /*依次按头插法将各结点插入,就实现了逆置*/ { q = p; /*用q记录待插入结点地址*/ p = p->next; /*用p记录待插入结点的后继结点地址*/*/ q->next = L->next; /*将

数据结构之 线性表--链表的逆置

数据结构实验之链表三:链表的逆置 Time Limit: 1000MS Memory limit: 65536K 题目描述 输入多个整数,以-1作为结束标志,顺序建立一个带头结点的单链表,之后对该单链表的数据进行逆置,并输出逆置后的单链表数据. 输入 输入多个整数,以-1作为结束标志. 输出 输出逆置后的单链表数据. 示例输入 12 56 4 6 55 15 33 62 -1 示例输出 62 33 15 55 6 4 56 12 #include <iostream> #include <

单链表的逆置--普通循环方法(详细图解)

关于单链表的逆置,大家都很清楚有两种基本方法:(1)普通的循环的方法.(2)递归调用方法.今天正好研究这两种方法,发现很不理解代码这么写的具体的作用,诚如很多人所说,吃透这个还是要自己画一个详细的过程图.今天就给大家介绍一下(普通的循环方法)我学习下来的一些经验,如有不对之处还望大家一起交流. 首先,以下是关于单链表逆置的普通循环方法的代码: //单链表定义 typedef struct ListNode{ int m_nValue; ListNode* pNext; }; //单链表逆置实现

链表习题(3)-将带头结点的链表进行逆置

1 /*将带头结点的链表进行逆置*/ 2 /* 3 算法思想:设逆置链表尾空,将原链表中的结点依次删除后,按头插法插入逆置链表中,直至 4 原链表为空 5 */ 6 void Reverse(LinkList& L) 7 { 8 LNode *p, *q; 9 p = L->next; 10 L->next = NULL; 11 while (p) 12 { 13 q = p; 14 p = p->next; 15 /*头插法*/ 16 q->next = L->ne

java版的单向链表的逆序输出

将单向链表逆序输出,方法有三种: a.遍历链表,将每个节点的内容存入一个数组中,然后逆序输出数组(最简单的做法) b.使用栈来逆序输出 c.直接将链表逆序然后输出(本文采用的方法) 先介绍算法: 1). 若链表为空或只有一个元素,则直接返回: 2). 设置两个前后相邻的指针p,q. 将p所指向的节点作为q指向节点的后继: 3). 重复2),直到q为空 4). 调整链表头和链表尾 示例:以逆序A->B->C->D为例,图示如下 package com.moluo.shujujiegou;

单链表就地逆置

题目:有一个线性表(a1,a2,a3,...,an),采用带头节点的单链表L存储,设计一个算法将其就地逆置,线性表变为(an,...a3,a2,a1).所谓"就地"指辅助存储空间为O(1). 解题思路: 如果是顺序存储的话,我们很容易想到解题思路,利用1个辅助变量让第1个元素与第n个元素交换,然后再利用这个辅助变量让第2个元素与第n-1个元素交换,...最后利用这个辅助变量让第n/2个元素与第n+1-n/2个元素交换. 如果不要求"就地"的话,可以创建一个n个元素辅