精华内容
下载资源
问答
  • 链表反向输出

    千次阅读 2016-11-12 16:11:29
    第二种方式,使用栈,遍历链表,最后遍历的节点先输出,是符合栈。第三种方式栈相当于一个递归调用,但如果递归层次太多,会使得栈溢出. 本文第二种方式实现如下:// test.cpp : 定义控制台应用程序的入口点。 //#...

    有三种方式:第一种方式,改变链表指向,使末节点成为首节点。第二种方式,使用栈,遍历链表,最后遍历的节点先输出,是符合栈。第三种方式栈相当于一个递归调用,但如果递归层次太多,会使得栈溢出. 本文第二种方式实现如下:

    // test.cpp : 定义控制台应用程序的入口点。
    //
    
    #include "stdafx.h"
    #include <stdio.h>
    #include<malloc.h>
    #include <string>
    #include <iostream>
    #include<stack>
    using namespace  std;
    struct ListNode
    {
    int data;
    ListNode *next;
    };
    void printReverse(ListNode *head)
    {
    ListNode *p;
    p = head;
        if(head == NULL)
        return;
    std::stack<ListNode*>nodes;
        while(p)  //入栈
        {
            nodes.push(p);
            p = p->next;
        }   
        while(!nodes.empty())  //出栈
        {
            p =  nodes.top();
            printf("%d\n",p->data);
            nodes.pop();
        }
    
    }
    int _tmain(int argc, _TCHAR* argv[])
    {
        //新建链表
        ListNode *head,*temp,*p;
        head  =(ListNode*) malloc(sizeof(ListNode));
        head->next = NULL;
        for(int i =0;i<5;i++)
        {
            temp =(ListNode*) malloc(sizeof(ListNode));
            temp->data = i;
            temp->next = NULL;
            if(i == 0)
            {
                head = temp;
                p = head;
            }
            else
            {
    
                p->next = temp;
                p = p->next;
            }
    
        }
        printReverse(head);
        //释放链表
        p = head;
        while(p != NULL)
        {
        temp = p->next;
        free(p);
        p = temp;
    
        }
    
        system("pause");
        return 0;
    }
    
    
    展开全文
  • 链表反向输出 offer05的要求是,给出和一个链表,要求反向输出。这里先给出一个[1,2,3,4,5]的链表 from linklist import ListNode, LinkList l = LinkList() for i in range(1,6,1): l.append(i) node = l.head ...

    链表结构

    关于链表的结构请参考:
    《剑指offer》预备知识-链表与二叉树
    我会直接调用里面定义的这个链表的类(但不调用大部分的类方法,不然就是出猫了→_→)。

    链表反向输出

    offer05的要求是,给出和一个链表,要求反向输出。这里先给出一个[1,2,3,4,5]的链表

    from linklist import ListNode, LinkList
    
    l = LinkList()
    for i in range(1,6,1):
        l.append(i)
    node = l.head
    

    如果对数据结构有了解的话,就会第一时间考虑一个栈。请把栈想象成一个量筒,然后我们往里面装乒乓球(元素);当我们要取乒乓球的时候,就会有先进后出,后进先出的情况。这很符合题目的要求。因此用一个栈把链表里的元素记下来,然后输出即可。

    # offer05-solution
    def printListFromTailToHead(listNode):
        if not listNode:
            return []
        res = []
        while listNode.next is not None:
            res.append(listNode.val)
            listNode = listNode.next
        res.append(listNode.val)
        print(res[::-1])  # res相当于一个栈,先进后出,后进先出
        return
    
    printListFromTailToHead(node)
    

    链表反转

    offer21直接要求反转链表。

    # offer21-solution
    def ReverseList(pHead):
        pre = None  # 前一个
        now = pHead  # 现在
        rear = None  # 后一个
        while now:
            rear = now.next  # 后指针向后移一位
            now.next = pre  # now指向前指针
            if not rear:  # now已经是原链表尾部,现链表头部
                return now
            pre = now  # 前指针向后移一位
            now = rear # 现指针向后移一位
    
    ReverseList(node)
    

    我使用的是一种三指针的形式。链表类的题目,一定要把图画出来,这种三指针的形式迭代的方法如下。

    我也看到有利用双指针完成的思路,但是我自己没写出来,这里附上给大家参考。

    小结

    链表类的问题还有很多,这两个应该是比较典型的逆序问题。其中offer21会相对较难,自己搞的时候要上图理解。
    参考:
    【图文解析】反转一个单链表

    展开全文
  • 使用C的链表反向输出

    2019-01-16 22:12:03
    反向输出链表,在没有学习堆栈的情况下首先想到的是将链表数据储存在数组中,然后逆序输出,但是觉得如果数据量比较大的话,既费时又占内存。想将链表逆序链接,如何操作呢?递归也可以实现最后的数据先输出,如果...

    反向输出链表,在没有学习堆栈的情况下首先想到的是将链表数据储存在数组中,然后逆序输出,但是觉得如果数据量比较大的话,既费时又占内存。想将链表逆序链接,如何操作呢?递归也可以实现最后的数据先输出,如果学习了栈的话,应该知道是先进后出的,也可以实现。

    -----------------------------------

    typedef struct LinkNode
    {
        int data;
        struct LinkNode * next;
    }LNode,* LinkList;

    ----------------------------------------

    一、链表反向链接

    把前面的节点一个一个拆出来,在一个一个的链接上。

    LinkList revlinklist(LinkList head)
    {
        LinkList currentNode, preNode, nextNode;
        currentNode = head;
        preNode = NULL;
        nextNode = NULL;
        if (head == NULL)
            return NULL;
        while (currentNode)
        {
            nextNode = currentNode->next;
            currentNode->next = preNode;
            preNode = currentNode;
            currentNode = nextNode;
        }
        return preNode;
    }

    二、使用递归

    void showLink(LinkList head)
    {
        LinkList current;
        current = head->next;
        if (head == NULL)
            printf("NULL!\n");
        if(current!=NULL)
            showLink(current);
        printf("%d ->", head->data);
    }

    其实递归的本质也是利用了栈。

    三、使用栈

    (待补充)。

    展开全文
  • STL链表反向输出实例

    千次阅读 2016-08-30 23:34:43
    C++ list反向输出/反转实例 给定一个单向链表,从尾到头输出其每个值。 代码: #include #include "stdio.h" #include #include using namespace std;//从尾到头输出list--1.递归方法 void list_reverse1(list...

    C++ STL list反向输出实例

        给定一个单向链表,从尾到头输出其每个值。
    代码:

    #include <iostream>
    #include "stdio.h"
    #include <list>
    #include <stack>
    using namespace std;
    
    //从尾到头输出list--1.递归方法 
    void list_reverse1(list<int> &mylist, list<int>::iterator &it)//传递引用比传值副本更高效 
    {
        if(mylist.empty()) //判断list是否为空,如果没有判断即便链表为空后面仍会执行一遍cout 
            return;
        it++;
        if(it != mylist.end())
        {
            list_reverse1(mylist, it);  
        }
        cout<<*(--it)<<endl; 
        /**
        *这里要注意一点是it是对象的引用或者理解为对象指针,
        *所以对它的值得修改(it++) 会影响递归的其他轮回。
        *所以最后输出时要进行--it
        */ 
    }
    
        /**
        *递归有个通病,就是当递归次数过长,比如这里的链表过长时,可能会导致函数调用栈溢出.
        *可以用下面循环的方式实现避免这个问题. 
        */ 
    
    //从尾到头输出list--2.栈+循环方法
        /**
        * list是从头到尾循迹的,要将其从尾到头输出, 会想到stack栈结构,
        *所以可以先把list一一取出放到stack暂存.然后后面只需要迭代输出stack即可.
        *这个思想同样可以用于list的反转 
        */
    void list_reverse2(list<int> &mylist)
    {
        stack<int> mystack;
        if(mylist.empty()) //判断list是否为空,如果没有判断即便链表为空后面仍会执行一遍cout 
            return;
        list<int>::iterator it = mylist.begin();
        while(it != mylist.end())
        {
            mystack.push(*it);
            it++;
        }
        while(!mystack.empty())
        {
            cout<<mystack.top()<<endl;
            mystack.pop();  
        }
    }
    
    int main()
    {
        list<int> mylist;
        for(int i=0; i < 5; i++)
            mylist.push_back(i);
        list<int>::iterator it = mylist.begin();
    
        //逆序输出 
        cout<<"逆序输出" <<endl;
        //list_reverse1(mylist, it);
        list_reverse2(mylist);
    
        //顺序输出 
        cout<<"顺序输出" <<endl;
        for(it = mylist.begin(); it != mylist.end(); it++)
            cout<<*it<<endl;
    
    
        return 0;
    }
    

    运行输出:

    逆序输出
    4
    3
    2
    1
    0
    顺序输出
    0
    1
    2
    3
    4
    
    --------------------------------
    Process exited after 0.01161 seconds with return value 0
    请按任意键继续. . .
    

    如果是头指针版本的链表,反向输出链表的思想一样,只是代码是用指针来处理,一样要用到递归。

    markdown插入整段代码时发现只有第一行被当做是代码怎么破:

    选定其他的代码,继续摁一下ctrl+k插入代码键就ok了。
    展开全文
  • #include <iostream> #include <stack> using namespace std; struct Node { int value; Node * next; Node(int a) { value = a; } }; Node* reverse(Node* pHead)... if (pHead == nullptr || p...
  • #include "stdio.h" #include "stdlib.h" struct node\\建立一个结构体 { int number; struct node *next; }; int main() {struct node *makelist();\\声明数据指针型函数makelist ...\\反向输出 } }
  • #define N 3 #define LEN sizeof(struct list) #define NULL 0 #include<...调试后,构造链表函数没有问题,直到输出函数,p->next=NULL,到这里发现head->next 也是NULL了 ,怎么改善?
  • i 程序输出结果如下: We%20Are%20Happy 三、反向链表输出问题 Q:输入一个链表,按链表从尾到头的顺序返回一个ArrayList。 A:分析:可通过借助栈(Stack)的后进先出特性或创建另一个ArrayList用于反向遍历存储返回...
  • **方法一:**利用递归的思想,将链表反向的值反向输出 **方法二:**借助栈,将链表的值按顺序压入栈中,然后再输入栈中的值 二.源代码 方法一. //从尾到头输出单链表中的值 void ReversePrint(List list) { if ...
  • 双循环链表是指,每个结点都有指向下一个结点的指针和指向前一个结点的指针。同时,尾结点的next域指向头结点,头结点的prior域指向尾结点。 C语言代码实现 #include <stdio.h> #include <stdlib.h> ...
  • 反向输出链表

    2017-12-30 19:44:06
    输入一个链表,用反向输出链表的节点。 可以用栈保存的遍历的链表节点的值。然后用栈先进后出的特点。就可以实现从尾到头输出节点值。#include #include #include #include #include #include using namespace std;...
  • 链表反向输出 1.反转链表 2.链表节点从头到尾入栈,在出栈 */ # include # include # define SIZE 5 //初始定义链表的长度 //定义节点 typedef struct Node { int data; struct Node * pNext; }NODE, * ...
  • 对于链表反向输出元素看起来非常简答,如果使用java编程的有以下几种思路 思路一、遍历两次链表 第一次遍历的时候计算链表的长度 根据链表的长度来定义数组 第二次遍历链表的时候按照数组的下标从后往前来放入...
  • // 测试输入的第二个参数大于链表的结点总数 void Test5() { printf("=====Test5 starts:=====\n"); ListNode* pNode1 = CreateListNode(1); ListNode* pNode2 = CreateListNode(2); ListNode* pNode3 = ...
  • 给定一个链表反向输出。 考察知识 链表的创建以及常规操作 栈的使用 解题思路 先进去的后输出,自然想到是栈的特点,故使用栈来实现。递归的本质也是栈。 完整代码 /*03_printlist*/ #include<iostream> #...
  • 问题描述:反向输出一个链表 源代码: #!/usr/bin/python # -*- coding: UTF-8 -*- if __name__ == '__main__': ptr = [] for i in range(5): num = int(raw_input('please input a number:\n')) ptr.a...
  • C语言反向输出链表.

    2021-04-07 07:12:49
    无法正确反向输出链表 <code>#include <stdio.h> #include "string.h" #include "stdlib.h" typedef struct node { int data; struct node* next; }Node; int main() { struct node *...
  • 编写一个函数,检查输入的链表是否是回文的。 示例 1: 输入: 1->2 输出: false 示例 2: 输入: 1->2->2->1 输出: true 链表的形式,我们可以直接将其转化为数组,采用while循环,head链表形式,...
  • Java实现反向输出链表

    千次阅读 2018-04-20 23:57:29
     题目解析:一般从尾到头打印链表结点的值的话,可以想到将链表结点的指针反转过来,改变链表方向,这样相当于从头到尾输出了,但是这样就改变了链表的结构。打印通常只是一个只读操作,并不希望改变链表的数据结构...
  • 剑指offer:反向输出链表 思路:使用stack先进后出,恰好与题目要求反向输出相契合。 实现: 牛客网编程通过。 class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 406
精华内容 162
关键字:

链表反向输出