C语言递归,非递归实现翻转链表

翻转链表作为,链表的常用操作,也是面试常遇到的。

分析
非递归分析:

非递归用的小技巧比较多,很容易出错。

递归分析比较简单,在代码里面

代码:

#include<stdio.h>
#include<stdlib.h>
typedef int elemtype;
typedef struct node{
    elemtype element;
    struct node*next;//写成node* next;node * next;node *next;也是可以的,为了方便阅读,以后统一写成elemtype* element。‘*‘,‘;‘,‘,‘‘=‘,‘->‘等等这些特殊意义的关键字符语法规则差不多,本身具有分割意义,两旁加空格与不加空格的意义是一致的,也就是说空格对这些特殊字符是不起作用的,而解析编译器,运行器也不是利用空格来分割的;标志符是不能用这些字符,为了方便阅读,不会看的一驼屎,最好在这些特殊的字符两旁加空格。
}node;//这个类型名与其的结构体名可以一样,不矛盾。

/*Function:将链表所有结点从头结点顺序打印,遍历链表。traverse_linkedList
 *遍历一种数据机构,进去看一看,给人说一说,一般遍历打印里面的数据,知道是进去,可以拿到里面的数据。
 *这种数据结构有很多数据元素,但每次遍历只能访问一个元素,因此要循环,而且要访问所有的结点,必须有一种机制从一个结点跳到另一个结点。
 *@paramb:node* phead :链表首地址,首结点地址。
 */
void traverse_linkedList(node* phead){
    node *p=phead ;//定义一个跳转控制指针
    if (NULL == p){
        printf("亲,链表为空\n");
        return ;
    }
    else{
        while(NULL !=  p){

        printf("%d\n",p -> element);//访问结构体的数据,可以用: 其结构体变量.成员变量;还可以:指向这个结构体的指针 -> 成员变量
        p = p -> next ;
        }
    }

}
/*Function:翻转链表(非递归) reverse_linkedList
 *param:node** phead  //参数意义:保存链表指针变量的地址
 *return: void
 *
 *知识点:node** p;p代表链表指针变量的地址。*p才是链表。**p 代表结点(可以认为"*"具有解析功能)
 *整体的思路:重整结点的关系,原来从左指向右,翻转后从右指向左;原来指向头结点,翻转后指向尾结点
 *
 *时间复杂度:O(n)
 *
 *
 * */
void reverse_linkedList(node** phead){//存链表头的指针变量的地址传过来,旨在能改变这个变量,指针本质上是存地址的变量。
    node *pLeft,*pRight,*pMiddle;//定义三个指针: 左中右,pRight:作移动。
    pLeft=pRight=*phead;
    //空链表或者只有一个结点
    if(NULL == pLeft || NULL == ( pLeft -> next)){
            return ;

    }else{
        //头的结点的处理
        pLeft = *phead ;
            pRight = (*phead) -> next ; //‘ ->‘优先级最高
        pLeft -> next = NULL ;

        //循环控制条件
            node *ctl=pRight;
         while(NULL != ctl){
            pMiddle = pRight ;// 在移动前,先保存
            pRight = pRight -> next ;// pRight移动到下一个结点
            ctl = pMiddle -> next; //在变换关系前,先把控制的信息存起来
            pMiddle -> next = pLeft ; //变换关系
            pLeft = pMiddle ; // p变换
        }

        *phead = pLeft ; //指向链表头指针变量,指向新的头。
    }
}
/*
 *Function:翻转链表(递归) reverse_recursive_linkedList
 *param:node* head
 *return: node*
 *
 *知识点:
 *递归:自身调用自身;出口。
 *思考:
 *
 *如果链表是空链表或者只有一个结点,就可以直接的返回表头;如果是两个结点以上链表,调用自身,拿到子结点的表头,再重建他们的关系。
 *
 * */
node* reverse_recursive_linkedList(node * head){
    if(head == NULL || head -> next == NULL){
       return head ;
    }
    else{
       node* second = head -> next ;
       node* new_head = reverse_recursive_linkedList(second);
       second -> next = head ;
       head -> next = NULL ;
       return new_head ;
    }
}
int main()
{
    node *p , *q , *head;//仅仅定义了几个指针变量,系统做了哪些工作呢?开辟这些指针变量类型所需的空间。若没有初始值一般由系统随机分配值,还没有指向真正的结点,也就是说 p -> 成员变量是没有意义的。会报""; node 类型的声明,告诉系统作对应的语法检查,该怎么处理指针指向的内容。
    // insert 10 nodes
    //创建结点,结点本质上是数据块,这些数据是占用空间的,有了储存空间,就有了数据载体。所以开辟空间是创建数据的关键,然后告诉系统你怎么来处理这块空间,最后空间开辟成功。
    p = q = (node* )malloc(sizeof(node)) ;//与” 数据类型 标识符“ 创建的差别,无标识符,要手动开空间,并提取信息。标识符功能:解析+地址。
    head = p ;
    p -> element = 0 ;
    int i=0;
    for ( i = 0 ;i < 9 ; i++){

        q = (node* )malloc(sizeof(node)) ;
        q -> element = i + 1 ;
        p -> next = q ;
        p = q ;

    }

    traverse_linkedList(head);
    reverse_linkedList(&head);//&只能作取址用,没有解析功能。
    traverse_linkedList(head);
    traverse_linkedList(reverse_recursive_linkedList(head));
}

本人在重拾C,很多东西看是熟悉而又陌生,所以注释比较多一点,仅供参考,不爽直接忽略,

时间: 2024-10-27 05:30:13

C语言递归,非递归实现翻转链表的相关文章

快速排序递归非递归队列堆栈实现

递归实现 #include<iostream> using namespace std; template <class T> void QuickSort(T A[],int left,int right) { if(left<right) { int i=left; int j=right+1; do { do i++;while(A[i]<A[left]); do j--;while(A[j]>A[left]); if(i<j) Swap(A[i],A

二叉树总结—建树和4种遍历方式(递归&amp;&amp;非递归)

今天总结一下二叉树,要考离散了,求不挂!二叉树最重要的就是 建立.4种遍历方式,简单应用,如何判断两颗二叉树是否相似 二叉树分为 :1.完全二叉树  2.满二叉树 结构性质: 1).满二叉树 高度为h ,节点数则为 2^h - 1,且叶子节点全在最下层,且叶子节点数为2^(n-1)个{n代表二叉树层数,也叫深度} 2).n个节点的 完全二叉树 深度为 int(log2n)(以2为底n的对数)+ 1: 3).非空二叉树 叶子节点个数==双分支节点数+1 4).非空二叉树 某节点编号 n  若有左孩

【算法拾遗】二分查找递归非递归实现

转载请注明出处:http://blog.csdn.net/ns_code/article/details/33747953 本篇博文没太多要说的,二分查找很简单,也是常见常考的查找算法,以下是递归非递归的实现. 非递归实现: /* 非递归实现,返回对应的序号 */ int BinarySearch(int *arr,int len,int key) { if(arr==NULL || len<1) return -1; int low = 0; int high = len-1; while(l

2013-03-17---二叉树递归,非递归实现(附代码)深度,叶子节点数量,逐行打印二叉树

昨天晚上没有发文章,说来话长啊,昨天不知道是csdn的问题,还是我的问题,我访问了半天,访问不上网站啊,后来12点多了,就睡了.上一篇文章说到了二叉树的先序,中序,后序遍历问题,这次还是说的简单的一点,说计算二叉树的深度,和叶子节点数量 int ceng(Node *pRoot) //计算层数,递归实现 { int left = 0; int right = 0; int res = 0; if (pRoot == NULL) { return 0; } if (pRoot->pLeft !=

Java实现二叉树的创建、递归/非递归遍历

近期复习数据结构中的二叉树的相关问题,在这里整理一下 这里包含: 1.二叉树的先序创建 2.二叉树的递归先序遍历 3.二叉树的非递归先序遍历 4.二叉树的递归中序遍历 5.二叉树的非递归中序遍历 6.二叉树的递归后序遍历 7.二叉树的非递归后序遍历 8.二叉树的层次遍历 这里感谢博客http://blog.csdn.net/skylinesky/article/details/6611442的指导 /**二叉树的结点定义*/ class Node<T>{ private T value; pr

递归非递归的二叉树遍历(递归前中后,非递归前中后,层次遍历,凹入打印法等)

由于所有的递归算法都可以借助于堆栈转换成循环结构的非递归算法.方法一:形式化模拟转换.方法二:根据要求解问题的特点设计借助于堆栈的循环结构算法.而此次正好是利用第二种按方法求解. 1.1非递归前序遍历: 首先利用下图来设计非递归前序遍历算法思想: 堆栈结构体如下: #define size 100 typedef struct { DataType data[size]; int tag[100]; //这个是在非递归后序中用到 int top : }SeqStack : (1)初始化设置一个堆

作业 树和森林 遍历(递归/非递归先序,递归/非递归后序,递归层次)

1 #include <iostream> 2 #include"queue.h"//之前写的类 3 #include"stack.h" //之前写的类 4 using namespace std; 5 6 template <class T> 7 class Tree; 8 9 //======================================== 10 // 树节点类声明 11 template <class T>

二叉树的前序/中序/后续遍历(递归+非递归)

这几日又把二叉树的递归写了一遍,原来是用C写的,自己写了一个栈,这一次直接用的C++,使用了自带的栈结构.代码如下: 1 /************************************************************************* 2 > Author: Yves 3 > E-mail: [email protected] 4 > File Name: BiTreeNew.cpp 5 > Description: ... 6 > Cre

hdu 4850 字符串构造---欧拉回路构造序列 递归+非递归实现

http://acm.hdu.edu.cn/showproblem.php?pid=4850 题意:构造长度为n的字符序列,使得>=4的子串只出现一次 其实最长只能构造出来26^4+4-1= 456979 的序列,大于该数的都是不可能的.构造方法,就是那种欧拉回路的序列,此题DFS会爆栈,手动扩展栈也可以AC...... 递归形式的开始WA了,没有细调就换非递归了,后来又想了想,虽然自己电脑上运行不了,但是先把长度按小的来,然后调试代码,然后在扩大,AC了,当时错在MOD,递归的MOD应该是26

2015-03-15---二叉树递归(非递归)实现先序、中序、后序遍历(附代码)

今天说好的不碰代码的,后来还是没忍住,学了学数据结构和算法,就先讲讲先序中序和后序遍历吧,我还写了代码,一套递归方式实现遍历二叉树,还有两套非递归方式遍历二叉树, 从简单的开始,因为二叉树的所有操作都是要求在能够遍历的基础上啊. 学过数据结构的肯定都明白遍历顺序, 先序遍历就是先自己,然后左子树,然后右子树, 中序遍历就是先左子树,然后自己,然后右子树 后序遍历就是先左子树,然后右子树,然后自己 比如上图这个很简单的二叉树: 先序遍历:1 2 4 5 3 6 7 中序遍历:4 2 5 1 6 3