单链表逆序的三种方法

一、不使用额外存储空间的逆序

LinkList ReverseLink(LinkList L)
{
    LinkList *next;
    LinkList *prev = NULL;
    LinkList *head = L->next;

    while(head != NULL)
    {
        next = head->next;
        head->next = prev;
        prev = head;
        head = next;
    }

    L->next = prev
    return L;
}

二、头插法逆序

LinkList ListReverse(LinkList L)
{
    LinkList current,pnext,prev;
    if(L == NULL || L->next == NULL)
        return L;
    current = L->next;  /* p1指向链表头节点的下一个节点 */
    pnext = current->next;
    current->next = NULL; /* 断开链表 */
    while(pnext)
    {
        prev = pnext->next;
        pnext->next = current;
        current = pnext;
        pnext = prev;
        printf("交换后:current = %d,next = %d \n",current->data,current->next->data);
    }
    L->next = current;  /* 将链表头节点指向p1 */
    return L;
}

三、递归逆序

/*链表的逆序*/
Node* reverse_list(Node *plist, Node *&head) //这个函数的返回值并不是最终链表逆序后的链表头,而是尾,
                                            //它的头保存在head指针里,所以head用的是指针引用.
{
    Node *pback = NULL;
    if(plist == NULL || plist->next == NULL)
    {
        head->next = plist;
        return plist;
    }
    else
    {
        pback = reverse_list(plist->next, head);
        pback->next = plist;
        return plist;
    }
}
时间: 2024-10-20 19:39:05

单链表逆序的三种方法的相关文章

单链表逆序的几种方法

假设单链表数据结构定义如下: struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {} }; 单链表有一个头指针指向第一个结点,最后一个结点指向NULL 一.最容易想到的方法,新建一个单链表newNode,每次将原先链表的第一个结点放到newNode后 ListNode* reverseList(ListNode* head) { ListNode *newNode = new ListN

单链表逆序或者逆序输出

分为两种情况,一种是只逆序输出,实际上不逆序:另一种是把链表逆序. ********************逆序输出*********************** 1 #include<iostream> 2 #include<stack> 3 #include<assert.h> 4 using namespace std; 5 6 7 typedef struct node{ 8 int data; 9 node * next; 10 }node; 11 12 //

华为机试题-- 单链表逆序

[问题] 单链表逆序 [代码] #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct ListNode { int value; struct ListNode *next; }ListNode; typedef struct ListNode *List; List reverseList(List head) //列表逆序 { ListNode *rear, *curr,

链表 - 单链表逆序

单链表逆序是经典的链表操作算法,单链表逆序的算法思想是将链表箭头反指(假设next指针是一个箭头),即所谓的改链,改链过程如下. 逆序前: head-->......prev-->cur-->next-->......->NULL 逆序后: NULL<--......prev<--cur<--next<--......head 算法逻辑: 1.空链表或只有一个元素,返回原链表head. 2.定义3个指针prev.cur.next,初始化时,prev指向

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

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

单链表逆序打印!

单链表打印的时候 一般 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:从第二个节点开始,记录它的下一个节点,然后依次挪到第一个节点之前成为新表头int inverse_node(struct node pH){struct node p = pH; //头结点struct node pPrev = NULL; //记录前一个节点struct node pBack = NULL; //记录下一个节点地址struct node *pFirstNode = p->pNext; //记录第一个节点 //节点只有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

单链表逆序

1.辅助指针 void ReverseList(LinkList* ListHead) { if(NULL==ListHead || NULL==ListHead->next) return; LinkList* pPre=ListHead; LinkList* pCur=ListHead->next; LinkList* pNext=NULL; while(NULL!=pCur) { pNext=pCur->next; pCur->next=pPre; pPre=pCur; pC