数据结构3-单链表

已于 2023-05-31 15:34:59 修改
阅读量147 收藏
点赞数 2
分类专栏： 数据结构 文章标签： 数据结构 链表
于 2022-10-16 21:09:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44177768/article/details/127348854
版权

目录

链表（Linked List）

1.单向链表（Single-Linked List）

2.单链表应用-合并有序链表

3.单链表应用-删除链表重复元素

4.单链表应用-查找链表中间节点

5.单链表应用-查找倒数第n个节点

6.单链表应用-逆置单链表

链表（Linked List）

链表通常由一连串节点组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（"links"）

链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。（插入去除都变得方便）但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。

1.单向链表（Single-Linked List）

单链表是链表中结构最简单的。一个单链表的节点(Node)分为两个部分，第一个部分(data)保存或者显示关于节点的信息，另一个部分存储下一个节点的地址。最后一个节点存储地址的部分指向空值。

单向链表只可向一个方向遍历，一般查找一个节点的时候需要从第一个节点开始每次访问下一个节点，一直访问到需要的位置。而插入一个节点，对于单向链表，我们只提供在链表头插入，只需要将当前插入的节点设置为头节点，next指向原头节点即可。删除一个节点，我们将该节点的上一个节点的next指向该节点的下一个节点。

1.创建链表-------》（1）创建节点（分配内存，填充数据域和指针域（NULL））   
                                     （2）将节点链接在一起

linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

//节点结构体
struct node
{
	unsigned char elem;
	struct node *next;
};  //注意；

//函数声明
void create_list(unsigned char elem);     //节点的创建
void insert_node(int pos, unsigned char elem);    // 插入节点
void delete_node(int pos);                //删除节点
void print_linklist(void);               //输出链表
int search(unsigned char elem);          //查询链表中的某个数值 
#endif

linklist.c

#include "linklist.h"
#include <stdlib.h>


struct node *head = NULL; // 头指针
struct node *tail = NULL; // 尾指针 
//节点的创建
void create_list(unsigned char elem)
{
      struct node *p = (struct node *)malloc(sizeof(struct node));
      p->elem = elem;   // 节点内容为elem
      p->next = NULL;   //刚开始节点指针为空
    
      if(head == NULL)
            head = p;          
      else
            tail->next = p;    
      tail = p;               // 更新尾节点
}


// 插入节点
void insert_node(int pos, unsigned char elem)
{
      struct node *pre; // 前趋点
      pre = head;       // 前趋点从头开始
      int i = 0;
      struct node *p = (struct node *)malloc(sizeof(struct node));  // 创建节点
      
      if(pos == 0)               //如果更新头节点
      {
             p->elem = elem;          
             p->next = head;
             head = p;
      }
      else
      { 
            while(i < pos - 1)
            {
                 pre = pre->next; //pre是一个指针，pre->next是该指针所指向结构的一个成员
                 i++;
            }  
            p->elem = elem;        //
            p->next = pre->next;
            pre->next = p; 
            
            if(p->next == NULL)  // 尾节点
                    tail = p;
      }   
}

//删除节点
void delete_node(int pos)
{
         struct node *pre, *p;  // 前趋点
         pre = head;            // 前趋点从头开始
         int i = 0;
         
         if(pos == 0)    // 头结点
         {
              head = head->next;
              free(pre);
         }
         else
         {
              while(i < pos-1)       //更新前趋点直到要删除的前一个
              {
                  pre = pre->next;
                  i++;
              }
         
              p = pre->next;
              pre->next = p->next;
              if(p->next == NULL)
                  tail = pre;
              free(p);
              
         }
}

//输出链表
void print_linklist(void)
{
        struct node *p;
        for(p = head; p; p = p->next)
                printf("%c", p->elem);
}

//查询链表中的某个数值 
int search(unsigned char elem)
{
        struct node *p;
        for(p = head; p; p = p->next)
           if(p->elem == elem)
              return 1;
        return 0;
}

main.c

#include <stdio.h>
#include "linklist.h"


int main(void)
{
         // 创建链表
	     create_list('A');
         create_list('B');
         create_list('Z');
	     create_list('X');
         print_linklist();
         printf("\n");
         //删除
         delete_node(0);
         print_linklist();
         printf("\n");
         //插入
         insert_node(2, 'Z');
         insert_node(0, 'F');
         print_linklist();
         printf("\n");
         //查询
         if(search('A'))
              printf("the elem is found\n");
         else
              printf("the elem is not found\n");
         printf("\n");
         return 0;
}

2.单链表应用-合并有序链表

链表  1      9       13     27
链表  3       5      14     81      88     95     99
合并  1        3      5       9        13      14     27     81    88       95    99

linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *tail;
extern struct node *head;         //main.c 也要使用 head tail
//节点结构体
struct node
{
	unsigned int elem;
	struct node *next;
};  //注意；

//函数声明
void create_list(unsigned int elem);              //节点的创建
void insert_node(int pos, unsigned int elem);     // 插入节点
void delete_node(int pos);                        //删除节点
void print_linklist(struct node *linklist_head);  //输出链表
int search(unsigned int elem);                    //查询链表中的某个数值 
#endif

linklist.c

#include "linklist.h"
#include <stdlib.h>


struct node *head = NULL; // 头指针
struct node *tail = NULL; // 尾指针 
//节点的创建
void create_list(unsigned int elem)
{
      struct node *p = (struct node *)malloc(sizeof(struct node));
      p->elem = elem;
      p->next = NULL;
    
      if(head == NULL)
            head = p;          
      else
            tail->next = p;    
      tail = p;               // 更新尾节点
}


// 插入节点
void insert_node(int pos, unsigned int elem)
{
      struct node *pre; // 前趋点
      pre = head;       // 前趋点从头开始
      int i = 0;
      struct node *p = (struct node *)malloc(sizeof(struct node));  // 创建节点
      
      if(pos == 0)  //如果更新头点节点
      {
             p->elem = elem;
             p->next = head;
             head = p;
      }
      else
      { 
            while(i < pos - 1)
            {
                  pre = pre->next;   //pre是一个指针，pre->next是该指针所指向结构的一个成员
                  i++;
            }  
            p->elem = elem;        //
            p->next = pre->next;
            pre->next = p; 
            
            if(p->next == NULL)  // 尾节点
                    tail = p;
      }   
}

//删除节点
void delete_node(int pos)
{
         struct node *pre, *p; // 前趋点
         pre = head;           // 前趋点从头开始
         int i = 0;
         
         if(pos == 0)         // 如果删除头结点
         {
              head = head->next;
              free(pre);
         }
         else
         {
              while(i < pos-1)  //更新前趋点直到要删除的前一个
              {
                  pre = pre->next;
                  i++;
              }
         
              p = pre->next;
              pre->next = p->next;
              if(p->next == NULL)   //如果删除尾节点
                  tail = pre;
              free(p);
              
         }
}

//输出链表
void print_linklist(struct node *linklist_head)   // 结构体型指针
{
        struct node *p;
        for(p = linklist_head; p; p = p->next)
                printf("%5d", p->elem);
}

//查询链表中的某个数值 
int search(unsigned int elem)
{
        struct node *p;
        for(p = head; p; p = p->next)
           if(p->elem == elem)
              return 1;
        return 0;
}

main.c

#include <stdio.h>
#include "linklist.h"


int main(void)
{ 
         //两个链表的头指针
         struct node *head1 = NULL;
         struct node *head2 = NULL;
         //结构体指针，用来遍历两个链表
         struct node *p = NULL;
         struct node *q = NULL;
         // 创建链表1
         create_list(1);
         create_list(9);
         create_list(13);
         create_list(27);
         head1 = head;
	     print_linklist(head1);
         printf("\n");
         // 创建链表2       
         head = NULL;
         create_list(3);
         create_list(5);
         create_list(14);
         create_list(81);
         create_list(88);
         create_list(95);
         create_list(99);
         head2 = head;
	     print_linklist(head2);
         printf("\n");
         //新链表
         head = NULL;
         p = head1;
         q = head2;
         while(p && q)
         {
                if(p->elem <= q->elem)
                {
                    if(head == NULL)  //head只更新一次
                          head = p;
                    else
                          tail->next = p;
                    tail = p;
                    p = p->next;
                }
                else
                {
                   if(head == NULL)  //head只更新一次
                          head = q;
                   else
                          tail->next = q;
                   tail = q;
                   q = q->next;
                }
         } 
         tail->next = p?p:q;
         print_linklist(head);
         printf("\n");
         return 0;
}

3.单链表应用-删除链表重复元素

辅助数组flag[10]：下标：要检索的内容     元素：状态（是否出现过，0代表没出现过）

元素出现次数0000000000
数组下标0123456789

linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *tail;
extern struct node *head;         //main.c 也要使用 head tail
//节点结构体
struct node
{
	unsigned int elem;
	struct node *next;
};  //注意；

//函数声明
void create_list(unsigned int elem);              //节点的创建
void insert_node(int pos, unsigned int elem);     // 插入节点
void delete_node(int pos);                        //删除节点
void print_linklist(struct node *linklist_head);  //输出链表
int search(unsigned int elem);                    //查询链表中的某个数值 

#endif

linklist.c

#include "linklist.h"
#include <stdlib.h>


struct node *head = NULL; // 头指针
struct node *tail = NULL; // 尾指针 
//节点的创建
void create_list(unsigned int elem)
{
      struct node *p = (struct node *)malloc(sizeof(struct node));
      p->elem = elem;
      p->next = NULL;
    
      if(head == NULL)
            head = p;          
      else
            tail->next = p;    
      tail = p;               // 更新尾节点
}


// 插入节点
void insert_node(int pos, unsigned int elem)
{
      struct node *pre; // 前趋点
      pre = head;       // 前趋点从头开始
      int i = 0;
      struct node *p = (struct node *)malloc(sizeof(struct node));  // 创建节点
      
      if(pos == 0)  //如果更新头点节点
      {
             p->elem = elem;
             p->next = head;
             head = p;
      }
      else
      { 
            while(i < pos - 1)
            {
                  pre = pre->next;   //pre是一个指针，pre->next是该指针所指向结构的一个成员
                  i++;
            }  
            p->elem = elem;        //
            p->next = pre->next;
            pre->next = p; 
            
            if(p->next == NULL)  // 尾节点
                    tail = p;
      }   
}

//删除节点
void delete_node(int pos)
{
         struct node *pre, *p; // 前趋点
         pre = head;           // 前趋点从头开始
         int i = 0;
         
         if(pos == 0)         // 如果删除头结点
         {
              head = head->next;
              free(pre);
         }
         else
         {
              while(i < pos-1)  //更新前趋点直到要删除的前一个
              {
                  pre = pre->next;
                  i++;
              }
         
              p = pre->next;
              pre->next = p->next;
              if(p->next == NULL)   //如果删除尾节点
                  tail = pre;
              free(p);
              
         }
}

//输出链表
void print_linklist(struct node *linklist_head)   // 结构体型指针
{
        struct node *p;
        for(p = linklist_head; p; p = p->next)
                printf("%5d", p->elem);
}

//查询链表中的某个数值 
int search(unsigned int elem)
{
        struct node *p;
        for(p = head; p; p = p->next)
           if(p->elem == elem)
              return 1;
        return 0;
}


//删除重复元素
void delete_repeat(struct node *head)
{
       int flag[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       struct node *p = head;
       struct node *q = NULL;
      
       flag[p->elem] = 1;
       while(p->next != NULL)
       {
            if(flag[p->next->elem] == 0)
            {
                 flag[p->next->elem] = 1;
                 p = p->next;
            }
            else
            {
                 q = p->next;
                 p->next = q->next;
                 free(q);
            }
       }
}

main.c

#include <stdio.h>
#include "linklist.h"


int main(void)
{ 
         // 创建链表1
         create_list(1);
         create_list(2);
         create_list(3);
         create_list(4);
         create_list(5);
         create_list(6);
         
         print_linklist(head);
         printf("\n");
         delete_repeat(head);
         print_linklist(head);
         printf("\n");

         return 0;

        
}

4.单链表应用-查找链表中间节点

快慢指针的使用：快指针走两步，慢指针走一步

linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *tail;
extern struct node *head;         //main.c 也要使用 head tail
//节点结构体
struct node
{
	unsigned int elem;
	struct node *next;
};  //注意；

//函数声明
void create_list(unsigned int elem);              //节点的创建
void insert_node(int pos, unsigned int elem);     // 插入节点
void delete_node(int pos);                        //删除节点
void print_linklist(struct node *linklist_head);  //输出链表
int search(unsigned int elem);                    //查询链表中的某个数值 
void delete_repeat(struct node *head);            //删除重复元素
int find_mid(struct node *head);                  //查找中间节点元素
#endif

linklist.c

#include "linklist.h"
#include <stdlib.h>


struct node *head = NULL; // 头指针
struct node *tail = NULL; // 尾指针 
//节点的创建
void create_list(unsigned int elem)
{
      struct node *p = (struct node *)malloc(sizeof(struct node));
      p->elem = elem;
      p->next = NULL;
    
      if(head == NULL)
            head = p;          
      else
            tail->next = p;    
      tail = p;               // 更新尾节点
}


// 插入节点
void insert_node(int pos, unsigned int elem)
{
      struct node *pre; // 前趋点
      pre = head;       // 前趋点从头开始
      int i = 0;
      struct node *p = (struct node *)malloc(sizeof(struct node));  // 创建节点
      
      if(pos == 0)  //如果更新头点节点
      {
             p->elem = elem;
             p->next = head;
             head = p;
      }
      else
      { 
            while(i < pos - 1)
            {
                  pre = pre->next;   //pre是一个指针，pre->next是该指针所指向结构的一个成员
                  i++;
            }  
            p->elem = elem;        //
            p->next = pre->next;
            pre->next = p; 
            
            if(p->next == NULL)  // 尾节点
                    tail = p;
      }   
}

//删除节点
void delete_node(int pos)
{
         struct node *pre, *p; // 前趋点
         pre = head;           // 前趋点从头开始
         int i = 0;
         
         if(pos == 0)         // 如果删除头结点
         {
              head = head->next;
              free(pre);
         }
         else
         {
              while(i < pos-1)  //更新前趋点直到要删除的前一个
              {
                  pre = pre->next;
                  i++;
              }
         
              p = pre->next;
              pre->next = p->next;
              if(p->next == NULL)   //如果删除尾节点
                  tail = pre;
              free(p);
              
         }
}

//输出链表
void print_linklist(struct node *linklist_head)   // 结构体型指针
{
        struct node *p;
        for(p = linklist_head; p; p = p->next)
                printf("%5d", p->elem);
}

//查询链表中的某个数值 
int search(unsigned int elem)
{
        struct node *p;
        for(p = head; p; p = p->next)
           if(p->elem == elem)
              return 1;
        return 0;
}


//删除重复元素
void delete_repeat(struct node *head)
{
       int flag[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       struct node *p = head;
       struct node *q = NULL;
      
       flag[p->elem] = 1;
       while(p->next != NULL)
       {
            if(flag[p->next->elem] == 0)
            {
                 flag[p->next->elem] = 1;
                 p = p->next;
            }
            else
            {
                 q = p->next;
                 p->next = q->next;
                 free(q);
            }
       }
}

//查找中间节点
int find_mid(struct node *head)
{
       struct node *p;
       struct node *q;
       p = q = head;
       
       while(p != NULL && p->next != NULL)
       {
            p = p->next->next;
            q = q->next; 
       }
       return q->elem;
}

main.c 

#include <stdio.h>
#include "linklist.h"


int main(void)
{ 
         // 创建链表1
         create_list(1);
         create_list(2);
         create_list(1);
         create_list(4);
         create_list(5);
         create_list(4);

         print_linklist(head);

         printf("\n");
         printf("mid = %d\n", find_mid(head));
         return 0;
}

5.单链表应用-查找倒数第n个节点

快慢指针的使用：快指针先走n-1步，然后快慢指针同时一步一步的走

linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *tail;
extern struct node *head;         //main.c 也要使用 head tail
//节点结构体
struct node
{
	unsigned int elem;
	struct node *next;
};  //注意；

//函数声明
void create_list(unsigned int elem);              //节点的创建
void insert_node(int pos, unsigned int elem);     // 插入节点
void delete_node(int pos);                        //删除节点
void print_linklist(struct node *linklist_head);  //输出链表
int search(unsigned int elem);                    //查询链表中的某个数值 
void delete_repeat(struct node *head);            //删除重复元素
int find_mid(struct node *head);                  //查找中间节点元素
int find_last_nth(struct node *head, int n);       //查找倒数第n个节点
#endif

linklist.c

#include "linklist.h"
#include <stdlib.h>


struct node *head = NULL; // 头指针
struct node *tail = NULL; // 尾指针 
//节点的创建
void create_list(unsigned int elem)
{
      struct node *p = (struct node *)malloc(sizeof(struct node));
      p->elem = elem;
      p->next = NULL;
    
      if(head == NULL)
            head = p;          
      else
            tail->next = p;    
      tail = p;               // 更新尾节点
}


// 插入节点
void insert_node(int pos, unsigned int elem)
{
      struct node *pre; // 前趋点
      pre = head;       // 前趋点从头开始
      int i = 0;
      struct node *p = (struct node *)malloc(sizeof(struct node));  // 创建节点
      
      if(pos == 0)  //如果更新头点节点
      {
             p->elem = elem;
             p->next = head;
             head = p;
      }
      else
      { 
            while(i < pos - 1)
            {
                  pre = pre->next;   //pre是一个指针，pre->next是该指针所指向结构的一个成员
                  i++;
            }  
            p->elem = elem;        //
            p->next = pre->next;
            pre->next = p; 
            
            if(p->next == NULL)  // 尾节点
                    tail = p;
      }   
}

//删除节点
void delete_node(int pos)
{
         struct node *pre, *p; // 前趋点
         pre = head;           // 前趋点从头开始
         int i = 0;
         
         if(pos == 0)         // 如果删除头结点
         {
              head = head->next;
              free(pre);
         }
         else
         {
              while(i < pos-1)  //更新前趋点直到要删除的前一个
              {
                  pre = pre->next;
                  i++;
              }
         
              p = pre->next;
              pre->next = p->next;
              if(p->next == NULL)   //如果删除尾节点
                  tail = pre;
              free(p);
              
         }
}

//输出链表
void print_linklist(struct node *linklist_head)   // 结构体型指针
{
        struct node *p;
        for(p = linklist_head; p; p = p->next)
                printf("%5d", p->elem);
}

//查询链表中的某个数值 
int search(unsigned int elem)
{
        struct node *p;
        for(p = head; p; p = p->next)
           if(p->elem == elem)
              return 1;
        return 0;
}


//删除重复元素
void delete_repeat(struct node *head)
{
       int flag[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       struct node *p = head;
       struct node *q = NULL;
      
       flag[p->elem] = 1;
       while(p->next != NULL)
       {
            if(flag[p->next->elem] == 0)
            {
                 flag[p->next->elem] = 1;
                 p = p->next;
            }
            else
            {
                 q = p->next;
                 p->next = q->next;
                 free(q);
            }
       }
}

//查找中间节点
int find_mid(struct node *head)
{
       struct node *p;
       struct node *q;
       p = q = head;
       
       while(p != NULL && p->next != NULL)
       {
            p = p->next->next;
            q = q->next; 
       }
       return q->elem;
}

//查找倒数第n个节点
int find_last_nth(struct node *head, int n)
{
       int i;
       struct node *p;
       struct node *q;
       p = q = head;
       
       for(i = 0; i < n-1; i++)
            p = p->next;
       while(p->next != NULL)
       {
            p = p->next;
            q = q->next;
       }
       
       return  q->elem;
}

main.c

#include <stdio.h>
#include "linklist.h"


int main(void)
{ 
         int n;
         // 创建链表1
         create_list(1);
         create_list(2);
         create_list(3);
         create_list(4);
         create_list(5);
         create_list(6);
         create_list(7);
         create_list(8);
         create_list(9);
         create_list(10);
         create_list(11);
         create_list(12);
         
         printf("please enter the last one you want to show:");
         scanf("%d", &n);
      
         printf("the last n:%d\n", find_last_nth(head, n));
         printf("\n");

         return 0;
}

6.单链表应用-逆置单链表

linklist.h

#ifndef LINKLIST_H__
#define LINKLIST_H__

#include <stdio.h>

extern struct node *tail;
extern struct node *head;         //main.c 也要使用 head tail
//节点结构体
struct node
{
	unsigned int elem;
	struct node *next;
};  //注意；

//函数声明
void create_list(unsigned int elem);              //节点的创建
void insert_node(int pos, unsigned int elem);     // 插入节点
void delete_node(int pos);                        //删除节点
void print_linklist(struct node *linklist_head);  //输出链表
int search(unsigned int elem);                    //查询链表中的某个数值 
void delete_repeat(struct node *head);            //删除重复元素
int find_mid(struct node *head);                  //查找中间节点元素
int find_last_nth(struct node *head, int n);       //查找倒数第n个节点
void reverse_linklist(struct node *linklist_head); //逆置链表
#endif

linklist.c

#include "linklist.h"
#include <stdlib.h>


struct node *head = NULL; // 头指针
struct node *tail = NULL; // 尾指针 
//节点的创建
void create_list(unsigned int elem)
{
      struct node *p = (struct node *)malloc(sizeof(struct node));
      p->elem = elem;
      p->next = NULL;
    
      if(head == NULL)
            head = p;          
      else
            tail->next = p;    
      tail = p;               // 更新尾节点
}


// 插入节点
void insert_node(int pos, unsigned int elem)
{
      struct node *pre; // 前趋点
      pre = head;       // 前趋点从头开始
      int i = 0;
      struct node *p = (struct node *)malloc(sizeof(struct node));  // 创建节点
      
      if(pos == 0)  //如果更新头点节点
      {
             p->elem = elem;
             p->next = head;
             head = p;
      }
      else
      { 
            while(i < pos - 1)
            {
                  pre = pre->next;   //pre是一个指针，pre->next是该指针所指向结构的一个成员
                  i++;
            }  
            p->elem = elem;        //
            p->next = pre->next;
            pre->next = p; 
            
            if(p->next == NULL)  // 尾节点
                    tail = p;
      }   
}

//删除节点
void delete_node(int pos)
{
         struct node *pre, *p; // 前趋点
         pre = head;           // 前趋点从头开始
         int i = 0;
         
         if(pos == 0)         // 如果删除头结点
         {
              head = head->next;
              free(pre);
         }
         else
         {
              while(i < pos-1)  //更新前趋点直到要删除的前一个
              {
                  pre = pre->next;
                  i++;
              }
         
              p = pre->next;
              pre->next = p->next;
              if(p->next == NULL)   //如果删除尾节点
                  tail = pre;
              free(p);
              
         }
}

//输出链表
void print_linklist(struct node *linklist_head)   // 结构体型指针
{
        struct node *p;
        for(p = linklist_head; p; p = p->next)
                printf("%5d", p->elem);
}

//查询链表中的某个数值 
int search(unsigned int elem)
{
        struct node *p;
        for(p = head; p; p = p->next)
           if(p->elem == elem)
              return 1;
        return 0;
}


//删除重复元素
void delete_repeat(struct node *head)
{
       int flag[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
       struct node *p = head;
       struct node *q = NULL;
      
       flag[p->elem] = 1;
       while(p->next != NULL)
       {
            if(flag[p->next->elem] == 0)
            {
                 flag[p->next->elem] = 1;
                 p = p->next;
            }
            else
            {
                 q = p->next;
                 p->next = q->next;
                 free(q);
            }
       }
}

//查找中间节点
int find_mid(struct node *head)
{
       struct node *p;
       struct node *q;
       p = q = head;
       
       while(p != NULL && p->next != NULL)
       {
            p = p->next->next;
            q = q->next; 
       }
       return q->elem;
}

//查找倒数第n个节点
int find_last_nth(struct node *head, int n)
{
       int i;
       struct node *p;  //快指针
       struct node *q;  //慢指针
       p = q = head;
       
       for(i = 0; i < n-1; i++) //快指针先走n-1步
            p = p->next;
       while(p->next != NULL)   //只要p->next不为空，p q 就一直一起走
       {
            p = p->next;
            q = q->next;
       }
       
       return  q->elem;  
}


// 逆置链表
void reverse_linklist(struct node *linklist_head)
{
       struct node *p, *n;
       
       p = linklist_head->next;
       linklist_head->next = NULL;

       while(p->next != NULL)
       {
            n = p->next;
            p->next = linklist_head;
            linklist_head =  p;
            p = n;
       }
       p->next = linklist_head;
       linklist_head = p;
       head = linklist_head;     //给全局变量特别重要，要不无法正常输出
                                 //因为传入的实参head始终指向的原来的头，变得是形参 
                                 //linklist_head
}

main.c

#include <stdio.h>
#include "linklist.h"


int main(void)
{ 
         int n;
         // 创建链表1
         create_list(1);
         create_list(2);
         create_list(3);
         create_list(4);
         create_list(5);
         create_list(6);
         create_list(7);
         create_list(8);
         create_list(9);
         create_list(10);
         create_list(11);
         create_list(12);
         
         reverse_linklist(head);  //逆转
         print_linklist(head);    //输出显示，注意这里在Linklist.c的操作
         printf("\n");

         return 0;
}

I'mFAN
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构--单链表反转（图文教程）
Mr_L001的博客
09-07 1665
今天突然听朋友提到单链表，就想写一个图文教程，有不对的地方希望大家指出，共同进步！ 链表反转代码 void reserveLinkList(Node *L) { Node *p,*q,*t; //*p--前驱指针，*q--当前指针，*t--缓存的下一个结点 p = L; q = L->next; if(L==NULL || L->nex...
数据结构--单链表操作实验报告
04-12
1.从键盘输入顺序任意的5个整数，按有序插入的要求生成第一个有序单链表，将该链表输出显示。...3.将这两个有序单链表合并成一个有序单链表，要求使用两个单链表的原有空间进行合并，将生成的有序单链表输出显示。
单链表的基本操作（三）单链表的创建
gets_s的博客
03-07 754
1、尾插法创建一个单链表（顺序输入一个数组） Linklist Createndlist(int a[N]) { Linklist L; L = (Lnode*)malloc(sizeof(Lnode)); if (L == NULL) { cout << "error"; exit(0); } else L->next = NULL; Linklist t...
C语言实现新建一个单链表并打印输出
2201_75648436的博客
03-11 3394
本篇文章主要讲述如何用C语言新建一个单链表并打印输出。
数据结构---单链表
m0_56064145的博客
03-20 2233
前言：单链表是后面要学的双链表以及循环链表的基础，要想继续深入了解数据结构以及C++，我们就要奠定好这块基石！接下来就和我一起学习吧！ 这里我们来简单实现单链表的增删查找。 头文件 ...
C/C++数据结构---单链表逆转（PTA）
敲代码嘞~的博客
09-27 1209
对于初次学习数据结构，一定要把最基础的，最简单的样例给写的十分熟练，自己每写一遍也将会增加对其结构的理解，为接下来更难的知识打好坚实的基础！一定一定不要一味的照着别人的代码敲，最后一定要自己独自去写！其中List/* 存储结点数据 *//* 指向下一个结点的指针 *//* 定义单链表类型 */L是给定单链表，函数Reverse要返回被逆转后的链表。
数据结构--单链表的查找
m0_60593173的博客
06-27 1736
均以带头结点链表为例:按位查找操作。获取表L中第i个位置的元素的值。:按值查找操作。在表L中查找具有给定关键字值的元素。
C++数据结构---单链表
weixin_45196915的博客
09-08 1229
C++数据结构—单链表 基础知识 单链表是线性表的一种，是指用链式存储结构表示线性关系，使逻辑上相邻的元素在结构上也相邻。 线性关系是指除了首元元素和尾元元素，任何结点都只有一个一个前驱和一个后继，首元没有前驱尾元没有后继。 链式存储结构不同与顺序存储结构其存储空间不是一片连续的存储单元，每个空间除了存储数据信息，还要存储数据的逻辑关系。所以用一个结点来表示，每个结点包含数据域和指针域，数据域用于存储元素本身，指针域定义了一个指针，用于指向元素的下一个结点（指向后继），从而形成链式结构。 根据链表结点所含指
数据结构-单链表
qq_54227351的博客
11-08 1549
链表是数据结构中线性表的一种，其中的每个元素实际上是一个单独的结构体对象，而所有对象都通过每个元素中的指针链接在一起。它是以结构体为节点，将一个结构体看成数据域和指针域两个部分，数据域用于存储数据，指针域用于连接下一个节点。链表中每个结构体对象叫做节点，其中第一个数据节点叫做链表的首元节点；如果第一个节点不用于存储数据，只用于代表链表的起始点，则这个节点称为链表的头节点。
【数据结构--单链表】
qq_61719813的博客
04-30 1213
文章目录单链表一、单链表的定义二、线性表的链式存储结构三、单链表的实现单链表存储结构代码初始化单链表打印单链表向单链表中添加元素单链表的读取单链表的插入单链表的删除单链表的整表删除完整代码运行截图闵版代码（略改）四、总结 单链表 一、单链表的定义 ​ 由于顺序表的插入删除操作需要移动大量的元素，影响了运行效率，因此引入了线性表的链式存储——单链表。 单链表示意图 二、线性表的链式存储结构 ​ 线性表的链式存储结构：线性表中数据元素（结点）在存储器中的位置是任意的，即逻辑上相邻的数据元素在物理位置上不一定相
数据结构-单链表操作
有朋自远方来，不亦乐乎。
07-27 1248
注意步骤（2）（3）的顺序不能颠倒，否则会导致插入位置后的部分链表丢失。（2）将新结点的next指针指向插入位置后的结点。（3）将插入位置前的节点指针next指向新的结点。（2）手动释放掉结点，回收被结点占用的存储空间。插入位置一共分三种，分别是头部插入、中间插入和尾部插入。先找到目标位置再更改结点的数据域。（1）创建一个新的要插入的结点。（1）将结点从链表中摘下。...
数据结构实验-单链表的相关运算
05-12
单链表的存储结构定义为： typedef struct LNode{ ElemType data; //数据域 struct LNode *next; //指针域 }LNode； 三、实验内容 编写主函数，在主函数中调用建立单链表的算法创建一个单链表，然后调用查找、...
数据结构C语言-单链表操作实验
04-23
数据结构C语言版，单链表操作的菜单式实验，包括单链表的初始化、创建、求表长、插入删除元素、销毁和清空单链表等操作，具体操作根据屏幕提示进行。
数据结构-单链表的操作
06-28
数据结构-单链表的操作
数据结构学习笔记-单链表
02-16
在所有数据结构中，链表是一种基础且重要的类型，尤其是单链表。本学习笔记将聚焦于单链表的概念、操作以及在VS2022环境下如何实现。 单链表是一种线性数据结构，其元素（节点）不是在内存中连续存储的，而是通过...
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1066
可以参考以下视频。
数据结构day3
qq_55245263的博客
07-18 286
顺序表实现学生管理系统
【面试题】数据结构：堆排序的排序思想？
Colorful___的博客
07-18 711
堆排序是一种高效的排序算法，其基本思想是利用堆这种数据结构来实现排序。堆是一种特殊的完全二叉树，通常用数组来表示。
数据结构---二叉树
最新发布
weixin_47808575的博客
07-22 40
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
c语言数据结构--单链表 算法函数的实现(查找位序)
09-04
单链表是一种常见的数据结构，它由一个或多个节点组成，每个节点包含一个数据域和一个指针域，指针域指向下一个节点。 实现单链表的查找位序算法函数需要以下步骤： 1. 定义一个指针p指向链表的头节点，并定义一个变量count，用于计数。 2. 从头节点开始，遍历链表，当p指向某个节点时，计数器count加1。 3. 如果p指向的节点的数据与目标数据相等，则返回当前的计数器count，即为目标数据的位序。 4. 如果p指向的节点不是目标数据，则将p指向下一个节点，重复步骤3。 5. 如果遍历完链表后仍未找到目标数据，则返回-1，表示未找到。 下面是C语言实现单链表查找位序算法函数的代码示例： ```c #include <stdio.h> #include <stdlib.h> // 定义单链表节点结构 typedef struct Node { int data; // 数据域 struct Node* next; // 指针域 } Node; // 查找位序的算法函数 int findPosition(Node* head, int target) { Node* p = head; // 指向头节点 int count = 0; // 计数器初始化为0 while (p != NULL) { count++; // 计数器加1 if (p->data == target) { return count; // 找到目标数据，返回当前计数器的值 } p = p->next; // 指向下一个节点 } return -1; // 遍历完链表未找到目标数据，返回-1 } int main() { // 创建链表 Node* head = (Node*)malloc(sizeof(Node)); head->data = 1; // 头节点数据为1 Node* node1 = (Node*)malloc(sizeof(Node)); node1->data = 2; Node* node2 = (Node*)malloc(sizeof(Node)); node2->data = 3; head->next = node1; node1->next = node2; node2->next = NULL; // 查找位序示例 int target = 3; // 目标数据为3 int position = findPosition(head, target); if (position != -1) { printf("目标数据 %d 的位序为 %d\n", target, position); } else { printf("未找到目标数据 %d\n", target); } // 释放链表内存 free(node2); free(node1); free(head); return 0; } ``` 在上述代码中，我们首先定义了一个指向头节点的指针p和一个计数器count，然后使用while循环遍历链表。当p指向某个节点时，计数器加1，并判断该节点的数据是否与目标数据相等。如果找到了目标数据，则返回当前计数器的值，即为目标数据的位序。如果遍历完链表仍未找到目标数据，则返回-1表示未找到。最后在主函数中演示了调用该算法函数的示例。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值