单链表的操作

最新推荐文章于 2024-07-07 21:10:32 发布
最新推荐文章于 2024-07-07 21:10:32 发布
阅读量650 收藏 1
点赞数
文章标签： c语言 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_53425020/article/details/121443649
版权

对该代码中函数做一些简单介绍  

仅涉及C语言

主要实现功能：单链表的

1.后插；

2.删除;

3.查找；   

4.输出；

5.退出； 

6.前插；

7. 排序 ;

8.将头节点变成末节点；

注意：实验中需要先插入将空链表变成一个可执行操作的单链表可采用前插或后插进行

插入后是这个形式

1.数据函数的1初始化

 

 typedef struct Node
    {
        ElemType data;//数据域
        struct Node *next;//指针域
    }LNode,*LinkList;
//初始化函数
    Status InitList(LinkList &L)
    {
     L = new LNode;//生成头结点 这样删除等操作就不必分第一个结点和其他了
     L->next = NULL;
     return 1;
    }
    
    //获取单链表长度 头结点无数据，不算
    int ListLength(LinkList L)
    {
        LinkList p=L;int sum=0;
        while(p)
        {
         sum++;
         p=p->next;
        }
        return sum-1;//去除头结点
    }

然后进行一系列函数的定义，通过学习的一些C语言基本思想实现，如for循环，if判断语句，函数调用等

具体思想参考注释

1.删除

    bool ListInsert(LinkList &L,int i,ElemType e)
    {
        LNode* s;LinkList p=L;int j=0;
        while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
        {
         p=p->next;
         ++j;
        }
        if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
        {
            printf("插入位置无效！！！\n");
            return false;
        }
        s=new LNode;
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
    
    void Delete(LinkList L)
    {
      int place;bool flag;
      printf("请输入要删除的位置(从1开始):\n");
      scanf("%d",&place);
      flag=ListDelete(L,place);
      if(flag)
      {
        printf("删除成功！！！\n");
        PrintList(L);
      }
      return;
    }

执行结果如下：

 2.插入

注

意分析前插后插的区别

bool ListInsert(LinkList &L,int i,ElemType e)
    {
        LNode* s;LinkList p=L;int j=0;
        while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
        {
         p=p->next;
         ++j;
        }
        if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
        {
            printf("插入位置无效！！！\n");
            return false;
        }
        s=new LNode;
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }

void Insert(LinkList &L)
    {
      int place;ElemType e;bool flag;
      printf("请输入要插入的位置(从1开始)及元素:\n");
      scanf("%d%d",&place,&e);
      flag=ListInsert(L,place,e);
      if(flag)
      {
        printf("插入成功！！！\n");
        PrintList(L);
      }
    }
    void Insert2(LinkList &L)
    {
      int place;ElemType e;bool flag;
      printf("请输入要插入的位置(从1开始)及元素:\n");
      scanf("%d%d",&place,&e);
      flag=insert2(L,place,e);
      if(flag)
      {
        printf("插入成功！！！\n");
        PrintList(L);
      }
    }

结果如下

3

3.查找：通过位置查到想要的数据

    LNode *LocateElem(LinkList L,ElemType e)
    {
        LNode *p=L;
        while(p&&(p->data!=e))
        {
            p=p->next;
        }
        return p;
    }
    void Search(LinkList L)
    {
      ElemType e;LNode *q;
      printf("请输入要查找的值:\n");
      scanf("%d",&e);
      q=LocateElem(L,e);
      if(q)
      {
        printf("找到该元素！\n");
      }
      else
        printf("未找到该元素！\n");
    }

结果如下

 

4.排序

    void sort(LinkList &L)//链表选择排序
    {
    struct Node *p;  //=(struct Node*)malloc(sizeof(struct Node));
    struct Node *q;   //=(struct Node*)malloc(sizeof(struct Node));
    ElemType t;
    for(p=L->next; p!=NULL ; p=p->next)//选定的位置，从第一个位置开始
    {
        for(q=p->next;q!=NULL;q=q->next)//每次遍历一遍链表，只要比选定位置的数据小就交换
        {
            if(q->data<p->data)
            {
                t=q->data;
                q->data=p->data;
                p->data=t;
            }
        }
    }
    PrintList(L);
}

结果如下

 

5.逆序

	void Nshow(LinkList L){
    	LinkList p = L->next;
    	int i = ListLength(L);
    	if(i == 0){
    		printf("链表为空~~~\n");
    		return;
		}
		if(i == 1){
			printf("%d  \n",p->data);
			return;
		}
    	int arr[i];
    	i = 0;
    	while(p != NULL){
    		arr[i] = p->data;
    		p = p->next;
    		i = i + 1;
		}
		for(i = i - 1; i >= 0; i--){
			printf("%d  ",arr[i]);
		}
		printf("\n");
    	
	}

结果如下

 

6.头节点变为末节点

 

	void change(LinkList L){
		LinkList p = L;
		Node* q = L->next;
		if(q && q->next != NULL){
		    while(p->next != NULL){
		    	p = p->next;
		    }
		    p->next = q;
		    L->next = q->next;
		    q->next = NULL;
	    }
	    return;
	}

结果如下

 

总源码如下：

#include<cstdio>
    #include<cstdlib>
    #include<cstring>
    #include<cmath>
    #include<iostream>
    using namespace std;
    #define Status int
    #define ElemType int
    //单链表结点数据结构
    typedef struct Node
    {
        ElemType data;//数据域
        struct Node *next;//指针域
    }LNode,*LinkList;
    
    //**************************基本操作函数***************************//
    //初始化函数
    Status InitList(LinkList &L)
    {
     L = new LNode;//生成头结点 这样删除等操作就不必分第一个结点和其他了
     L->next = NULL;
     return 1;
    }
    
    //获取单链表长度 头结点无数据，不算
    int ListLength(LinkList L)
    {
        LinkList p=L;int sum=0;
        while(p)
        {
         sum++;
         p=p->next;
        }
        return sum-1;//去除头结点
    }
    
    bool ListInsert(LinkList &L,int i,ElemType e)
    {
        LNode* s;LinkList p=L;int j=0;
        while(p&&(j<i-1))//j指到i-1位置或者p已经到最后时跳出
        {
         p=p->next;
         ++j;
        }
        if(!p||j>i-1)//i<1或者i>ListLength(L)+1时,插入位置无效 不调用ListLength,提高效率
        {
            printf("插入位置无效！！！\n");
            return false;
        }
        s=new LNode;
        s->data=e;
        s->next=p->next;
        p->next=s;
        return true;
    }
    
    //删除函数 删除位置i的结点 即删除i-1之后的结点
    bool ListDelete(LinkList &L,int i)
    {
         LNode* s;LinkList p=L;int j=0;
        LinkList q;
        while(p&&(j<i-1))//j指到i-1位置
        {
         p=p->next;
         ++j;
        }
        if(!(p->next)||j>i-1)//i<1或者i>ListLength(L)时,删除位置无效
        {
            printf("删除位置无效！！！\n");
            return false;
        }
        q=p->next;
        p->next=q->next;
        free(q);//释放空间
        return true;
    }
    //查找函数 按值查找 查找第一个等于e的结点 成功返回该结点指针，否则返回NULL
    LNode *LocateElem(LinkList L,ElemType e)
    {
        LNode *p=L;
        while(p&&(p->data!=e))
        {
            p=p->next;
        }
        return p;
    }
    //**************************功能实现函数**************************//
    void PrintList(LinkList L);
    bool insert2(LinkList &L,int i,ElemType e)
  {
    LNode* s;LinkList p = L , last;int j=0;
    while(p&&(j<i))//j指到i位置或者p已经到最后时跳出
    {
		 last = p;
		 p = p -> next;
		 ++ j;
    }
    //出来的时候j = i,或者已经走到最后了 
    if(!p && j == i - 1) //走到最后，并且在i - 1位置 
    {
    	s = new LNode;
		s -> data = e;
		s -> next = p -> next;
		p -> next = s; 
		return true;
    }
    if (!p && j != i) 
	{
		printf("插入位置无效！！！\n");
		return false;
	}
    s = new LNode;
    last -> next = s;
    s -> data = e;
    s -> next = p;
}
    
    void sort(LinkList &L)//链表选择排序
    {
    struct Node *p;  //=(struct Node*)malloc(sizeof(struct Node));
    struct Node *q;   //=(struct Node*)malloc(sizeof(struct Node));
    ElemType t;
    for(p=L->next; p!=NULL ; p=p->next)//选定的位置，从第一个位置开始
    {
        for(q=p->next;q!=NULL;q=q->next)//每次遍历一遍链表，只要比选定位置的数据小就交换
        {
            if(q->data<p->data)
            {
                t=q->data;
                q->data=p->data;
                p->data=t;
            }
        }
    }
    PrintList(L);
}
    
    //遍历输出函数
    void PrintList(LinkList L)
    {
        LinkList p=L->next;//跳过头结点
        if(ListLength(L))
        {
            printf("当前单链表所有元素:");
            while(p)
            {
                printf("%d ",p->data);
                p=p->next;
            }
            printf("\n");
        }
        else
        {
            printf("当前单链表已空！\n");
        }
    }
    //插入功能函数 调用ListInsert插入 
    void Insert(LinkList &L)
    {
      int place;ElemType e;bool flag;
      printf("请输入要插入的位置(从1开始)及元素:\n");
      scanf("%d%d",&place,&e);
      flag=ListInsert(L,place,e);
      if(flag)
      {
        printf("插入成功！！！\n");
        PrintList(L);
      }
    }
    void Insert2(LinkList &L)
    {
      int place;ElemType e;bool flag;
      printf("请输入要插入的位置(从1开始)及元素:\n");
      scanf("%d%d",&place,&e);
      flag=insert2(L,place,e);
      if(flag)
      {
        printf("插入成功！！！\n");
        PrintList(L);
      }
    }
    //删除功能函数 调用ListDelete删除
    void Delete(LinkList L)
    {
      int place;bool flag;
      printf("请输入要删除的位置(从1开始):\n");
      scanf("%d",&place);
      flag=ListDelete(L,place);
      if(flag)
      {
        printf("删除成功！！！\n");
        PrintList(L);
      }
      return;
    }
    //查找功能函数 调用LocateElem查找
    void Search(LinkList L)
    {
      ElemType e;LNode *q;
      printf("请输入要查找的值:\n");
      scanf("%d",&e);
      q=LocateElem(L,e);
      if(q)
      {
        printf("找到该元素！\n");
      }
      else
        printf("未找到该元素！\n");
    }
    // 逆序输出节点 
	void Nshow(LinkList L){
    	LinkList p = L->next;
    	int i = ListLength(L);
    	if(i == 0){
    		printf("链表为空~~~\n");
    		return;
		}
		if(i == 1){
			printf("%d  \n",p->data);
			return;
		}
    	int arr[i];
    	i = 0;
    	while(p != NULL){
    		arr[i] = p->data;
    		p = p->next;
    		i = i + 1;
		}
		for(i = i - 1; i >= 0; i--){
			printf("%d  ",arr[i]);
		}
		printf("\n");
    	
	}
	
	// 将头节点变成末节点 
	void change(LinkList L){
		LinkList p = L;
		Node* q = L->next;
		if(q && q->next != NULL){
		    while(p->next != NULL){
		    	p = p->next;
		    }
		    p->next = q;
		    L->next = q->next;
		    q->next = NULL;
	    }
	    return;
	} 
	
	//菜单
    void menu()
    {
       printf("********1.后插    2.删除*********\n");
       printf("********3.查找    4.输出*********\n");
       printf("********5.退出    6.前插*********\n");
       printf("********7.排序          *********\n");
       printf("********8.将头节点变成末节点*****\n");
       printf("********9.逆序输出      *********\n");
    }
    //主函数
    int main()
    {
     LinkList L;int choice;
     InitList(L);
     while(1)
     {
      menu();
      printf("请输入菜单序号：\n");
      scanf("%d",&choice);
      if(choice==5) break;
      switch(choice)
      {
      	
      case 1:Insert(L);break;
      case 2:Delete(L);break;
      case 3:Search(L);break;
      case 4:PrintList(L);break;
      case 6:Insert2(L);break;
      case 7:sort(L);break;
      case 8:change(L);break;
      case 9:Nshow(L);break;
      default:printf("输入错误！！！\n");
      
      }
     }
     return 0;
    }

 

m0_53425020
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
02.C语言单链表的创建、遍历、查找、清空、删除、修改、退出
chongyang_的博客
10-10 2630
//输入输出头函数 #include<iostream> using namespace std; #define OK 1; #define ERROR 0; #define OVERFLOW -2; typedef int Elemtype; /** * 单链表的存储结构 */ typedef struct LNode{ Elemtype data; struct LNode *next; }LNode,*LinkList; /** * 尾插法创建单链表 *
PTA：创建单链表。（程序填空题）
空白的博客
04-03 1420
#include using namespace std; #define OK 1 #define ERROR 0 typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; } LNode, *LinkList; void CreateList(LinkList &L, int n) {...
单链表的查找、插入、删除和打印（展示）
b312738566的博客
11-21 3768
单链表的查找、插入、删除和打印
数据结构第二章（单链表部分）学习笔记
qq_62175345的博客
04-05 4055
线性表---单链表部分 1、知识承接 顺序表可以随时存取表中的任意一个元素，它的存储位置可以用一个简单直观的公式来表示。但效率低插入和删除操作需要移动大量的元素。临时扩大存储空间有困难，存储分配只能预先进行必须占用地址连续的内存空间 . 链式存储线性表时，不需要使用地址连续的存储单元，即不要求逻辑上相邻的元素在物理位置上也相邻，它通过“链”建立起数据元素之间的逻辑关系，因此插入和删除操作不需要移动大量的元素，只需要修改指针，但也会失去顺序表可以随机存取的优点。 单链表 链表： 通过一组任意的
借鉴网上代码，自己总结修改，写出了基于单链表的一元多项式的加法，减法，乘法
weixin_43371898的博客
05-24 131
下面贴代码 #include #include <stdlib.h> #include using namespace std; typedef struct term { int coef;//系数 int expn;//指数 struct term *next; }term ,*LinkList; void InsertList(LinkList &L,LinkList...
单链表操作
03-26
单链表的基本操作，如创建、插入、删除、输出
单链表操作基本运算_单链表的基本操作_
10-03
这个压缩包文件“单链表操作基本运算”包含了关于如何在编程中实现单链表基本操作的详细内容，特别是插入和删除操作。 单链表的插入操作通常分为头插法和尾插法。头插法是在链表的开头添加新节点，这需要更新头节点...
数据结构---单链表的基本操作代码块
qq_62175345的博客
04-06 2181
//定义 typedef struct LNode { ElemType data; //数据域 struct LNode *next; //指针域 }LNode , *LinkList; //初始化 Status InitList(LinkList &L) { L = new LNode; //生成一个新结点 L->next = NULL; //结点指针域置空 return ok; } /.
数据结构--单链表
WX_timi的博客
02-07 546
数据结构–单链表 InitList(LinkList &L) 参数：单链表L 功能：初始化 时间复杂度 O(1) ListLength(LinkList L) 参数：单链表L 功能：获得单链表长度 时间复杂度O(n) ListInsert(LinkList &L,int i,ElemType e) 参数：单链表L,位置i，元素e 功能：位置i后插 时间复杂度O(n)[加入了查找]...
数据结构（03）——单链表
08-20 510
单链表概念 链表的节点均单向指向下一个节点，形成一条单向访问的数据链。 单链表的初始化 typedef struct _LinkNode { int data; //结点的数据域 struct _LinkNode *next; //结点的指针域 }LinkNode, LinkList; //链表节点、链表 bool InitList(LinkList* &L)//...
数据结构—带头结点的单循环链表
热门推荐
小虾米编程
06-19 2万+
1.基本操作 循环链表的特点是最后一个元素的指针域指向头结点。 因此对于循环链表的初始化（设表的头结点是L， 不再是L->next=NULL，而是L->next=L。循环链表为空时，头结点的下一个结点依然是头结点本身。因此但虚幻链表的初始化如下： //初始化 int InitList(LinkList &L) { L=new LNode; L->next=L...
单链表的基本操作
Dlaryy的博客
11-22 700
单链表的基本操作
数据结构算法实现-顺序表实现
jiaye_mi的博客
03-08 3312
C++实现数据结构顺序表代码，仅用于学习。
单链表的基本操作数据结构
weixin_45301057的博客
05-10 265
宏定义 #include<math.h> #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0 #define Status int #define ElemType int 单链表节点定义 typedef struct LNode { ElemType data;//数据域 struct LNode *next;//指针域 }LNode,*LinkList; ...
数据结构-顺序表（数组）循环左移（2010联考真题）
关注网络安全、云原生安全
09-18 7423
王道18页，2010年计算机联考真题 n(n>1)个整数放到一维数组R中，将R中保存的顺序序列循环左移p(0<p<n)个位置， 即R中数据由(X0,X1...Xn-1)变换为(Xp,Xp+1...Xn-1,X0,...Xp-1) 思想:动态创建大小为p的辅助数组S，将R中前p个整数依次暂存在S中，同时将R中后n-p个整数左移，然后将S中的p个数， 依次放到R的后续单元中。 C...
【LinuxC语言】手撕Http之处理POST请求
m0_62599305的博客
07-07 131
在互联网的世界中，HTTP协议无疑是最重要的协议之一。它是Web的基础，支持着我们日常生活中的大部分在线活动。尽管有许多现成的库可以处理HTTP请求，但了解其底层工作原理是非常有价值的。本文将介绍如何在Linux C语言环境中处理HTTP POST请求。POST是HTTP协议中的一种请求方法，用于提交数据到服务器进行处理。与GET请求不同，POST请求将数据包含在请求体中，而不是URL中。这使得POST请求可以发送大量的数据，并且这些数据可以是任何类型，包括文本、二进制数据，甚至是文件。
C/C++ 代码注释规范及 doxygen 工具
最新发布
jucat的博客
07-07 717
C++ 注释规范及 doxygen 配置和文档生成
用c语言实现单链表操作
03-21
可以使用以下代码实现单链表操作： ```c #include #include typedef struct node { int data; struct node *next; } Node; Node *createNode(int data) { Node *newNode = (Node *)malloc(sizeof(Node)); ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值