C++单链表递归逆序

#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;
}

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-08-03 09:34:00

C++单链表递归逆序的相关文章

java 实现单链表的逆序

</pre><pre name="code" class="java">package com.ckw.mianshi; /** * java 实现单链表的逆序 * @author Administrator * */ public class SingleLinkedReverse { class Node{ int data; Node next; public Node(int data){ this.data = data; } }

单链表的逆序 (采用头插法实现)

// 单链表的建立// 单链表的建立可以用头插法或者尾插法.头插法是指建立单链表时, 总是将新节点插入到当前链表的表头.// 头插法常用在将一个已存在的链表逆序. 1 #include <iostream> 2 3 using std::cout; 4 using std::endl; 5 6 struct Item{ 7 char c; 8 Item *next; 9 }; 10 Item *Routine1(Item *x){ 11 Item *prev = NULL, *curr = x

【链表】实现单链表的逆序

1 public class Main { 2 3 // 就地逆序法 4 public Node reverse(Node head) { 5 // no need to reverse 6 if (head == null || head.next == null || head.next.next == null) { 7 return head; 8 } 9 10 // pointer 11 Node pre = head; 12 Node cur = head.next; 13 Node

算法题:链表的递归逆序

#include <iostream> using namespace std; struct Node { int data; Node *next; Node(int d = int()) :data(d), next(NULL){} }; class Clist { public: Clist(int a[], int n) :first(NULL) { int i = 0; Node *p = NULL; for (; i < n; i++) { Node *s = new No

(转)单链表的逆置

对于单链表的逆置有两种方法可以实现: (1)利用辅助指针 基本思想:在遍历结点过程中,设置辅助指针,用于记录先前遍历的结点.这样依次编译的过程中只需修改其后继结点的next域即可. 实现代码: 1 typedef int DataType; //类型定义 2 typedef struct node{ //单链表定义 3 DataType data; 4 struct node* next; 5 }LinkedNode,*LinkList; 6 void ReverseList(LinkList&

JAVA链表实现与链表的逆序

1.链表         链表有单链表还有双向链表,在java中每个节点都是一个类,这里声明了内部类,为了方便插入和删除,有时会在,链表的表头加上哨兵(形成有哨兵的循环或双向循环链表),这样的插入删除就不用考虑当插入删除的元素在边界的情况,方便,至于哨兵你可能觉得没什么用,其实他可以存储链表的许多信息,比如你每次查找一个元素,在无哨兵时,使用P!=null,使用哨兵,可以存储要查找的元素,退出时,就要判断是不是哨兵. 2.链表的实现与逆序 若想代码写得快,必须清楚每次交换插入,产生的状态和性质.

单链表的逆置--普通循环方法(详细图解)

关于单链表的逆置,大家都很清楚有两种基本方法:(1)普通的循环的方法.(2)递归调用方法.今天正好研究这两种方法,发现很不理解代码这么写的具体的作用,诚如很多人所说,吃透这个还是要自己画一个详细的过程图.今天就给大家介绍一下(普通的循环方法)我学习下来的一些经验,如有不对之处还望大家一起交流. 首先,以下是关于单链表逆置的普通循环方法的代码: //单链表定义 typedef struct ListNode{ int m_nValue; ListNode* pNext; }; //单链表逆置实现

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

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

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

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