精华内容
下载资源
问答
  • C语言链表节点插入与删除

    千次阅读 2018-09-17 20:43:31
    void init(lk *l) //定义一个链表节点 { (*l) = (lk)malloc(sizeof(node)); (*l)->next = NULL; } void creat(lk l,int n) //创建一个链表 { int a; lk tmp, p; tmp = l; int i; for(i = 0;i ;i++) { p =...

    线性表操作

    顺序表是我们数据结构中的基本储存形式,现在给定一个顺序表,有如下操作:
    Insert X Y:在顺序表中X位置插入Y元素,遍历输出当前顺序表的所有元素。
    Delete X:删除顺序表中的X元素,如果有多个X元素,只删除第一个X,遍历输出当前顺序的所有元素。
    Locate X:输出顺序表中X元素的所在的位置,如果有多个X元素,只输出第一个X元素的位置。
    GetElem X:输出顺序表中X位置上的元素。

    代码如下:

    #include<string.h>
        #include<stdio.h>
        #include<stdlib.h>
        typedef struct node                         //定义一个结构体
        {
            int data;
            struct node *next;
        }node, *lk;
    
    void init(lk *l)                                 //定义一个链表头节点
    {
        (*l) = (lk)malloc(sizeof(node));
        (*l)->next = NULL;
    }
    void creat(lk l,int n)                          //创建一个链表
    {
        int a;
        lk tmp, p;
        tmp = l;
        int i;
        for(i = 0;i < n;i++)
        {
            p = (lk)malloc(sizeof(node));
            scanf("%d", &a);
            p->data = a;
            p->next = NULL;
            tmp->next = p;
            tmp = p;
        }
    }
    void insert(lk l,int n, int m)            //Insert X Y:在顺序表中X位置插入Y元素,遍历输出当前顺序表的所有元素。
    {
        lk p, q;
        p = l;
        int i;
        for(i = 0;i < n-1;i++)
        {
        	p = p->next;
    	}
    	q = (lk)malloc(sizeof(node));
    	q->data = m;
    	q->next = p->next;
    	p->next = q;
    }
    void show(lk l)    //打印链表
    {
    	int flag = 1;
    lk p;
    p = l;
    p = p->next;
        while(p)
        {
        	if(flag)
        	{
        		printf("%d", p->data);
            	flag = 0;
    		}
    		else{
    			printf(" %d", p->data);
    		}
            p = p->next;
        }
        printf("\n");
    }
    int GetElem(lk l, int n)     //GetElem X:输出顺序表中X位置上的元素。
    {
    	int i;
    	for(i = 0;i < n;i++)
    	{
    		l = l->next;
    	}
    	return l->data;
    }
    int Delete (lk l, int n)               //Delete X:删除顺序表中的X元素,如果有多个X元素,只删除第一个X,遍历输出当前顺序的所有元素。
    {
    	lk p ,q,s;
    	p = l;
    	q = l->next;
    	int i = 0;
    	while(q)
    	{
    		if(q->data==n)
    		{
    			p->next = q->next;
    			//s = q;
    			q= q->next;
    			i = 1;
    			break;
    		}
    		else
    		{
    			p = p->next;
    			q = q->next;
    		}
    	}
    	return i;
    }
    int Locate(lk l,int n)   Locate X:输出顺序表中X元素的所在的位置,如果有多个X元素,只输出第一个X元素的位置。
    {
    	int q = 0;
    	while(1)
    	{
    		l = l->next;
    		q++;
    		if(l->data == n)
    		{
    			break;
    		}
    	}
    	return q;
    }
    int main()
    {
    	int m , n;
    	scanf("%d %d", &m, &n);
    	lk l;
    	init(&l);
    	creat(l, m);
    	int k;
    	char a[10];
    	int x,y,rt;
    	for(k = 0;k < n;k++)
    	{
    		scanf("%s", &a);
    		if(a[0] == 'I')
    		{
    			scanf("%d %d", &x, &y);
    			if(x > m)
    			{
    				printf("Wrong Input!\n");
    			}
    			else
    			{
    				insert(l,x,y);
    				show(l);
    			}
    		}
    		else if(a[0] == 'D')
    		{
    			scanf("%d", &x);
    			if(Delete(l,x) == 0)
    			{
    				printf("Wrong Input!\n");
    			}
    			else
    			{
    				Delete(l,x);
    				show(l);
    			}
    		}
    		else if(a[0] == 'L')
    		{
    			scanf("%d", &x);
    			if(x > m)
    			{
    				printf("Wrong Input!\n");
    			}
    			else
    			{
    				rt = Locate(l,x);
    				printf("%d\n", rt);
    			}
    		}
    		else if(a[0] == 'G')
    		{
    			scanf("%d", &x);
    			if(x > m)
    			{
    				printf("Wrong Input!\n");
    			}
    			else
    			{
    				rt = GetElem(l,x);
    				printf("%d\n", rt);
    			}
    		}
    		else
    		{
    			printf("%d\n", rt);
    		}		
    	}	
    	return 0;
    }
    

    结果展示

    在这里插入图片描述

    展开全文
  • 2.实现原理:头指针指向链表的第一个节点,然后第一个节点中的指针指向下一个节点,然后依次指到最后一个节点,这样就构成了一条链表。 3.链表的数据结构 typedef struct node { void*data;//数据域 struct node* ...
    1.链表的简单结构:

    头指针(head),若干个节点(节点包括了数据域和指针域),最后一个节点要指向空。

    2.实现原理:头指针指向链表的第一个节点,然后第一个节点中的指针指向下一个节点,然后依次指到最后一个节点,这样就构成了一条链表。

    3.链表的数据结构

    typedef struct node
    {
    	void*data;//数据域
    	struct node* pNext;//指针
    }NODE_T;
    

    4.链表的相关函数

    extern NODE_T* pHead;
    NODE_T* List_init(void* pData)//初始化链表
    {
      NODE_T* pHead = (NODE_T*)malloc(sizeof(NODE_T));//分配内存空间
      memset(pHead,0,sizeof(NODE_T));//清空
      //当头指针为空
      if(NULL==pHead)
      {
      printf("error\n");
      }
      else
      {
      pHead->data = pData;//指向数据域
      pHead->pNext = NULL;//下一个阶段指向为空
      }
      return pHead;
    }
    NODE_T* List_add(void* data,NODE_T* head)//增加链表节点
    {
      NODE_T* pTmp;
      NOED_T* newNode =  (NODE_T*)malloc(sizeof(NODE_T));
       memset(newNode,0,sizeof(NODE_T));//清空
       newNode ->data = data;//添加赋值
       if(head==NULL)//头节点为空
       {
       head = newNode;
       }
       else if(head->pNext == NULL)//当下一个节点为空时
       {
       head->pNext = newNode;
       }
       else
       {
       pTmp = head;
       while(NULL!= pTmp->pNext)
       {
       pTmp = pTmp->pNext;
       }
       pTmp->pNext = newNode;
       }
       return head;
    }
    int List_GetCount(NODE_T* head)//计算链表节点
    {
      NODE_T* pTmp = head;//头指针
      int count = 0;//节点数初始化
      while(NULL! = pTmp)//当指针不为空
      {
      pTmp = pTmp->pNext;
      count++;
      }
      return count;
    }
    NODE_T* List_GetNode(int index,NODE_T* head)//找到指定位置的节点
    {
      NODE_T* pTmp = head;
      int num = List_GetCount(pTmp);//链表节点数
      int pos = 1;
      if(index>num)//当找到节点位置大于节点数,不存在节点
      {
      printf("get error\n");
      return NULL;
      }
      while(NULL!=pTmp)
      {
      if(index == 1)//当要查找的节点为头节点的时候
      {
      break;//跳出循环
      }
      pTmp = pTmp->pNext;
     pos++;
     if(pos == index)//当要查找的节点匹配时
     {
     break;
     } 
      }
      return pTmp;
    }
    int List_DelNode(int index)//删除结点
    {
     NODE_T* pTmp1 = pHead;//临时移动的节点
     NODE_T* pTmp2 = pHead;//保存移动之前的节点
     int pos = 1;
     while(pos<index && NULL! = pTmp1->pNext)
     {
     pTmp2 = pTmp1;
     pTmp1 = pTmp1->pNext;
     pos++;
     }
     pTmp2->pNext = pTmp1 ->pNext;
     free(pTmp1->data);
     free(pTmp1);
     return 1;
    }
    NOED_T* Last_Node(NODE_T* pTmp)//找到尾节点
    {
     while(pTmp->pNext)
     {
     pTmp = pTmp->pNext;
     }
     return pTmp;
    }
    
    展开全文
  • C语言 链表的创建,以及节点增加和删除

    万次阅读 多人点赞 2017-06-20 20:26:22
    今天下午倒腾了一下c语言链表,感觉链表就是一个小型的数据库,用于简单的小程序的用户信息存储和管理还是很方便的。 下面为方便起见,以学生信息为例: 链表采用了动态分配的办法为一个结构分配内存空间。每...

    第一次写博客,如有错误还请指正…………
    今天下午倒腾了一下c语言的链表,感觉链表就是一个小型的数据库,用于简单的小程序的用户信息存储和管理还是很方便的。
    下面为方便起见,以学生信息为例:
    链表采用了动态分配的办法为一个结构分配内存空间。每一次分配一块空间可用来存放一个学生的数据,我们可称之为一个结点。有多少个学生就应该申请分配多少块内存空间,也就是说要建立多少个结点。当然用结构数组也可以完成上述工作,但如果预先不能准确把握学生人数,也就无法确定数组大小。而且当学生留级、退学之后也不能把该元素占用的空间从数组中释放出来。用动态存储的方法可以很好地解决这些问题。有一个学生就分配一个结点,无须预先确定学生的准确人数,某学生退学,可删去该结点,并释放该结点占用的存储空间。从而节约了宝贵的内存资源。另一方面,用数组的方法必须占用一块连续的内存区域。而使用动态分配时,每个结点之间可以是不连续的(结点内是连续的)。结点之间的联系可以用指针实现。 即在结点结构中定义一个成员项用来存放下一结点的首地址,这个用于存放地址的成员,常把它称为指针域。
    可在第一个结点的指针域内存入第二个结点的首地址,在第二个结点的指针域内又存放第三个结点的首地址,如此串连下去直到最后一个结点。最后一个结点因无后续结点连接,其指针域可赋为0。这样一种连接方式,在数据结构中称为“链表”。
    下面给出一个简单的例子,包含链表的创建,

    #include<stdio.h>
    #include<stdlib.h>
    
    
    #define LEN sizeof (struct stu)
    /*
    head为(伪)头指针,pbefore为指向两相邻结点的前一结点的指针变量。pafter为后一结点的指针变量。
    */
    
    //定义学生个数
    int n=4;
    //定义链表结构体
    typedef struct stu{
        int num;
        int age;
        struct stu *next;
    }TYPE;
    
    /*定义删除函数:删除所选中的节点*/
    void delete(TYPE *head,int number)
    {
        int i;
        TYPE *list=head;
        TYPE *tp=NULL;
        //这里循环n+1次,是因为包含头节点在内总共有n+1个节点
        for(i=0;i<(n+1);i++){
            printf("the next:%ld\n",(long)list->next);
    
            if(list->num==number){
                if(list->next==0){
                    tp->next=0;
                    break;
                }else{
                    tp->next=list->next;
                    break;
                }
            }
            tp=list;// 临时指针指向的是前一节点
            list=list->next; //继续判断下一节点
        }
    
    }
    /*定义查询函数:显示链表中所有信息*/
    void query(TYPE *head)
    {
        TYPE *list=head;
        while(list)
        {
            printf("%d,%d\n",list->num,list->age);
            printf("the next:%ld\n",(long)list->next);
            list=list->next;
        }
    
    }
    
    
    
    int main()
    {
        //这是定义的真正的头节点
        struct stu *head;
        head->num=0;
        head->age=0;
    
        struct stu *thead,*pbefore,*pafter;
        int i;
        for(i=0;i<n;i++){  
            pafter=(TYPE*) malloc(LEN); //定义的pafter也相当于一个临时节点
            printf("input Number and  Age\n");
            scanf("%d%d",&pafter->num,&pafter->age);
            if(i==0) pbefore=thead=pafter; //第一次循环,直接设置头节点
            else pbefore->next=pafter;
            //这里的pbefore其实是上一轮循环的after赋予的,所以是 “前一个节点”
            //注意:这里改动的不是pbefore,而是pbefore指向的内存里的数据
            pafter->next=NULL; // 将最后的指针域清零,赋给pbefore,即前节点
            pbefore=pafter;// 这里pbefore指向了新的内存,也就是下一个节点
                           // 强调一下,pbefore只是一个指针
        }
        head->next=thead;
    
        query(head);
    
        int number;
        printf("you want to delete:");
        scanf("%d",&number);
    
        delete(head,number);
        query(head);
    
    
        return 0;
    }

    以上程序包含了一个节点数为n+1的链表(n个学生节点和1个头节点,因为头节点没有数据域)。如果没有提前定义头节点,则第一个学生的节点则为头节点,这样就导致这个头节点无法删除。这里写图片描述
    上图可以看出,如果直接删除了头节点,会发生段错误。

    现在我们在链表的尾部增加一个节点

    #include<stdio.h>
    #include<stdlib.h>
    
    
    #define LEN sizeof (struct stu)
    
    
    
    typedef struct stu{
        int num;
        int age;
        struct stu *next;
    }TYPE;
    
    
    int n=4;
    
    /*增加节点函数:返回新的尾部节点地址*/
    TYPE *add(TYPE* tail)
    {
        TYPE *new;
         new=(TYPE*) malloc(LEN); 
    
        printf("input the new num and age\n");
        scanf("%d%d",&new->num,&new->age);
    
        tail->next=new;
        printf("tail:%ld",(long)tail);
        new->next=NULL;//缺了这一句,新的节点数据就显示不出了
        tail=new;
        printf("new tail:%ld",(long)tail);
    
        return tail;
    
    
    }
    
    /*删除节点函数*/
    void delete(TYPE *head,TYPE* tail,int number)
    {
        int i;
        TYPE *list=head;
        TYPE *tp=NULL;
        for(i=0;i<(n+1);i++){
        //  printf("the next:%ld\n",(long)list->next);
            if(list->num==number){
                if(list->next==0){
                    tp->next=0;
                    tail=tp;//若尾部节点被删除,则更新尾部节点
                    break;
                }else{
                    tp->next=list->next;
                    break;
                }
            }
            tp=list;// 临时指针指向的是前一节点
            list=list->next; //继续判断下一节点
        }
    
    }
    
    /*查询函数:显示所有节点数据*/
    void query(TYPE *head)
    {
        TYPE *list=head;
        while(list)
        {
            printf("%d,%d\n",list->num,list->age);
            //printf("the next:%ld\n",(long)list->next);
            list=list->next;
        }
    
    }
    
    
    
    int main()
    {
        //初始化头节点以及尾部节点
        struct stu *head; 
        struct stu *tail; 
    
        head->num=0;
        head->age=0;
    
        struct stu *thead,*pbefore,*pafter;
        int i;
        for(i=0;i<n;i++){  
            pafter=(TYPE*) malloc(LEN); 
            printf("input Number and  Age\n");
            scanf("%d%d",&pafter->num,&pafter->age);
            if(i==0) pbefore=thead=pafter; 
            else pbefore->next=pafter; 
            pafter->next=NULL; 
            pbefore=pafter;
        }
    
        tail=pafter;
        printf(" tail:%ld",(long)tail);
    
        head->next=thead;
    
        query(head);
    
        int number;
        printf("you want to delete:");
        scanf("%d",&number);
    
        delete(head,tail,number);
        query(head);
    
        tail=add(tail);
        query(head);
    
        tail=add(tail);
        query(head);
    
    
        return 0;
    }

    这里我们需要定义尾部节点,并且增加后要对尾部节点进行更新,方便再次在链表后面插入节点,注意:不要忘了给新的节点分配内存,否则会报段错误,因为你给并没有分配内存的结构体赋值了。
    new=(TYPE*) malloc(LEN);
    另外不要忘了给新的尾部节点的指针域设置为NULL。
    new->next=NULL;
    以上是增加了两个节点的例子,运行结果如下
    这里写图片描述
    可以看到,增加的节点已经显示出来了。

    展开全文
  • C语言链表交换指针交换链表的节点C语言链表交换指针交换链表的节点完整源码(定义,实现,main函数测试) C语言链表交换指针交换链表的节点完整源码(定义,实现,main函数测试) #include <iostream> struct ...

    C语言链表交换指针交换链表的节点完整源码(定义,实现,main函数测试)

    #include <iostream>
    
    
    struct Node {
       
      int data;
      Node* next;
      Node(int d) : data{
       d
    展开全文
  • (1)在中间插入结点 将5结点插入2 、3 结点中间 操作顺序:先连后改指向 先让5结点指向结点3 s -...(2) 增加头结点 将S结点增加到头部 先连: s -> next = head; 后连接: head = s ; (3) 插...
  • C语言编写的链表中插入节点的程序,供学习参考交流用
  • struct link *lianbiao(struct link *head,int n,char id[10],char password[10])/*登录链表*/ { //括号内传入想要传入的参数 struct link *p=NULL,*pr=head; 设置一个空节点和一个头节点 p=(struct link *)malloc...
  • 大学期间用C语言链表实现的一个图书管理系统,主要功能有 a. 设备申请。由专业人员填写“申请表”送交领导批准购买。 b. 设备入库。新设备购入后要立即进行设备登记(包括类别、设备名、型号、规格、单价、数量、...
  • 链表的尾部动态添加节点,添加信息包括图书编号和价格。 //下面是动态添加节点的完整c代码(直接复制粘贴到main.c中就可以运行) #include<stdio.h> #include<stdlib.h> typedef struct book { int num...
  • C语言链表节点排序

    千次阅读 2019-05-07 19:54:45
    初次用到链表的排序还是在C语言课程设计上,当时想着要把代码发到CSDN上,结果一拖再拖到现在。 我的课程设计项目为“学生成绩管理系统”,所用链表为双向链表链表。 涉及到成绩管理则避免不了成绩的排序。 结构体中...
  • C语言实现删除链表所有节点空间 节点结构 struct node ...//释放链表节点空间 void delete_chain(node *head) { node *p1; while (head) { p1 = head; head = head->next; free(p1); } }
  • c语言链表详解(超详细)

    万次阅读 多人点赞 2018-06-03 16:16:01
    链表可以动态的进行存储分配,也就是说,链表是一个功能极为强大的数组,他可以在节点中定义多种数据类型,还可以根据需要随意增添,删除,插入节点链表都有一个头指针,一般以head来表示,存放的是一个地址。链表...
  • C语言链表操作详解

    万次阅读 多人点赞 2018-12-29 19:01:55
    为什么要使用链表 在未学习链表时,我们常用的存储数据的方式无非就是数组。使用数组存储数据的好处就是查询快,但是它的弊端也很明显: 使用前需声明数组的长度,一旦声明长度就不...n个节点离散分配 每一个节...
  • 例:在2之前插入15 #include<stdio.h> #include<...//节点结构体 struct Node { int a; struct Node* pNext; }; //链表头尾指针 struct Node* g_pHead = NULL; struct Node* g_pEn...
  • C语言—头节点链表与无头节点链表

    千次阅读 2018-04-21 18:43:46
    头指针链表与头节点链表 二者差异 头指针是指指向开始结点的指针(没有头结点的情况下)。一个单链表可以由其头指针唯一确定,一般用其头指针来命名单链表 头结点是在链表的开始结点之前附加的一个结点。可以...
  • C语言链表的头指针、头节点

    千次阅读 多人点赞 2019-02-17 16:09:48
    头指针:指向链表的第一个节点(或者说是链表中第一个结点的存储位置叫做头指针),如果链表有头结点,则是指向头结点的指针 。 在访问链表时,只能顺序访问,我们要先找到链表的头指针,因为它是指向第一个节点的...
  • C语言链表--链表结点删除(4)

    千次阅读 2020-05-06 21:35:14
    1、 例子:删除中间结点3 要找到删除结点的前一个结点 struct node { int data; struct node *next; }; struct node *p,*q; q = (struct node *)malloc(sizeof(struct node)); q = head ->...q -&...
  • VC6.0下 用C语言实现单向链表的创建、插入,删除节点,和2个链表合并等操作
  • C语言实现删除链表的一个节点 节点表示 struct node { int data; node *next; }; ...node *delete_node(node *... printf("链表节点为空!\n"); return 0; } if (head->data == data) {//链表非空,删除表头。
  • 请编写一个函数,使其可以删除某个链表中给定的(非末尾)节点。传入函数的唯一参数为 要被删除的节点 。 现有一个链表 – head = [4,5,1,9],它可以表示为: 示例 1: 输入:head = [4,5,1,9], node = 5 输出:[4,1...
  • C语言链表详解附实例

    万次阅读 多人点赞 2020-03-11 23:43:02
    链表是一种常见的重要的数据结构。它是动态地进行存储分配的一种结构。链表和数组比较,不用事先确定存储空间,而是根据需要开辟内存单元。本文章实现了用C语言编写学生管理系统,可以实现添加、删除、增加..,等功能
  • C语言链表返回第n个到最后的节点的算法C语言链表返回第n个到最后的节点的算法完整源码(定义,实现,main函数测试) C语言链表返回第n个到最后的节点的算法完整源码(定义,实现,main函数测试) #include<iostream...
  • C语言实现链表节点的插入和删除

    千次阅读 2016-06-07 11:09:41
    今天我实现的是插入链表节点和删除链表节点。 看代码吧,注释写的不好的就见谅吧·················    /*  链表节点的插入与删除  编译环境:VC++ 6.0  编
  • C语言数据结构实现链表逆序并输出 将一个链表逆序并输出。我用了两种方法来实现,第一种是借助了一个新的空链表;第二种是在原来链表的基础上直接实现逆序。 实例代码:  头文件:  #include #include #...
  • C语言实现链表之单向链表(二)结点内存申请及数据初始化  在上一篇文章中已经给出了整体的设计框架,现在讲逐一给出每一个函数的实现,为了一一讲解,清晰一点,将分开介绍。  本篇文章将给出MyList_Single.c...
  • 单向链表之删除节点C语言实现)

    万次阅读 多人点赞 2018-03-19 17:16:54
    删除的第一步是找到要删除的节点,同链表查找,如果找不到或链表为空,提示未找到,找到后根据情况删除此节点。删除节点两种情况:第一个节点,后面节点。 步骤: 1、链表为空:不用删除 2、链表不为空:先循环找...
  • C语言通过链表指针删除链表节点的算法C语言通过链表指针删除链表节点的算法完整源码(定义,实现,main函数测试) C语言通过链表指针删除链表节点的算法完整源码(定义,实现,main函数测试) #include <iostream&...
  • C语言链表的删除操作

    千次阅读 2020-05-11 11:02:29
    C语言链表的删除节点操作,超简单; 懂了之后修改和查找更不在话下
  • C语言 链表数据的排序

    千次阅读 多人点赞 2021-02-25 22:04:49
    C语言使用链表时,有些时候会对链表中的数据进行排序。下边介绍使用链表时可用的排序方法,冒泡排序和选择排序。 此链表排序仅对链表中的数据进行排序,如果想进行对整个结构体的排序,也就是利用数据顺序来调整节点...
  • 关于这个问题,基本思路是先将要被删除节点的上一个节点和下一个节点连接起来,然后再把要删除的节点释放掉就行了。 首先先定义一个链表: struct STU { int a; int b; int c; struct STU *next; } struct STU ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 40,966
精华内容 16,386
关键字:

c语言链表增加节点

c语言 订阅