devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

单链表的定义和操作(超详细——C语言)_链表定义

作者：Gausst松鼠会 | 2024-05-12 02:14:04

赞

踩

链表定义

一、链表的概念

  定义：

         链表是一种物理存储上非连续，数据元素的逻辑顺序通过链表中的指针链接次序，实现的一种线性存储结构。

   特点：

           链表是一系列节点组成，节点在运行时动态生成（malloc），每一个节点包括两个部分。

     一 个是存储数据元素的数据域，另一个是存储下一个节点地址的指针域


 链表是一种线性存储结构,线性存储结构又可分两类：

        一类是 顺序存储结构（即 数组的存储方式），其特点是是逻辑关系上相邻的两个元素在物理位置上也相邻，即在连续的地址块中存储一系列数据。

         一类是 链式存储结构（链表的存储方式），其特点为不需要逻辑上相邻的元素在物理位置上也相邻，即在不连续的地址中存储一系列数据 ，所以链表不能向数组一样通过下标随机访问。

那么链表之间的元素又是如何相互关联的呢？

        它是由一系列的存储数据元素的单元通过指针串接来确定元素之间相互关系的,因此每个单元至少都有两个域—数据域和指针域，这样的单元也被称为节点(Node)。

二、为什么要用链表

     我们学完c语言之后，我们至少可以通过两种结构来存储数据，一种是“数组”，另外一种是“链表”。为什么还要学习链表呢，因为数组是连续的。

          1、数组的缺点

      1）因为他是连续。内存需要一块连续的空间。如果存储数据大的话，系统必须得找一块连续且大的空闲空间，如果找不到，就分配不成功。     

      2）数组不可以插入，删除里面的元素，满足不了我们项目的需求。                               

       3）数组存放数据时，必须事先定义固定的长度                               

           2、链表的优点 

       1）链表不需要连续地分配内存空间，每一个元素之间不是连续而是分开的，所以不需要很大的内存空间。

       2）链表可以插入，删除和添加等操作，且效率高

       3） 链表不需要像数组预先指定空间的长度，可以现用现分配。

            3、链表的缺点

        1）由于链表的每一个元素里面都有一个地址。相对而已，会占用比较多的内存，空间的开销会比较大。 

三、链表分类

链表可大致分为

        1）单链表（最普通的链表）

        2）双向链表（有两个指针域）

        3）循环链表（首尾相接）

        4）静态链表（链表的数组表示法）

四、链表的构成：（以上图为例）

  1. #define MAX 20                  
  2. typedef struct Node｛           //  Node 结构体名，可以随便去，但不能是关键字
  3.    
  4.      int data;
  5.      strutc Node *next;
  6.  
  7. }linkList;                          //linkList 等效于 struct Node

 五，链表的操作

 1、链表的创建CreateLinkList

  1. #include<stdio.h>
  2. #include<srdlib.h>
  3.  
  4. #define ERROR O
  5. #define  OK   1
  6. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  7. typedef struct Node         
  8. {
  9.    //数据域
  10.      int data;         
  11.  
  12.    //指针域
  13.      struct Node *next;
  14. }STU;
  15.  
  16.  
  17.  STU * CreateLinkList(void)         
  18. {
  19.    STU * head = NULL;
  20.  
  21.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  22.    if(head==NULL)
  23.   {
  24.      exit(0);
  25.    }
  26.     head ->next = NULL;
  27.     return head;
  28. }

2、 链表赋值

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4.  
  5. #define ERROR O
  6. #define  OK   1
  7. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  8. typedef struct Node         
  9. {
  10.    //数据域
  11.      int data;         
  12.  
  13.    //指针域
  14.      struct Node *next;
  15. }STU;
  16.  
  17.  
  18.  
  19.  
  20.  STU * CreateLinkList(void)         
  21. {
  22.    STU * head = NULL;
  23.  
  24.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  25.    if(head==NULL)
  26.   {
  27.       exit(0);
  28.    }
  29.     head ->next = NULL;
  30.     return head;
  31. }
  32.  
  33.  
  34. void PrintList(STU *head)      //封装打印链表函数
  35. {
  36.    STU *pmove = head->next;       
  37.     while(pmove)
  38.   {
  39.     printf("%d",pmove->data);     
  40.     pmove=pmove->next;
  41.   }   
  42.    
  43.     printf("\n");
  44.    
  45. }
  46.  
  47.  
  48.    int nmain()
  49. {
  50.     int i=0;
  51.     int num=0;
  52.     STU * link = NULL;
  53.     STU * p_new = NULL;
  54.     link= CreateLinkList();
  55.     printf("请输入链表的初始个数：\n");
  56.     scanf("%d\n",&num);
  57.     for(i=0;i<num;i++)
  58.    {
  59.       p_new=(STU *)malloc(sizeof(STU));
  60.       printf("请输入数据：\n");
  61.       scanf("%d\n",&p_new->data);
  62.     }      
  63.    
  64.      PrintList(link);
  65.  
  66.     return 0;
  67. }

3、创建新的单个节点 CreateNode

  1.  
  2. STU *CreateNode(int data)
  3. {
  4.    STU * newhead = ( STU *)malloc(sizeof(STU));
  5.  
  6.    newhead->data=data;
  7.    newhead->next=NULL;
  8.    
  9.    return newhead;
  10. }
  11.  
  12.

4、打印链表PrintList()

  1. void PrintList(STU *head)
  2. {
  3.  
  4.    STU *pmove = head->next;   //头结点数据是0，因此，从头结点下一个数据开始打印，即head->next
  5.     
  6.      while(pmove)
  7.   {
  8.     printf("%d",pmove->data);     
  9.     pmove=pmove->next;
  10.   }   
  11.    
  12.     printf("\n");
  13.    
  14. }

5、插入节点（头插法）

  1.  
  2. STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
  3.                                    //方便使用
  4. {
  5.    STU * newhead = ( STU *)malloc(sizeof(STU));
  6.  
  7.    newhead->data=data;
  8.    newhead->next=NULL;
  9.    
  10.    return newNode;
  11. }
  12.  
  13. void InsertHeadNode(STU *head,int data)
  14. {
  15.     STU * newNode =CreateNode(int data); 
  16.  
  17.     newNode->next = head->next;
  18.     head-> = newNode;
  19.  
  20.  
  21. }

5.1简单的头插法使用（完整代码）

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. #define ERROR O
  5. #define  OK  1
  6. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  7. typedef struct Node         
  8. {
  9.    //数据域
  10.      int data;         
  11.  
  12.    //指针域
  13.      struct Node *next;
  14. }STU;
  15.  
  16. STU * CreateLinkList()         
  17. {
  18.    STU * head = NULL;
  19.  
  20.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  21.    if(head==NULL)
  22.   {
  23.      exit(0);
  24.    }
  25.     head ->next = NULL;
  26.     return head;
  27. }
  28.  
  29. STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
  30.                                    //方便使用
  31. {
  32.    STU * newNode = ( STU *)malloc(sizeof(STU));
  33.  
  34.    newNode->data=data;
  35.    newNode->next=NULL;
  36.    
  37.    return newNode;
  38. }
  39.  
  40. void InsertHeadNode(STU *head,int data)
  41. {
  42.     STU * newNode =CreateNode(data); 
  43.  
  44.     newNode->next = head->next;
  45.     head->next=newNode;
  46.     
  47. }
  48.  
  49. void PrintList(STU *head)
  50. {
  51.  
  52.    STU *pmove = head->next;       
  53.     while(pmove)
  54.   {
  55.     printf("%d",pmove->data);     
  56.     pmove=pmove->next;
  57.   }   
  58.    
  59.     printf("\n");
  60.    
  61. }
  62.   int main()
  63.   {
  64.       
  65.     int i;
  66.     STU *link=NULL;
  67.     link =CreateLinkList();
  68.       
  69.    InsertHeadNode(link, 1);
  70.    InsertHeadNode(link, 2);
  71.    InsertHeadNode(link, 3);
  72.    InsertHeadNode(link, 4);
  73.    PrintList(link);     
  74.       
  75.      return 0; 
  76.       
  77.   }
  78.

运行结果

4321

 6、链表插入（中间插入）

  1. //在哪个表插入，第几个位置，插入什么数据
  2. void InsertNode(STU *head,int where，int data)  
  3. {
  4.     int k=0;
  5.     STU *q=head;
  6.     STU * newNode2 =CreateNode(int data); 
  7.  
  8.    for( k ; k<where ; k++)
  9.   {
  10.     if(q==NULL)
  11.    {
  12.     printf("create  q fail\n");
  13.      exit(0);
  14.    }
  15.       q =q->next;
  16.  
  17.   }
  18.  
  19.     newNode2->next = q->next;
  20.       
  21.      q->next = newNode2;
  22.  
  23.  
  24. }

6.1简单的插入（中间）法使用（完整代码）

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. #define ERROR O
  5. #define  OK  1
  6. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  7. typedef struct Node         
  8. {
  9.    //数据域
  10.      int data;         
  11.  
  12.    //指针域
  13.      struct Node *next;
  14. }STU;
  15.  
  16. STU * CreateLinkList()         
  17. {
  18.    STU * head = NULL;
  19.  
  20.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  21.    if(head==NULL)
  22.   {
  23.      exit(0);
  24.    }
  25.     head ->next = NULL;
  26.     return head;
  27. }
  28.  
  29. STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
  30.                                    //方便使用
  31. {
  32.    STU * newNode = ( STU *)malloc(sizeof(STU));
  33.  
  34.    newNode->data=data;
  35.    newNode->next=NULL;
  36.    
  37.    return newNode;
  38. }
  39.  
  40. void InsertHeadNode(STU *head,int data)
  41. {
  42.     STU * newNode =CreateNode(data); 
  43.  
  44.     newNode->next = head->next;
  45.     head->next=newNode;
  46.     
  47. }
  48.  
  49. void PrintList(STU *head)
  50. {
  51.  
  52.    STU *pmove = head->next;       
  53.     while(pmove)
  54.   {
  55.     printf("%d",pmove->data);     
  56.     pmove=pmove->next;
  57.   }   
  58.    
  59.     printf("\n");
  60.    
  61. }
  62. //在哪个表插入，第几个位置，插入什么数据
  63. void InsertNode(STU *head,int data)  
  64. {
  65.     int k=0;
  66.     int num;
  67.     STU *q=head;
  68.     STU * newNode2 = CreateNode(data); 
  69.     printf("请输入插入中间第几个数：\n");
  70.     scanf("%d",&num);
  71.     
  72.   for(k=1; k<=num;k++)
  73.   {
  74.     if(q==NULL)
  75.    {
  76.     printf("create  q fail\n");
  77.      exit(0);
  78.    }
  79.       q =q->next;
  80.   }
  81.  
  82.     newNode2->next = q->next;
  83.       
  84.      q->next = newNode2;
  85. }
  86.   int main()
  87.   {
  88.       
  89.     int i;
  90.     STU *link=NULL;
  91.     link =CreateLinkList();
  92.       
  93.    InsertHeadNode(link, 1);
  94.    InsertHeadNode(link, 2);
  95.    InsertHeadNode(link, 3);
  96.    InsertHeadNode(link, 4);
  97.    PrintList(link);  
  98.    InsertNode(link,9);  
  99.    PrintList(link);     
  100.      return 0; 
  101.       
  102.   }
  103.

 7、链表查找（查找int类型的数据）

  1. STU * link_search_num(STU *head,int data)
  2.   {           
  3.          STU * pmove = head;
  4.  
  5.         whlie(pmove != NULL)
  6.        {
  7.  
  8.                                    //如果找到是当前结点数据，则返回当前结点的地址
  9.            if(pmove->data==data)
  10.  
  11.           {
  12.              return pmove;
  13.           }
  14.                                   //如果没有找到，则继续对比下一个结点的指针域
  15.              pmove=pmove->next;
  16.            
  17.         }
  18.                                    //当循环结束的时候还没有找到，返回一个NULL给主函数
  19.             return NULL;           //没有找到
  20.      }

 7.1链表查找（查找char类型的数据）

  1. typedef struct Node         
  2. {
  3.    //数据域
  4.      int data;         
  5.      char name[20]; 
  6.    //指针域
  7.      struct Node *next;
  8. }STU;
  9.  
  10.  
  11. STU * link_search_name(STU *head,char *name)
  12.   {           
  13.          STU * pmove = head;
  14.  
  15.         whlie(pmove != NULL)
  16.        {
  17.  
  18.                                            //如果找到是当前结点数据，则返回当前结点的地址
  19.            if(strcmp(pmove->name,name)==0) //找到了
  20.           {
  21.              return pmove;
  22.           }
  23.           
  24.                                            //如果没有找到，则继续对比下一个结点的指针域
  25.              pmove=pmove->next;
  26.  
  27.         }
  28.                                         //当循环结束的时候还没有找到，返回一个NULL给主函数
  29.             return NULL;                 //没有找到
  30.      }

7.2简单链表查找使用（完整代码）

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. #define ERROR O
  5. #define  OK  1
  6. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  7. typedef struct Node         
  8. {
  9.    //数据域
  10.      int data;         
  11.  
  12.    //指针域
  13.      struct Node *next;
  14. }STU;
  15.  
  16. STU * CreateLinkList()         
  17. {
  18.    STU * head = NULL;
  19.  
  20.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  21.    if(head==NULL)
  22.   {
  23.      exit(0);
  24.    }
  25.     head ->next = NULL;
  26.     return head;
  27. }
  28.  
  29. STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
  30.                                    //方便使用
  31. {
  32.    STU * newNode = ( STU *)malloc(sizeof(STU));
  33.  
  34.    newNode->data=data;
  35.    newNode->next=NULL;
  36.    
  37.    return newNode;
  38. }
  39.  
  40. void InsertHeadNode(STU *head,int data)
  41. {
  42.     STU * newNode =CreateNode(data); 
  43.  
  44.     newNode->next = head->next;
  45.     head->next=newNode;
  46.     
  47. }
  48.  
  49. void PrintList(STU *head)
  50. {
  51.  
  52.    STU *pmove = head->next;       
  53.     while(pmove)
  54.   {
  55.     printf("%d",pmove->data);     
  56.     pmove=pmove->next;
  57.   }   
  58.    
  59.     printf("\n");
  60.    
  61. }
  62. STU * link_search_num(STU *head,int data)
  63.   {           
  64.          STU * pmove = head;
  65.  
  66.         while(pmove != NULL)
  67.        {
  68.  
  69.                                  //如果找到是当前结点数据，则返回当前结点的地址
  70.            if(pmove->data==data)
  71.  
  72.           {
  73.              return pmove;
  74.           }
  75.            
  76.                                  //如果没有找到，则继续对比下一个结点的指针域
  77.              pmove=pmove->next;
  78.         }
  79.                                   //当循环结束的时候还没有找到，返回一个NULL给主函数
  80.             return NULL;           //没有找到
  81.     }
  82.  
  83.   int main()
  84.   {
  85.       
  86.     int i;
  87.     STU *link=NULL;
  88.     STU *p =NULL;
  89.     link =CreateLinkList();
  90.       
  91.    InsertHeadNode(link, 1);
  92.    InsertHeadNode(link, 2);
  93.    InsertHeadNode(link, 3);
  94.    InsertHeadNode(link, 4);
  95.    PrintList(link); 
  96.    p=link_search_num(link,3);    // 查找3这个数据 
  97.   if(p !=NULL)
  98.   {	  
  99.    printf("%d\n",p->data);        //打印查找的数据   
  100.   }
  101.   else
  102.   {
  103. 	  printf("没有这个数据\n");
  104.    }	
  105. 	  return 0; 
  106.       
  107.   }
  108.  
  109.

运行结果

4321
3

 8、链表的删除某个数据

  1. int dellte_List(STU *head,int deldata)
  2.  { 
  3.  
  4.  //定义两个指针，一个指该删除数据前一个结点（ppre），一个指向该删除数据的结点（pp）
  5.      STU *pp = head->next; 
  6.       
  7.       STU *ppre = head;          
  8.  
  9.     while(pp != NULL)
  10.     {
  11.   
  12.        pp= pp->next;
  13.        ppre=ppre->next;
  14.  
  15.       if(pp->data==deldata)
  16.       {
  17.          break;
  18.         }
  19. 	 }
  20.        if(!pp)          //如果p是有该数据，则为真。！p则为假，就不会执行
  21.       {
  22.         return 0;
  23.       }
  24.         ppre->next = pp->next;
  25.          free(pp); 
  26.         return 1;
  27.      }

删除操作示意图 

 8.1简单删除操作使用

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. #define ERROR O
  5. #define  OK  1
  6. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  7. typedef struct Node         
  8. {
  9.    //数据域
  10.      int data;         
  11.  
  12.    //指针域
  13.      struct Node *next;
  14. }STU;
  15.  
  16. STU * CreateLinkList()         
  17. {
  18.    STU * head = NULL;
  19.  
  20.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  21.    if(head==NULL)
  22.   {
  23.      exit(0);
  24.    }
  25.     head ->next = NULL;
  26.     return head;
  27. }
  28.  
  29. STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
  30.                                    //方便使用
  31. {
  32.    STU * newNode = ( STU *)malloc(sizeof(STU));
  33.  
  34.    newNode->data=data;
  35.    newNode->next=NULL;
  36.    
  37.    return newNode;
  38. }
  39.  
  40. void InsertHeadNode(STU *head,int data)
  41. {
  42.     STU * newNode =CreateNode(data); 
  43.  
  44.     newNode->next = head->next;
  45.     head->next=newNode;
  46.     
  47. }
  48.  
  49. void PrintList(STU *head)
  50. {
  51.  
  52.    STU *pmove = head->next;                          //头结点数据是0，因此，从头结点下一个数据开始打印，即head->next
  53.     while(pmove)
  54.   {
  55.     printf("%d",pmove->data);     
  56.     pmove=pmove->next;
  57.   }   
  58.    
  59.     printf("\n");
  60.    
  61. }
  62. STU * link_search_num(STU *head,int data)
  63.   {           
  64.          STU * pmove = head;
  65.  
  66.         while(pmove != NULL)
  67.        {
  68.  
  69.           //如果找到是当前结点数据，则返回当前结点的地址
  70.            if(pmove->data==data)
  71.  
  72.           {
  73.              return pmove;
  74.           }
  75.            
  76.             //如果没有找到，则继续对比下一个结点的指针域
  77.              pmove=pmove->next;
  78.         }
  79.              //当循环结束的时候还没有找到，返回一个NULL给主函数
  80.             return NULL;           //没有找到
  81.     }
  82. int dellte_List(STU *head,int deldata)
  83.  { 
  84.  
  85.  //定义两个指针，一个指该删除数据前一个结点（ppre），一个指向该删除数据的结点（pp）
  86.      STU *pp = head->next; 
  87.       
  88.       STU *ppre = head;          
  89.  
  90.     while(pp != NULL)
  91.     {
  92.   
  93.        pp= pp->next;
  94.        ppre=ppre->next;
  95.  
  96.       if(pp->data==deldata)
  97.       {
  98.          break;
  99.         }
  100. 	 }
  101.        if(!pp)          //如果p是有该数据，则为真。！p则为假，就不会执行
  102.       {
  103.         return 0;
  104.       }
  105.         ppre->next = pp->next;
  106.          free(pp); 
  107.         return 1;
  108.      }
  109.  
  110.   int main()
  111.   {
  112.       
  113.     int i;
  114.     STU *link=NULL;
  115.     STU *p =NULL;
  116.     link =CreateLinkList();
  117.       
  118.    InsertHeadNode(link, 1);
  119.    InsertHeadNode(link, 2);
  120.    InsertHeadNode(link, 3);
  121.    InsertHeadNode(link, 4);
  122.    PrintList(link); 
  123.    p=link_search_num(link,3);    
  124.   if(p !=NULL)
  125.   {	  
  126.    printf("%d\n",p->data);//打印查找的数据   
  127.   }
  128.   else
  129.   {
  130. 	  printf("没有这个数据\n");
  131.    }
  132.     dellte_List(link,3);
  133. 	 PrintList(link); 
  134. 	  return 0; 
  135.       
  136.   }
  137.  
  138.

 运行结果

4321
3
421

9、链表的反转ReverseList()

  1. int ReverseList(STU *h)
  2.  {
  3.     STU  *q =NULL;
  4.     STU  *p =NULL;
  5.     if(h==NULL)
  6.   {
  7.      printf("h 是创建失败\n");  //失败不是空表，是没有这个h的头指针
  8.      return 0;
  9.   }   
  10.  
  11.                          // h->next ==NULL：只有一个头指针，没结点，即空表，反过来还是一样的
  12.                          // h->next->next ==NULL：只有一个结点，反过来还是一样的
  13.   if( h->next ==NULL || h->next->next ==NULL)
  14.  {
  15.    return 1;
  16.  
  17.   }
  18.    p = h->next->next;        //p指向原来链表的第二个结点
  19.                             
  20.    h->next->next =NULL;      //把链表一分为二，h指向的链表只有一个结点。即原来的链表的第一个结点
  21.   
  22. while(p!=NULL)
  23. { 
  24.    q = p;
  25.    p=p->next;
  26.    
  27.    q->next=h->next;
  28.    h->next= q;
  29.  }
  30.     return 0;
  31.   }

9.1简单的链表反转使用（完整代码）

  1. #include<stdio.h>
  2. #include<stdlib.h>
  3.  
  4. #define ERROR O
  5. #define  OK  1
  6. //初始化一个链表里面的需要用的数据，作为模版，为之后创建直接调用
  7. typedef struct Node         
  8. {
  9.    //数据域
  10.      int data;         
  11.  
  12.    //指针域
  13.      struct Node *next;
  14. }STU;
  15.  
  16. STU * CreateLinkList()         
  17. {
  18.    STU * head = NULL;
  19.  
  20.    head=(STU *)malloc(sizeof(STU)); //节点开辟一个空间.head变成指向第一个节点的头指针
  21.    if(head==NULL)
  22.   {
  23.      exit(0);
  24.    }
  25.     head ->next = NULL;
  26.     return head;
  27. }
  28.  
  29. STU *CreateNode(int data)          //插入什么数据，调用此函数，返回这个数据节点指针
  30.                                    //方便使用
  31. {
  32.    STU * newNode = ( STU *)malloc(sizeof(STU));
  33.  
  34.    newNode->data=data;
  35.    newNode->next=NULL;
  36.    
  37.    return newNode;
  38. }
  39.  
  40. void InsertHeadNode(STU *head,int data)
  41. {
  42.     STU * newNode =CreateNode(data); 
  43.  
  44.     newNode->next = head->next;
  45.     head->next=newNode;
  46.     
  47. }
  48.  
  49. void PrintList(STU *head)
  50. {
  51.  
  52.    STU *pmove = head->next;       
  53.     while(pmove)
  54.   {
  55.     printf("%d",pmove->data);     
  56.     pmove=pmove->next;
  57.   }   
  58.    
  59.     printf("\n");
  60.    
  61. }
  62. int ReverseList(STU *h)
  63.  {
  64.     STU  *q =NULL;
  65.     STU  *p =NULL;
  66.     if(h==NULL)
  67.   {
  68.      printf("h 是创建失败\n");  //失败不是空表，是没有这个h的头指针
  69.      return 0;
  70.   }   
  71.  
  72.                          // h->next ==NULL：只有一个头指针，没结点，即空表，反过来还是一样的
  73.                          // h->next->next ==NULL：只有一个结点，反过来还是一样的
  74.   if( h->next ==NULL || h->next->next ==NULL)
  75.  {
  76.    return 1;
  77.  
  78.   }
  79.    p = h->next->next;        //p指向原来链表的第二个结点
  80.                             
  81.    h->next->next =NULL;      //把链表一分为二，h指向的链表只有一个结点。即原来的链表的第一个结点
  82.   
  83. while(p!=NULL)
  84. { 
  85.    q = p;
  86.    p=p->next;
  87.    
  88.    q->next=h->next;
  89.    h->next= q;
  90.  }
  91.     return 0;
  92.   }
  93.   int main()
  94.   {
  95.       
  96.     int i;
  97.     STU *link=NULL;
  98.     link =CreateLinkList();
  99.       
  100.    InsertHeadNode(link, 1);
  101.    InsertHeadNode(link, 2);
  102.    InsertHeadNode(link, 3);
  103.    InsertHeadNode(link, 4);
  104.    PrintList(link);     
  105.    ReverseList(link);
  106.    PrintList(link);   
  107.      return 0; 
  108.       
  109.   }
  110.

运行结果

4321
1234

个人总结，适合小白学习，如有错误，请留下指正，谢谢。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/557127
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号