单链表反转C语言实现

单链表的反转可以使用循环,也可以使用递归的方式

1.循环反转单链表

循环的方法中,使用pre指向前一个结点,cur指向当前结点,每次把cur->next指向pre即可。

代码:

# include <iostream>
# include <cstdlib>
using namespace std;

struct linkNode
{
int val;
linkNode *next;
linkNode(int x):val(x),next(NULL){}
};
linkNode *reverse2(linkNode *head)
{
	if(head==NULL)
		return NULL;
	linkNode *pre=NULL;
	linkNode *p=head;
	linkNode *h=NULL;
	while(p)
	{
		h=p;
		linkNode *tmp=p->next;
		p->next=pre;
		pre=p;
		p=tmp;
	}
	return h;         //返回头结点
}
int main()                //测试代码
{
	linkNode *head=new linkNode(1);
	linkNode *p1=new linkNode(2);
	linkNode *p2=new linkNode(3);
	head->next=p1;
	p1->next=p2;      //建立链表   1->2->3->NULL
	linkNode *p=reverse2(head);
	while(p)
	{
		cout<<p->val<<endl;
		p=p->next;
	}                //输出为  3->2->1->NULL
system("pause");
return 0;
}

2.递归实现单链表反转

# include <iostream>
# include <cstdlib>
using namespace std;

struct linkNode
{
int val;
linkNode *next;
linkNode(int x):val(x),next(NULL){}
};

linkNode *reverse(linkNode *head,linkNode * &newhead)   //head为原链表的头结点,newhead为新链表的头结点
{
if(head==NULL)
	return NULL;
if(head->next==NULL)
{
		newhead=head;
}
else
{
	reverse(head->next,newhead);
	head->next->next=head;
	head->next=NULL;
}
return newhead;
}

int main()                                  //测试代码
{
	linkNode *head=new linkNode(1);
	linkNode *p1=new linkNode(2);
	linkNode *p2=new linkNode(3);
	head->next=p1;
	p1->next=p2;                            //建立链表1->2->3->NULL;
	linkNode *newhead=NULL;
	linkNode *p=reverse(head,newhead);
	while(p)
	{
		cout<<p->val<<endl;
		p=p->next;
	}                                   //输出链表 3->2->1->NULL;
system("pause");
return 0;
}

单链表反转C语言实现

时间: 2024-10-02 19:55:54

单链表反转C语言实现的相关文章

单链表反转问题

单链表反转问题 基本问题 如何将单链表反转? 算法实现 /** * * Description: 单链表反转. * * @param head * @return ListNode */ public static ListNode reverseList(ListNode head) { if (head == null) { return head; } ListNode prev = null; ListNode current = head; ListNode next = null;

单链表反转的2种方法

1 public class ReverseDemo { 2 3 /** 4 * 单链表反转的两种方法 5 */ 6 public static void main(String[] args) { 7 Node head =new Node("a"); 8 Node node2=new Node("b"); 9 Node node3=new Node("c"); 10 head.setNext(node2); 11 node2.setNext(

链表 单链表反转

思路1:O(n^2). “狸猫换太子”,不进行改动链表结构,只首尾交换len/2次.但是在本函数中用到了定位函数,定位函数实际上是遍历了一遍整个链表,所以综合效率很低,达到O(n^2). //单链表反转(O(n^2)) void reverseList(Node* Head) { int count = numOfNodes(Head); //首尾交换 for(int i=1; i<=count/2; i++) { Node* p1 = locateNodeI(Head, i); Node* p

单链表反转python实现

单链表的反转可以使用循环,也可以使用递归的方式 1.循环反转单链表 循环的方法中,使用pre指向前一个结点,cur指向当前结点,每次把cur->next指向pre即可. 代码: class ListNode: def __init__(self,x): self.val=x; self.next=None; def nonrecurse(head): #循环的方法反转链表 if head is None or head.next is None: return head; pre=None; c

数据结构 单链表反转 回顾练习

之前写了一个单链表反转,但是使用的新的空间. 这次的反转是不修改原来的结构,直接将节点内的元素进行修改 1 #!/usr/bin/env python3 2 3 class LNode(object): 4 def __init__(self, elem, next_=None): 5 self.elem = elem 6 self.next = next_ 7 8 class ListError(Exception): 9 pass 10 11 class LList(object): 12

单链表反转(Singly Linked Lists in Java)

单链表反转(Singly Linked Lists in Java) 博客分类: 数据结构及算法 Java代码   package dsa.linkedlist; public class Node<E>{ E data; Node<E> next; } Java代码   package dsa.linkedlist; public class ReverseLinkedListRecursively { public static void main(String args[])

单链表反转java代码

据说单链表反转问题面试中经常问,而链表这个东西相对于数组的确稍微难想象,因此今天纪录一下单链表反转的代码. 1,先定义一个节点类. 1 public class Node { 2 int index; 3 Node next; 4 5 public Node(int index, Node next) { 6 this.index = index; 7 this.next = next; 8 } 9 } 2,我一共写了三种方法 (1)迭代法.先将下一节点纪录下来,然后让当前节点指向上一节点,再将

时间复杂度为O(n)的非递归单链表反转【算法导论课后题】

单链表反转:1->2->3->4... 思路:先将1指向3,2指向1,结果为2->1->3->4,然后循环将3插入到2之前 <span style="font-size:18px;">void reverseLinkedList(List head) { List tmp,p; if(head==null) { return ; } tmp=head->next; while(tmp->next !=null){ p=tmp-

单链表反转(2)

今天会介绍另外一种反转单链表的方法,对于单链表反转这一类的算法,最重要的思想就是用临时变量来记住需要记住的节点.一个不够,那就用两个,或者用三个临时变量. 这次还是以图表来表现算法的过程,不同于上一篇,这次的头节点使用链表中的第一个节点. 该方法的思想就是遍历每个节点,将其插入到第一个节点之后. 如下图为链表的初始状态: 为了不断链,先将 P2 的后驱节点指向 P3 的后驱节点. 将P3插入 P1 和 P2 之间,也就是 将 P1 的后驱指向 P3.将 P3 的后驱指向 P2 P3 指向 P2