C++链表逆序打印节点

#include <iostream>
#include <stack>
using namespace std;
template<typename Type>
struct Node
{
    Type data;
    Node *next;
    Node(Type d = Type()):data(d),next(NULL){}
};

template<typename Type>
class List
{
    public:
    List()
    {
        head = NULL;
    }
    void Insert(Type a[],int n)
    {
        for(int i=0;i<n;i++)
        {
            _Insert(head,a[i]);
        }
    }
    void Printf()//顺序打印.
    {
        Node<Type> *p = head;
        while(p!=NULL)
        {
            cout<<p->data<<"\t";
            p = p->next;
        }
      cout<<endl;
    }
    void Printf_A()//递归逆序打印节点.
    {
        _Printf_A(head);
    }
    void Printf_B()
    {
        _Printf_B(head);//用栈实现逆序打印节点。
    }
    private:
    void _Printf_B(Node<Type> *t)
    {
        Node<Type> *p = t;
        stack<Node<Type> *> st;
        while(p!=NULL)
        {
            st.push(p);
            p = p->next;
        }
        while(st.empty()!=true)
        {
            p = st.top();
            st.pop();
            cout<<p->data<<"\t";
        }
        cout<<endl;
    }
    bool _Printf_A(Node<Type> *t)
    {
        if(t!=NULL)
        {
            _Printf_A(t->next);
            cout<<t->data<<"\t";
        }
    }
    bool _Insert(Node<Type> *t,Type val)
    {
        Node<Type> *p = t;
        Node<Type> *s = new Node<Type>(val);
        if(t==NULL)
        {
            head = s;
        }
        else
        {
          while(p->next!=NULL)
                    p=p->next;
            p->next = s;
        }
    }
    private:
    Node<Type> *head;
};
int main()
{
    int a[]={1,2,3,4,5,6,7,8};
    List<int> list;
    list.Insert(a,8);
//  list.Printf_A();
    //list.Printf();
    list.Printf_B();
    return 0;
}
时间: 2024-10-05 05:09:21

C++链表逆序打印节点的相关文章

单链表逆序打印!

单链表打印的时候 一般 if (p== NULL) return; printf("%d ",p->data ); reverse_show(p->next); 结果: 123456 就可以依次打印了 但是如果把打印语句放在后面 就会逆序打印 if (p== NULL)return; reverse_show(p->next); printf("%d ",p->data ); 结果 654321 这是因为退出的时候 是从后面进行的!

算法习题---线性表之单链表逆序打印

一:题目 逆序打印单链表中的数据,假设指针指向单链表的开始结点 二:思路 1.可以使用递归方法,来进行数据打印 2.可以借助数组空间,获取长度,逆序打印数组 3.若是可以,对链表数据使用头插法,逆序排列,然后正序打印即可 三:算法实现(这里使用方法一:递归实现简单易懂) #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #define MAXSIZE 10 #define OK 1 #def

[算法]链表的逆序遍历节点

有一个链表,知道链表头,怎么逆序打印出链表每个节点的值. 我们知道,当知道了链表头的时候,很容易顺序访问所有节点的值,但是如何逆序访问所有节点呢? 访问一棵二叉树,通常可以深度优先和广度优先访问每个节点,深度优先又分为先序,中序和后续遍历,后续遍历就是先访问树的右子树,再访问左子树,最后访问父节点,如果我们把一个链表看成是一颗单叉树,利用树的后续遍历就达到了逆序访问链表的每个节点,利用递归,实现代码如下: struct node { int val; node* next; }; void tr

C语言实现链表的逆序打印

我在前面几篇博客中<C语言实现链表节点的插入><C语言实现链表节点的删除><C实现头插法和尾插法来构建链表><C语言实现链表的基本操作>实现了链表的很多增删改查操作.这里我们要来实现链表的逆序打印,使用C来实现.代码上传至 https://github.com/chenyufeng1991/ReverseLinkedList . 基本算法是: (1)使用尾插法构建原链表: (2)依次遍历原链表: (3)取出遍历中的节点使用头插法建立一个新链表: (4)打印逆

链表逆序 和 寻找链表中间节点

已知链表的头节点为head,写一个函数把链表逆序. void reserve(list_node* head){ if(head == NULL) return 0; list_node* p = head; list_node* q = p->next; list_node* r = NULL; while(q){ r = q->next; q->next = p; p = q; q = r; } head->next == NULL; head = p; } 找出单链表的中间节

面试:用 Java 逆序打印链表

昨天的 Java 实现单例模式 中,我们的双重检验锁机制因为指令重排序问题而引入了 volatile 关键字,不少朋友问我,到底为啥要加 volatile 这个关键字呀,而它,到底又有什么神奇的作用呢? 对 volatile 这个关键字,在昨天的讲解中我们简单说了一下:被 volatile 修饰的共享变量,都会具有下面两个属性: 保证不同线程对该变量操作的内存可见性. 禁止指令重排序. 共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量. 可见性:一个线

C语言实现双向非循环链表的逆序打印

我在上一篇博客中<C语言实现双向非循环链表>实现了如何构造一个双向非循环链表,并实现了正向打印.我还在之前一篇博客<C语言实现单链表的逆序打印>中实现了单链表的逆序打印.这篇博客我们来实现对双向非循环链表进行逆序打印,实现起来非常的简单.代码已经上传至 https://github.com/chenyufeng1991/ReverseDoubleLinkedList . 核心代码如下: //打印非循环双向链表,这个其实是正向打印 void printList(Node *pNode

链表逆序输出 ---九度1511

题目描述: 输入一个链表,从尾到头打印链表每个节点的值. 输入: 每个输入文件仅包含一组测试样例. 每一组测试案例包含多行,每行一个大于0的整数,代表一个链表的节点.第一行是链表第一个节点的值,依次类推.当输入到-1时代表链表输入完毕.-1本身不属于链表. 输出: 对应每个测试案例,以从尾到头的顺序输出链表每个节点的值,每个值占一行. 样例输入: 1 2 3 4 5 -1 样例输出: 5 4 3 2 1 解题思路: 方法一:直接用数组存储数据,然后反向输出,不过好像通不过.为什么? 方法二:利用

算法-----单链表逆序

一.全部逆序 定义两个变量pre, next,与节点head一起,遍历整个链表. while(head != null){ next = head.next; head.next = pre; pre = head; head = next; } 二. 部分逆序 首先找到需要逆序的节点区域的前一个节点和后一个节点.记为 pre,pos. 定义3个变量cur, next1, next2. 遍历链表. Node cur = pre.next; Node next1 = cur.next; cur.n