精华内容
下载资源
问答
  • C++单链表递归逆序

    千次阅读 2015-07-14 13:45:51
    //递归逆序单链表。 void Printf() { Node *p = first; while (p != NULL) { cout << p->data " " ; p = p->next; } cout ; } private : Node *first; }; int main() { List list ; int...
    #include <iostream>
    using namespace std;
    struct Node
    {
        int data;
        Node *next;
        Node(int d = int()) :data(d), next(NULL){}
    };
    class List
    {
    public:
        List()
        {
            first = NULL;
        }
    
        void Insert(int a[], int n)
        {
            Node *p = first;
            for (int i = 0; i < n; i++)
            {
                Node *s = new Node(a[i]);
                if (p == NULL)
                {
                    p = s;
                    first = p;
                }
                else
                {
                    while (p->next != NULL)
                    {
                        p = p->next;
                    }
                    s->next = p->next;
                    p->next = s;
                }
            }
        }
    
        void Sort()
        {
            Sort(NULL, first);
        }
    
        void Sort(Node *p, Node *t)
        {
            if (t->next == NULL)
            {
                first = t;
                return;
            }
            else
            {
                Node *q = t->next;
                Sort(t, q);
                if (p == NULL)
                {
                    q->next = t;
                    t->next = NULL;
                    return;
                }
                q->next = t;
            }
        }
        //递归逆序单链表。
        void Printf()
        {
            Node *p = first;
            while (p != NULL)
            {
                cout << p->data << "   ";
                p = p->next;
            }
            cout << endl;
        }
    private:
        Node *first;
    };
    int main()
    {
        List list;
        int a[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
        list.Insert(a,sizeof(a)/sizeof(int));
        list.Sort();
        list.Printf();
        return 0;
    }
    展开全文
  • 单链表逆序输出

    千次阅读 2016-04-03 21:23:32
     这里只是简单写了一个可以实现正常功能的单链表,(未实现析构函数)由于单链表只能一般从前向后遍历,这样按题目的要求先访问者后输出,正好与栈的的功能相同,用栈能解决的问题都可以用递归的方法实现。...
     
     
    从尾到头打印单链表.
              这里只是简单写了一个可以实现正常功能的单链表,(未实现析构函数)由于单链表只能一般从前向后遍历,这样按题目的要求先访问者后输出,正好与栈的的功能相同,用栈能解决的问题都可以用递归的方法实现。这里我用了递归的方法
    # include <iostream>
    # include <cassert>
    using namespace std;
    struct ListNode
    {
               size_t _data;
               ListNode *_next;
              ListNode()
                       :_data(0)
                       , _next( NULL)
              {}
    };
    class List
    {
    private :
               ListNode *head;
               ListNode *tail;
    public :
              List()
                       :head( new ListNode )
                       , tail(head)
              {}
               bool Insert(size_t data)
              {
                       tail->_data = data;
                       tail->_next = new ListNode ;
                       tail = tail->_next;
                        if (tail != NULL )
                       {
                                  return true ;
                       }
                        else
                       {
                                  return false ;
                       }
              }
               void PrintHeadtoTail()
              {
                        assert(head);
                        ListNode *phead = head;
                        while (phead->_next != NULL)
                       {
                                 cout << phead->_data << " " ;
                                 phead = phead->_next;
                       }
                       cout << endl;
              }
               void PrintTailtoHead()
              {
                        assert(head);
                        ListNode *phead = head;
                       _PrintTailtoHead(phead);
                       cout << endl;

              }
    protected :
                void _PrintTailtoHead(ListNode* phead)
              {
                        if (phead ->_next==NULL)
                       {
                                  return;
                       }
                        else
                       {
                                 _PrintTailtoHead( phead->_next);
                       }
                       cout << phead->_data << " ";
              }

    };
    int main()
    {
               List L;
              L.Insert(1);
              L.Insert(2);
              L.Insert(3);
              L.Insert(4);
              L.Insert(5);
              L.Insert(6);
              L.Insert(7);
              L.Insert(8);
              L.Insert(9);
              L.PrintHeadtoTail();
              L.PrintTailtoHead();
               return 0;

    }








    展开全文
  • 带头结点的单链表逆序输出

    千次阅读 2019-07-04 18:10:32
    实现从尾到头反向输出带头结点的单链表L的每个结点元素,借助栈先进后出的思想,每经过一个结点,就把它放入栈中,遍历完整个链表后,再从栈顶开始输出结点。

    实现从尾到头反向输出带头结点的单链表L的每个结点元素

    题目要求

    设L为带头结点的单链表,试实现从尾到头反向输出L的每个结点元素。

    基本思想

    第一种
    对于单链表,从头到尾输出比较简单,因此可以先将单链表L逆置,然后再按照常规方法输出。
    第二种
    借助栈先进后出的思想,每经过一个结点,就把它放入栈中,遍历完整个链表后,再从栈顶开始输出结点。
    然而实际操作上,并不需要真的设置一个栈空间,使用递归方法也可完成任务(每当访问一个结点时,先递归输出后面的结点,再输出这个结点本身)。

    核心代码

    这里只放使用递归方法的代码

    void printRevList(LinkList L){
    	if (L->next != NULL)
    		printRevList(L->next);
    	cout << L->data << "  ";
    }
    

    需要特别注意,这里在调用时,需要把入口改为第一个带数据的结点,即

    printRevList(L->next);
    

    完整代码(C++)

    //函数功能:
    //实现一维数组中两个顺序表的位置互换
    //函数功能:实现从尾到头反向输出带头结点的单链表L的每个结点元素
    //基本思想:借助栈的思想,使用递归方法实现
    
    #include<iostream>
    using namespace std;
    
    typedef int ElemType;
    typedef struct LNode{
    	ElemType data;
    	struct LNode *next;
    }LNode, *LinkList;
    
    //链表的初始化
    void InitList(LinkList &L){
    	L = new LNode;
    	L->next = NULL;
    }
    
    //使用尾插法建立单链表
    LinkList tailInsertList(LinkList &L, ElemType A[], int n){
    	LNode *r = L;//尾指针
    	for (int i = 0; i < n; i++)
    	{
    		LNode *s = new LNode;
    		s->data = A[i];
    		r->next = s;
    		r = s;
    	}
    	r->next = NULL; //尾指针置空
    	return L;
    }
    
    //打印链表的数据(无头结点)
    void printList(LinkList L){
    	LNode *p = L->next;
    	while (p != NULL)
    	{
    		cout << p->data << "  ";
    		p = p->next;
    	}
    	cout << endl;
    }
    
    //逆向输出单链表
    void printRevList(LinkList L){
    	if (L->next != NULL)
    		printRevList(L->next);
    	cout << L->data << "  ";
    }
    
    
    void main()
    {
    	LinkList L;
    	InitList(L);
    	ElemType A[10] = { 1, 6, 15, 20, 35, 98, -7, 15, -2, 9 };
    	tailInsertList(L, A, 10);
    	printList(L);
    	printRevList(L->next);//注意入口为第一个带元素的结点
    }
    
    展开全文
  • 用c语言实现单链表逆序输出

    千次阅读 2014-08-28 20:42:42
    可以用递归,如果没到链表尾,则递归查询,否则输出当前值。下面只是算法表示,不能直接放到程序里编译执行。 int outlink(node *p) { if(p->next!=null) outlink(p->next); printf(p->data); return 0; }
    <span style="font-family: Arial, Helvetica, sans-serif;">可以用递归,如果没到链表尾,则递归查询,否则输出当前值。下面只是算法表示,不能直接放到程序里编译执行。</span><span style="font-family: Arial, Helvetica, sans-serif;"> </span>
    int outlink(node *p)
    {
        if(p->next!=null)
            outlink(p->next);
       printf(p->data);
       return 0;
    }
    以下为代码实现:
    #include<stdio.h>
    #include <stdlib.h>
    #include<string.h>
    #include<malloc.h>
    struct String{ //字符串结构体
     char c;
     struct String *next;
    };
    void iniString(struct String *str){ //字符串初始化
     struct String *p1,*p2;
     p1=str;
     scanf("%c",&(p1->c));
     while(p1->c!='\n'){
      p2=(struct String *)malloc(sizeof(struct String *));
      scanf("%c",&(p2->c));
      p1->next=p2;
      p1=p1->next;
     }
     p1->next=NULL;
    }
    void strPrint(struct String *str){ //字符串链表逆序输出
     struct String *s=str;
     if(s->next!=NULL)
     {
      strPrint(s->next);
      printf("%c",s->c);
     }else
     {
      printf("%c",s->c);
     }
    }
    int main(){
     printf("请输入字符串(回车结束输入):");
     struct String str1;
     struct String *pstr1;
     pstr1=&str1;
     iniString(pstr1);
     strPrint(pstr1);
     system("pause");
     return 0;
    }
    http://zhidao.baidu.com/link?url=ixHSZqmxacDynyM8kT9ERRALx_NX3uqm6OwAnd0Fydnb9eLjlchSsFtpuHY999P1P48q3oBldWkpqD7qHNBko_

    展开全文
  • 单链表逆序输出分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体如下: 1.逆序输出 实例代码如下: #include<iostream> #include<stack> #...
  • } List Reverse(List L){//递归实现 if(L==NULL)return NULL;//空链表 if(L->Next==NULL)return L;//单个节点的链表 List head=Reverse(L->Next); L->Next->Next=L; L->Next=NULL;//断开避免成环 return head; }
  • 今天突然被问到单链表逆序的问题,弄了好久才看出别人的程序有啥问题,就重新写了一遍。 今天才在CSDN客户端上看到美团的面试题是冒泡排序。 一个看似简单的问题难倒很多人,所以简单的不要因为他简单就忽视它,...
  • 这篇文章主要介绍了C语言实现单链表逆序与逆序输出,是数据结构与算法中比较基础的重要内容,有必要加以牢固掌握,需要的朋友可以参考下 单链表逆序输出分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把...
  • 单链表逆序输出

    千次阅读 2018-01-21 11:32:50
    单链表逆序输出,有好几种思路。 比如:将单链表逆序后输出;或者顺序遍历单链表然后将其存入栈,再用栈来实现;或者就是使用递归。 可想而知,递归是最简单的一种方法。因此下面以带头结点的单链表为例,放上...
  • 一、正确的学习方法 1、要想学好数据结构,先画图思考算法理解算法,然后在图上写...3、单链表逆序输出分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把链表逆序。本文就分别实例讲述一下两种方法。具体...
  • 分为两种情况,一种是只逆序输出,实际上不逆序;另一种是把链表逆序。   ********************逆序输出***********************
  • 本次实验是用递归的方法实现单链表逆序,网上有很多类似的code.  这次实验主要要注意的是指针引用的使用,要充分理解引用是个别名,指针的引用可以参考其它网友的一篇博文:指针的引用  实验内容是先构造...
  • 本次实验是用递归的方法实现单链表逆序,网上有很多类似的code.  这次实验主要要注意的是指针引用的使用,要充分理解引用是个别名,指针的引用可以参考其它网友的一篇博文:指针的引用  实验内容是先构造...
  • 单链表逆序(递归)

    2019-07-13 10:41:09
    首先创建一个链表,然后使用递归的方法不断完成逆序。 class Node: def __init__(self,val): self.next = None self.val = val class ListUtility: def __init__(self): self.head = None self....
  • 本次实验是用递归的方法实现单链表逆序,网上有很多类似的code. 这次实验主要要注意的是指针引用的使用,要充分理解引用是个别名,指针的引用可以参考其它网友的一篇博文:指针的引用 实验内容是先构造一个随机...
  • C语言 逆序输出单链表递归

    千次阅读 2017-09-02 09:38:26
    对于单链表而言,顺序输出十分简单,但逆序输出则...只需要采取栈的思想,即递归即可非常简单地实现单链表逆序输出。 代码: void R_Print(LNode* L) { if(L->next !=NULL) { R_Print(L->next); } printf
  • 在不使用额外存储节点的情况下使一个单链表的所有节点逆序?我们先用迭代循环的思想来分析这个问题,链表的初始状态如下 初始状态,prev是NULL,head指向当前的头节点A,next指向A节点的下一个节点B。首先从A...
  • 单链表逆序

    2017-12-17 13:37:04
    单链表逆序的方法: Link* reLink(Link *head) //递归 {  Link *cur, *tail, *headcur;  if (head->next == NULL)  {  return head;  }  cur = he
  • p2就是当前节点,最后一个节点,也就是最后逆序以后的头结点。 p3结点用来保存p2结点的下一个节点关系的中间变量。 大概过程就是,断开后面的节点,连接到前面,直到最后一个,他的最后为null,就返回了。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 3,392
精华内容 1,356
关键字:

单链表递归逆序输出