精华内容
下载资源
问答
  • 单链表的逆置
    2022-02-07 14:41:15

    本题要求实现一个函数,将给定的单链表逆转。

    函数接口定义:

    List Reverse( List L );

    其中List结构定义如下:

    typedef struct Node *PtrToNode;
    struct Node {
        ElementType Data; /* 存储结点数据 */
        PtrToNode   Next; /* 指向下一个结点的指针 */
    };
    typedef PtrToNode List; /* 定义单链表类型 */

    L是给定单链表,函数Reverse要返回被逆转后的链表。

    裁判测试程序样例:

    ​
    
    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int ElementType;
    typedef struct Node *PtrToNode;
    struct Node {
        ElementType Data;
        PtrToNode   Next;
    };
    typedef PtrToNode List;
    
    List Read(); /* 细节在此不表 */
    void Print( List L ); /* 细节在此不表 */
    
    List Reverse( List L );
    
    int main()
    {
        List L1, L2;
        L1 = Read();
        L2 = Reverse(L1);
        Print(L1);
        Print(L2);
        return 0;
    }
    
    /* 你的代码将被嵌在这里 */
    
    [点击并拖拽以移动]
    ​

    代码一


    List Reverse( List L )
    {
      List p1=NULL,p2=NULL;
      while (L)
      {
        p2=L->Next;
        L->Next=p1;
        p1=L;
        L=p2;
      }
      return p1;
    }

    代码二:头插法

    List Reverse(List L)
    {
        List p,q;
    	p = L->Next;
    	L->Next = NULL;
    	while (p)
    	{
    		q = p;
    		p = p->Next;
    		q->Next = L->Next;
    		L->Next = q;
    	}
    	return L;
    }
    

     

    更多相关内容
  • 输入多个整数,以-1作为结束标志,顺序建立一个带头结点的单链表,之后对该单链表的数据进行逆置,并输出逆置后的单链表数据。 Input 输入多个整数,以-1作为结束标志。 Output 输出逆置后的单链表数据。 ...
  • 单链表逆置

    2015-06-24 13:02:19
    单链表逆置部分代码,应该有用,第一次上传文件
  • 单链表逆置算法详解

    2014-10-29 21:41:19
    详细描述了单链表逆转的思路及过程,并附源码
  • C++单链表逆置

    2022-03-27 11:16:28
    /*单链表逆置 :利用辅助指针,把下一节点用r指针提前保存,然后修改指向关系即可*/ struct Node { int data; Node *next; }; void CreateList(Node *Head)//创建链表 { Node *p=Head; do { Node *NewNode=...

     代码实现

    #include<iostream>
    using namespace std;
    /*单链表的逆置 :利用辅助指针,把下一节点用r指针提前保存,然后修改指向关系即可*/
    struct Node
    {
    	int data;
    	Node *next;
    };
    void CreateList(Node *Head)//创建链表 
    {
    	Node *p=Head;
    	do
    	{	
    		Node *NewNode=new Node;
    		cin>>NewNode->data;
    		NewNode->next=NULL;
    		p->next=NewNode;
    		p=NewNode;
    	}while(cin.get()!='\n');//识别到回车换行就停止输入 
    }
    void show(Node *Head)//输出数据 
    {
        Node *p;
    	p=Head->next;
    	while(p!=NULL)
    	{
    	    cout<<p->data<<' ';
    	    p=p->next;
        }
    	cout<<endl;  
    }
    void ReserveList(Node *Head)//逆置函数 
    {
    	Node *p=NULL,*r=NULL;
    	p=Head->next;
    	Head->next=NULL;
    	while(p!=NULL)
    	{
    		r=p->next;
    		p->next=Head->next;
    		Head->next=p;
    		p=r;
    	}
    }
    int main()
    {
    	Node *Head;
    	Head=new Node;
    	Head->data=0;
    	Head->next=NULL;
    	CreateList(Head);
    	ReserveList(Head);
    	show(Head);
    	return 0;
    }

    建议画图理解节点之间指向关系的修改过程 

    运行结果展示 

     

    展开全文
  • 本博客主要记录两种解决方法 (1)三指针 (3)双指针(三指针优化) (2)双指针之头插法思想 一、三指针 思想: p1主要指向前面的一个结点 p2指向中间的结点 p2->next = p1;...p3指向后面的一个结点,p3主要作用是...

    本博客主要记录两种解决方法
    (1)三指针
    (3)双指针(三指针优化)
    (2)双指针之头插法思想

    一、三指针

    思想:
    p1主要指向前面的一个结点
    p2指向中间的结点
    p2->next = p1;
    p3指向后面的一个结点,p3主要作用是当p2指向改变之后,p2结点的后面的结点如果不用一个指针指向的话,就找不到了。
    代码:

    void Reserve(ListNode*& head)
    {
    	if (head == NULL || head->next == NULL) return;
    	p1 = head;
    	p2 = p1->next;
    	p3 = p2->next;
    	while (p2 != NULL)
    	{
    		p2->next = p1;
    		p1 = p2;
    		p2 = p3;
    		if (p3 != NULL)
    		{
    			p3 = p3->next;
    		}
    	}
    	head = p1;
    }
    

    二、双指针(三指针优化)

    思想:和三指针一样的,只不过少用了一个指针,指向中间的结点的指针p2可以不需要,因为p1->next即为p2。
    代码:

    void Reserve(ListNode*& head)
    {
    	if (head == NULL || head->next == NULL) return;
    	p1 = head;
    	p2 = p1->next->next;
    	while (p1->next != NULL)
    	{
    		p1->next->next = p1;
    		p1 = p1->next;
    		if (p2 != NULL)
    		{
    			p2 = p2->next;
    		}
    	}
    	head = p1;
    }
    

    三、双指针之头插法思想

    思想:两个指针,将结点从前向后一个一个插入到前面。
    代码:

    void Reserve(ListNode*& head)
    {
    	if (head == NULL || head->next == NULL) return;
    	LIstNode* p1 = head;
    	ListNode* p2 = p1->next;
    	head->next = NULL;//第一个结点的后继为NULL,因为反转后为最后一个结点
    	while (p2 != NULL)
    	{
    		p1 = p2;
    		p2 = p2->next;
    		p1->next = head;
    		head = p1;//新头插的结点为头节点
    	}
    }
    
    
    展开全文
  • 单链表逆置C语言编程实现

    千次阅读 2021-06-13 23:14:51
    单链表逆置 #include<stdio.h> #include<stdlib.h> typedef struct node { char data;//data为结点的数据信息 struct node *next;//next为指向后继结点的指针 }LNode;//单链表结点类型 LNode *...

    单链表逆置

    #include<stdio.h>
    #include<stdlib.h>
    typedef struct node
    {
    	char data;//data为结点的数据信息
    	struct node *next;//next为指向后继结点的指针 
    }LNode;//单链表结点类型
    LNode *CreatLinkList()//在表尾生成单链表
    {
    	char x; 
    	LNode *q,*p,*head;
    	head=(LNode *)malloc(sizeof(LNode));//生成头节点
    	head->next=NULL;//*head为链表头指针
    	p=head;
    	q=p;
    	printf("Input any char string:\n");
    	scanf("%c",&x);//结点的数据类型为char型,读入结点数据
    	while(x!='\n')
    	{
    		p=(LNode *)malloc(sizeof(LNode));//申请一个空结点
    		p->data=x;
    		p->next=NULL; 
    		q->next=p; //在表插入
    		q=p;
    		scanf("%c",&x);
    	 }
    	return head;
    }
    void Convert(LNode *H)//单链表逆置 
    {
    	LNode *p,*q;
    	p=H->next;
    	H->next=NULL;//p指向剩余结点链表的第一个数据结点
    	while(p!=NULL)
    	{
    		q=p;
    		p=p->next;//剩余结点链表中取出第一个结点
    		q->next=H->next;//p继续指向剩余结点链表新的第一个数据结点
    		H->next=q; 
    	 }
    }
    int main()
    {
    	LNode *A,*p;
    	A=CreatLinkList();//在表尾生成单链表
    	Convert(A);//单链表A逆置 
    	p=A->next;//输出单链表
    	while(p!=NULL)
    	{
    		printf("%c",p->data);
    		p=p->next;
    	}
    	printf("\n"); 
     } 
    
    展开全文
  • 单链表逆置(头插法图解)

    千次阅读 2022-04-05 15:08:00
    单链表逆置(头插法图解) 算法思想: 首先将头结点摘下,重新构造链表,然后原链表中的结点依次头插到新链表中,如此循环,直到链表为空,即可逆置链表。
  • #include typedef int Element;typedef struct LinkListType{Element data;struct LinkListType * next;} LinkList ;//reverse a link list recursivelyLinkList * reverse(LinkList * pre, LinkList * cur){if(!...
  • 【数据结构】单链表逆置的详解

    千次阅读 2021-10-02 14:05:05
    单链表逆置: 定义一个前指针和一个后指针用来辅助工作指针 //头文件 #ifndef LINKLIST_H_INCLUDED #define LINKLIST_H_INCLUDED struct Node{ int data; //数据域 Node *next; //指针域 }; class LinkList{...
  • PTA 6-1 单链表逆置

    2021-10-29 21:27:48
    PTA 6-1 单链表逆置* (20 分) 已知单链表的结点结构定义如下: typedef struct NODE { int data; struct NODE *next; } NODE; 说明:data 为数据域。next 为指针域,指示后继结点。 请编写函数,将带附加头结点的...
  • 带头结点单链表逆置

    2021-03-17 20:59:04
    1:递归 2:指针法
  • //用头插法创建新链表实现逆置 p->next=L->next; L->next=p; //更新p p=r; } } 2.不带头结点 //不带头结点 void Reverse(SLink *&L){ //用指针p遍历,r为p的后继 SLink *p,*r; p=L; r=p->next; L->next=...
  • day1 牛客网刷题C语言实现单链表逆置 C语言实现单链表逆置 由于一段时间没有用数据结构 刚开始有些忘记了 第一次真正在牛客网上进行调试 原来还会有调试用例 还要设置边界值 如果没有 测试也不会通过 struct ...
  • } 方法三:栈(用栈的先进后出,单链表数据全部入栈之后,然后把带头结点的数据结点给p,数据出栈,然后覆盖原数据) 栈逆置方法1 图示: 数据入栈 数据出栈 实现代码: #include #include #include #include #...
  • ListNode* NotHeadReverse(LinkList head) { if (head == NULL || head->next == NULL) { return head; } ListNode* pre = NULL, * s = NULL, * p = head; while (p != NULL) { s = p;...}
  • 单链表的一些简单应用函数的书写
  • C语言实现不带头结点的单链表逆置的三种方法直接循环头插法递归法END! 直接循环 图片解释 ListNode* ReverseList1(ListNode *head) { if(head == NULL || head->next == NULL) { return head; } ...
  • 数据结构老师布置的作业,运用课本代码,较为基础经典,适合大学本科在上数据结构这门课的同学参考,简单易懂,关于单链表逆置问题
  • 【数据结构】单链表逆置:头插法图解

    万次阅读 多人点赞 2018-09-12 22:06:23
    算法思想:逆置链表初始为空,表中节点从原链表中依次“删除”,再逐个插入逆置链表的表头(即“头插”到逆置链表中),使它成为逆置链表的“新”的第一个结点,如此循环,直至原链表为空。 LNode *Inverse(LNode ...
  • 单链表逆置-c++-文档输出
  • 单链表逆置问题

    2021-07-17 13:39:33
    using namespace std; typedef struct SLnode { int data; struct SLnode* next; }SLnode; void crealist(SLnode &head,int a[],int n) { head=(SLnode)malloc(sizeof(SLnode)); SLnode *p=head;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 8,791
精华内容 3,516
关键字:

单链表的逆置

友情链接: pqninbrp.zip