C++将链表反转的实现

  有题目的需求是求将链表反转,例如1->2->3->4->5转变成5->4->3->2->1,经典的是可以有两种解决方法,递归方式和非递归方式,下面给出C++的这两周实现过程。

#include<iostream>
using namespace std;
const int N = 6;
typedef int DataType;//定义数据类型

typedef struct node{//创建链表node
	DataType data;
	struct node* next;
}LinkedNode,*LinkList;

LinkList CreateList(DataType a[N])//建表函数
{
	LinkedNode* ListHead = new LinkedNode();
	ListHead->data= a[0];
	ListHead->next= NULL;
	for(int i = N - 1;i >= 1;i --)
	{
		LinkedNode* p = new LinkedNode();
		p->data = a[i];
		p->next = ListHead->next;
		ListHead->next = p;
	}
	return ListHead;
}

void PrintList(LinkList ListHead)//实现的一个输出表的函数
{
	if(ListHead == NULL)
		cout<<"This is empty list"<<endl;
	else
		{
			LinkedNode* p = ListHead;
			while(p != NULL)
			{
				cout<<p->data<<" ";
				p = p->next;
			}
			cout<<endl;
		}
}
void RecReverseList(LinkedNode* pCur,LinkList& ListHead)//递归实现表的反转
{
	if( (NULL == pCur) || (NULL == pCur->next) )
	{
		ListHead = pCur;
	}
	else
	{
		LinkedNode* pNext = pCur->next;
		RecReverseList(pNext,ListHead);
		pNext->next = pCur;
		pCur->next= NULL;
	}
}
void UnRecReverseList(LinkList& ListHead)//非递归实现表的反转
{
	if(NULL == ListHead)
		return ;
	LinkedNode *pre,*cur,*nex;
	pre = ListHead;
	cur = pre->next;
	while(cur)
	{
		nex = cur->next;
		cur->next = pre;
		pre = cur;
		cur = nex;
	}
	ListHead->next= NULL;
	ListHead = pre;

}
int main()
{
	int a[N] = {1,2,3,4,5,6};
	LinkedNode* list = CreateList(a);
	PrintList(list);
	LinkedNode* pTemp = list;
	RecReverseList(pTemp,list);
	PrintList(list);
	UnRecReverseList(list);
	PrintList(list);
	return 0;
}

  运行结果:

时间: 2024-08-09 02:10:05

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;

链表反转的递归和非递归实现方式

链表反转是数据结构的基本功,主要有递归和非递归两种实现方式.我们一一介绍如下: 1. 非递归实现 主要包括如下4步: 1)如果head为空,或者只有head这一个节点,return head即可: 2)从头到尾遍历链表,把reversedHead赋值给当前节点的next: 3)当前节点赋值给reversedHead: 4)遍历结束,return reversedHead. 下图试图来辅助说明: 代码如下: node* reverseList(node* head) { if(head == NU

链表反转(递归方式,非递归方式)

//非递归方式进行链表反转 public ListNode reverseList(ListNode head){ if(head==null||head.next==null){ return head; }else { ListNode pre=head; ListNode p=head.next; ListNode next=null; while (p!=null) { next=p.next; p.next=pre; pre=p; p=next; } head.next=null; r

单链表反转的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

单向链表反转算法——递归版和迭代版

最近在做笔试题时,遇到一道编程题:单向链表反转算法.一时紧张,没写出来就提前交卷了,然而交完卷就想出来了... 最初想出来的是递归版,遗憾的是没能做到尾递归,后来又琢磨出了迭代版.后来用实际编译运行测试了一遍,能正常运行. 递归版的灵感来源于<Haskell 趣学指南>中非常简洁的快速排序算法的实现,其思想是将单向链表分割头部和尾部.其中头部指是链表的第一个节点,尾部是指除去第一个节点后的子链表.通过递归的方法,将子链表继续分割成头部和尾部,直至尾部指剩下一个节点,无法继续分割,然后将头部和尾

链表反转leetcode206

最近准备结束自己的科研生涯,准备要开始找工作了,准备在LEETCODE刷刷题...刷的前40题全部用python刷的,各种调包速度奇快,后被师哥告知这样没意义,于是准备开始回归C++,Python用的多了再用C++总是忘记敲分号和括号,甚至Compile Error了几次 = =.尴尬 链表反转比较简单,首先用自己的"本科"方法做了一下,发现效率并不高: 1 class Solution { 2 public: 3 ListNode* reverseList(ListNode* hea

数据结构——线性表——链表反转

链表反转有两种常见方式.下面从图中详细解释.其中带有部分核心代码,最后上完整代码. 迭代法 //首先定义三个变量    PNODE pre = NULL;    PNODE now = pHead->pNext;    PNODE next = NULL; next = now->pNext;//先保存下一个节点 now->pNext = pre;//当前节点的next指针指向前一个节点 pre = now;//前一个节点赋值为当前节点 now = next;//当前节点赋值为下一个节点

单链表反转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){} }; linkNod