用栈实现单链表的逆转

#include<iostream>
#include<stack>
using namespace std;
struct ListNode
{
   ListNode *next;
   int data;
   ListNode(int x):
   {
      data=x;
      next=NULL:
   }
};
  ListNode* ReverseList(ListNode* pHead) {
        if(pHead==NULL||pHead->next == NULL)
        {
            return pHead;
        }
        ListNode * p=pHead;
        ListNode * newHead;
        stack<ListNode *> stack1;
        while(p->next!=NULL)
        {
            stack1.push(p);
            p=p->next;
        }
        newHead = p;
        while(!stack1.empty())
        {
          p->next=stack1.top();
            p=p->next;
            stack1.pop();
        }
        p->next=NULL;
        return newHead;

}
int  mian()
{
 struct  ListNode *head;
  ReserveList(head);
return 0;
}

时间: 2024-10-13 12:33:32

用栈实现单链表的逆转的相关文章

单链表的逆转

算法导论:10.2-7 给出一个 O(n) 时间的非递归过程,实现对一个含有 n 个元素的单链表的逆转.要求除存储链表本身所需的空间外,该过程只能使用固定大小的存储空间. #ifndef _SINGLY_LINKED_LIST_H #define _SINGLY_LINKED_LIST_H /*********************************************************** 10.2-7 单链表类,并实现了在 O(n) 时间内链表的逆转 ***********

PTA 单链表分段逆转

6-9 单链表分段逆转 (25 分) 给定一个带头结点的单链表和一个整数K,要求你将链表中的每K个结点做一次逆转.例如给定单链表 1→2→3→4→5→6 和 K=3,你需要将链表改造成 3→2→1→6→5→4:如果 K=4,则应该得到 4→3→2→1→5→6. 函数接口定义: void K_Reverse( List L, int K ); 其中List结构定义如下: typedef struct Node *PtrToNode; struct Node { ElementType Data;

python中栈的单链表实现

参考博客:https://www.cnblogs.com/stacklike/p/8284550.html 基于列表的简单实现 # 先进后出 # 以列表实现的简单栈 class SimpleStack: # 特殊属性,用以限制class可添加的属性 __slots__ = ('__items',) def __init__(self): self.__items = [] def is_empty(self): return self.__items == [] def peek(self):

两种方法(递归,非递归)实现单链表的逆转

//普通方法实现链表的逆置 void reverseList(pNode *head) { pNode p, q, r; if (*head == NULL || (*head)->next == NULL) return; q = *head; p = q->next; r = NULL; while (p){ q->next = r; r = q; q = p; p = p->next; } q->next = r; *head = q; } //递归法实现链表的逆置 p

【算法设计-单链表的逆转】单链表逆转实现

1.在Θ(n)时间内将链表转置,而且只能需要少量的额外空间 这里需要用3个指针使得q指向p然后依次后移. 代码: #include<iostream> using namespace std; typedef struct Node { int data; struct Node *next; }LinkList; LinkList* Create_End(); void printLinkList(LinkList *L); LinkList* Create_End() { LinkList

Javascript - 栈 和 单链表

最近在重温数据结构,于是写了一些代码玩玩,都是很初级的,表喷各位.... function Stack() { this.dataStore = []; this.top = 0; } Stack.prototype = { length: function () { return this.top; }, push: function (element) { this.dataStore[this.top++] = element; return this.top; }, pop: funct

单链表就地逆转

template<typename LinkList> void converse(LinkList*L) { LinkList *p, *q; p = L->next; L->next = NULL; while (p) { q = p; p = p->next; q->next = L->next; L->next = q; } }

单链表的逆转(测试数据)

测试数据: 有尾巴不反转 地址取到上下界 正好全反转(K的整数倍) K=N全反转                                边界测试 K=1不用反转 最大(最后剩K-1不反转).最小N 有多余结点

单链表逆转问题

实现对含有n个元素的单链表的逆转,要求运行时间O(n),除了链表本身所需空间外,只使用固定大小的存储空间.(此题来自<算法导论>10.2-7) 从头元素开始循环,将原本指向其后继节点的指针指向其前驱节点,直到循环至哨兵为止.整个过程额外需要三个指针变量的空间,分别保存当前节点及其前驱.后继. 下面是一个简单的C++实现. struct Node { Node* pNext; int key; }; class SingleLinkedList { public: SingleLinkedLis