精华内容
下载资源
问答
  • C语言链表基本操作

    2012-11-03 08:16:47
    C语言链表基本操作
  • c语言链表基本操作

    2021-03-10 14:11:58
    1、链表定义 typedef struct listnode{ int n; //数据域 struct listnode*next;//指针域 }listnode; 2、链表初始化 listnode *creatlist() { listnode*head = (listnode*)malloc(sizeof(listnode)); head->...

    1、链表定义

    typedef struct listnode{
       int n;   //数据域
       struct listnode*next;//指针域
    }listnode;
    

    2、链表初始化

    listnode *creatlist()
    {
       listnode*head = (listnode*)malloc(sizeof(listnode));
       head->next=null;
       return head;
    }
    

    注:头结点只有指针域没有数据域
    3、创建新节点

    listnode *creatlistnode()
    {
       printf(please input data:\n);
       scanf("d%",&data);
       listnode*node = (listnode*)malloc(sizeof(listnode));
       node->next=null;
       node->n=data;
       return node;
    }
    

    4、头插法

    void insertlisthead(listnode*head)
    {
       int i,n;
       printf(please input size:\n);
       scanf("d%",&n);
       for( i =0;i<n;i++)
       {
       //插入前首先创建新节点
       listnode*newnode = creatlistnode();
       newnode->next =head->next;
       head->next = newnode;
       }
    }
    

    5、尾插法

    void  insertlisttail(listnode*head)
    {
       int i,n;
       listnode*tail = (listnode*)malloc(sizeof(listnode));
       head = tail;
       printf(please input size:\n);
       scanf("d%",&n);
       for( i =0;i<n;i++)
       {
        listnode*newnode = creatlistnode();
        newnode->next = tail->next;
        tail->next = newnode;
        tail = newnode;
       }
    }
    

    6、打印输出链表

    void printlist(listnode*head)
    {
      listnode *p = head->next;
      while(p)
      {
      print("d%",p->n);
      p=p->next;
      }
      print ("\n")
    }
    

    7、指定位置删除节点

    void delatenodelocate(listnode*head)
    {
     int posdata;
     print("please input posdata:\n");
     scanf("d%",&posdata);
     listnode *p = head;
     listnode*posnode=head->next;
     while(posnode->n!=posdata)
     {
        p= p->next;
        posnode = posnode->next;
        if(posnode==NULL)
        {
           print("fail to delete");
           return;
        }
     }
     p->next= posnode->next;//找到要删除的节点 对其进行删除;
     free (posnode);
     
    }
    

    8、指定位置插入节点

    void insertnodelocate(listnode*head)
    {
     int pos;
     print("please input pos:\n");
     scanf("d%",&pos);
     listnode *p = head;
     listnode*posnode=head->next;
    
    for(int i =0;i<pos-1;i++)
    {
     p=p->next;
     posnode=posnode->next;
    }
     listnode*newnode = creatlistnode();  
      p->next = newnode;
      newnode->next =posnode;
    }
    

    9、判断是否为空

    bool EmptyList(listnode* Head)
    {
    	if(Head->next)
    	{
    		printf("not Empty!\n");
    		return 0;
    	}
    	else
    	{
    		printf("Empty!\n");
    		return 1;
    	}
    }
    

    10、清空链表

    void cleanlist(listnode*head)
    {
      listnode*p,*q;
      p=head->next;
      while(p)
      {
       q=p->next;
       free(p);
       p=q;
      }
      head->next=null;
     
    }
    

    11、求链表长度

    int Length(ListNode* Head)
    {
    	ListNode* p=Head;
    	int count=0;
    	while(p->next!=NULL)
    	{
    		count++;
    		p=p->next;
    	}
    	printf("Length:%d\n",count);
    	return count;
    }
    
    展开全文
  • 主要介绍了c语言链表基本操作,大家参考使用吧
  • 链表的建立、插入、查找、倒置、删除等操作//链表操作:建立、插入、删除、查找、倒置、删除等基本操作//喜洋洋制作#include#includetypedefstructLNode{intdata; structLNode *next;}LNode,*Llist;LNode *creat_head...

    链表的建立、插入、查找、倒置、删除等操作

    //链表操作:建立、插入、删除、查找、倒置、删除等基本操作

    //喜洋洋制作

    #include

    #include

    typedefstructLNode

    {

    intdata; structLNode *next;

    }LNode,*Llist;

    LNode *creat_head();//创建一个空表

    void creat_list(LNode *,int);//创建一个长度为n的线性链表 voidinsert_list(LNode *,int,int);//插入一个元素

    intdelete_list(LNode *,int);//删除一个元素

    intfound_list(LNode *,int);//链表查询

    void reverse(LNode *);//倒置整个链表

    voiddelete_whole(LNode *);//删除整个链表

    voidprint_list(LNode *);//打印链表

    main()

    {

    LNode *head; int n,n2;

    展开全文
  • C语言 链表基本操作源码 大学C语言课程基本设计。
  • c语言链表及其基本操作

    千次阅读 多人点赞 2020-11-11 00:58:26
    链表及其基本操作 文章目录 链表及其基本操作 一、链表是什么? 二、链表是如何实现的 1.创建链表 2.输出链表 三、基本操作(增删改查插) 1.查找结点 2.删除结点 3.插入结点 4.清空结点 做为一名 新生蒟蒻来写第一...

    链表及其基本操作


    做为一名 新生蒟蒻来写第一篇博客>
    最近在发愁如何做出一个有意思的项目来挑战自己,
    但是因为能力有限被文件和链表的基本操作搞晕了,
    所以来学巨佬的博客来写一写最近所学的链表操作和我对链表的理解

    欢迎指教


    一、链表是什么?

    链表在最开始学习的时候就听说很难,但是去认真学习后却发现链表非常的好玩 ,是对于结构体和指针的一种实际应用(个人理解)。
    那让我们先来说说什么叫链表:

    链表是一种常见的数据结构。它与常见的数组是不同的,
    使用数组时先要指定数组包含元素的个数,即为数组的长度,
    但是如果向这个数组中加入的元素超过了数组的大小时,便不能将内容全部保存。
    链表这种存储方式,其元素个数是不受限定的,当进行添加元素的时候存储的个数就会随之改变。
    且对于元素的操作十分方便。
    

    已经有大佬解释的对于链表的好处解释的十分清楚了。
    在这里插入图片描述

    二、链表是如何实现的

    1.创建链表

    最重要的是定义一个结构体,其中存放你要存储的数据和你下个位置的地址。

    struct nod
    {
    	int date;
    	struct nod* next;
    }

    因为链表是分散的,在茫茫人海中要去找到它难如登天,所以要有“*next”指针来找到下一个nod的位置。
    如图
    在这里插入图片描述
    我们看到其中有有2个特殊的位置,首和尾(滑稽),这也是我们创捷链表和查找链表的重要位置,可以知道从何开始,到哪结束。(从哪来呀,到哪去)。

    struct nod* creat(int n)
    {
    	struct nod * head = (struct nod *)malloc(sizeof(struct nod));
    	struct nod * end=head;
    	
    	for(int i=0;i<n;++i)
    	{
    		struct nod * temp = (struct nod *)malloc(sizeof(struct nod));
    		scanf("%d",&temp->date);
    		end->next = temp;
    		end = temp;
    	}
    	end->next = NULL;
    	
    	return head;
    }
    

    2.输出链表

    然后就是简简单单的输出了:

    void printlist(struct nod * head)
    {
    	if(head == NULL)
    		return ;
    	
    	struct nod * p = head;
    		
    	while(p->next!=NULL)
    	{		
    			p = p->next;//因为尾结点的next为空,为了可输出其值,这样巧妙使其可被输出。
    			printf("%d",p->date);
    	
    	}	
    	
    	return ;
    }
    
    

    三、基本操作(增删改查插)

    1.查找结点

    返回你需要查找的位置

    struct nod * Findnod(struct nod * head,int a)
    {
    	if(head == NULL)
    		return NULL;
    		
    	struct nod * temp = head;	
    		
    	while(temp->next != NULL)
    	{
    		temp = temp->next;
    		if(temp->date == a)
    			return temp;
    	} 
    	
    	return NULL;//没找到 
    	
    }
    

    2.删除结点

    找到你要删除结点的前一个结点,然后是前结点的next等于该节点的next即可。


    3.插入结点

    与指定位置增加结点,并赋值。

    void addnod(struct nod * head,int a)
    {
    	if(head == NULL)
    		return ;
    		
    	struct  nod * temp  = Findnod(head,a);
    	
    	struct  nod * newnod = (struct  nod *)malloc(sizeof(struct  nod ));
    	
    	scanf("%d",&newnod->date);
    	
    	newnod->next = temp->next;
    	temp->next = newnod;
    	
    	return ;
    } 
    

    4.清空结点


    void FreeList()
    {
    	//一个一个NULL
    	struct Node *temp =head;		//定义一个临时变量来指向头
    	while (temp !=NULL)
    	{
    	//	printf("%d\n",temp->a);
    		struct Node* pt =temp;
    		temp = temp->next;		//temp指向下一个的地址 即实现++操作
    		free(pt);					//释放当前
    	}
    	//头尾清空	不然下次的头就接着0x10
    	head =NULL;
    	end =NULL;
    }
    
    展开全文
  • c语言链表基本操作2 #include #include typedef int Datatype; //如果存其他类型的数据可以在此处直接修改 typedef struct node { Datatype data; struct node *next; }Node; //创建结点 Node* creatNode...

    c语言链表的基本操作2

    #include <stdio.h>
    #include <stdlib.h>
    
    typedef int Datatype;   //如果存其他类型的数据可以在此处直接修改
    
    typedef struct node {
        Datatype data;
        struct node *next;
    }Node;
    
    //创建结点
    Node* creatNode(Datatype data) {
        Node* p = NULL;
        p = (Node*)malloc(sizeof(Datatype));    //申请内存
        if (p == NULL) {    //安全检查
            return NULL;
        }
        p->data = data;     //赋值
        p->next = NULL;
        return p;
    }
    //打印链表
    void printList(Node* head) {
        Node* p = head;
        if (head == NULL) {
            return;
        }
        while(p != NULL) {
            printf("%d\n",p->data);
            p = p->next;
        }
        return;
    }
    //在一个结点后插入新结点
    int insertNodeBehind(Node* p,Node* pnew) {
        if (p == NULL || pnew == NULL) {
            return -1;
        }
        if (p->next != NULL) {
            pnew->next = p->next;
            p->next = pnew;
        }
        else {
            p->next = pnew;
        }
    /*其实此处直接写
        pnew->next = p->next;
        p->next = pnew;
     就可以了,因为若p->next = NULL则pnew->next = NULL*/
        return 0;
    }
    //结点后插入一个数据
    int insertDataBehind(Node *p,Datatype data) {
        Node* pnew = NULL;
        if (p == NULL) {
            return -1;
        }
        pnew = creatNode(data);
        insertNodeBehind(p,pnew);
        return 0;
    }
    //返回最后末尾结点的地址
    Node* findListTail(Node* phead) {
        if (phead == NULL) {
            return NULL;
        }
        while (phead->next != NULL) {
            phead = phead->next;
        }
        return phead;
    }
    //插入数据到链表的末尾,**是因为可能会涉及修改头指针,在没有结点的情况下
    int listInsertDataAtTail(Node** phead,Datatype data) {
        Node *p = NULL;
        if (phead == NULL) {
            return -1;
        }
        if (*phead == NULL) {
            *phead = creatNode(data);
            return 0;
        }
        p = findListTail(*phead);
        insertDataBehind(p,data);
        return 0;
    }
    //删除后一个结点
    int deleteNodeBehind(Node* p) {
        Node* temp  = NULL;
        if (p == NULL) {
            return -1;
        }
        if (p->next == NULL) {
            return 1;
        }
        temp = p->next;
        p->next = p->next->next;
        free(temp);
        return 0;
    }
    //返回数据为data的结点的地址
    Node* findNode(Node* head,Datatype data) {
        Node* p = NULL;
        if (head == NULL) {
            return NULL;
        }
        p = head;
        while (p->data != data) {
            if (p->next != NULL) {
                p = p->next;
            }
            else {
                return NULL;    //没找到该数据为data的结点
            }
        }
        return p;
    }
    //改数据
    int listChangeData(Node* head,Datatype oldData,Datatype newData) {
        Node* p = NULL;
        if (head == NULL) {
            return -1;
        }
        p = findNode(head, oldData);
        p->data = newData;
        return 0;
    }
    //返回数据为data的结点的前一个结点的地址
    Node* findPrevNode(Node *head,Datatype data) {
        Node* p = NULL;
        if (head == NULL) {
            return NULL;
        }
        p = head;
        while (p->next != NULL) {
            if (p->next->data == data) {
                return p;
            }
            else {
                p = p->next;
            }
        }
        return NULL;
    }
    //删除链表中第一个数据为data的结点
    int listDeleteData(Node** phead,Datatype data) {
        Node* p = NULL;
        Node* temp = NULL;
        if (phead == NULL || *phead == NULL) {
            return -1;
        }
        if ((*phead)->data == data) {
            temp = (*phead);
            (*phead) = (*phead)->next;
            free(temp);
            return 0;
        }
        p = findPrevNode(*phead, data);
        deleteNodeBehind(p);
        free(temp);
        return 0;
    }
    //销毁链表
    int listDestroy(Node **phead) {
        if (phead == NULL || (*phead) == NULL) {
            return 0;
        }
        while ((*phead)->next != NULL) {
            deleteNodeBehind(*phead);
        }
        (*phead) = NULL;
        free(*phead);   //不知道此处有没有错误!
        return 0;
    }
    int main(int argc, const char * argv[]) {
    //  创建结点,查尾,增加结点
        Node* p = NULL;
        listInsertDataAtTail(&p, 1); //调用了creatNode,findListTail,insertNodeBehind
        printList(p);
    
        listInsertDataAtTail(&p, 2);
        listInsertDataAtTail(&p, 3);
        listInsertDataAtTail(&p, 4);
        listInsertDataAtTail(&p, 5);
    
        printf("已有节点:1-2-3-4-5\n");
        printList(p);
    
    //    删除
    //    printf("删除1后面结点\n");
    //    listDeleteData(&p, 1);
    //    listDeleteData(&p, 3);
    //    printList(p);
    
    //    修改
        printf("修改2为20000\n");
        listChangeData(p, 2, 20000);
        printList(p);
    
        listDestroy(&p);
        printList(p);
        return 0;
    }
    


    展开全文
  • C语言链表基本操作

    2019-04-02 22:10:05
  • 1 创作初衷  作为一个毕业半年,到公司上班的 程序猿,却还没有参与过一次实际的项目开发,没有跟着项目写过一行代码, ... 这次简单的回顾一下 C语言 链表基本操作,如果诸位看众 发现有什么错误
  • 本文内容是关于:C语言 链表详解,c语言链表教程。 链表(Linked list)是一种常见的基础数据结构,是一种线性表,但是并不会按线性的顺序存储数据,而是在每一个节点里存到下一个节点的指针(Pointer)。 单链表(单向...
  • c语言链表操作

    2013-03-28 10:16:15
    c语言实现的链表操作,包括建表,插入,删除,显示等一些基本操作。。。
  • C语言链表各类操作详解

    千次阅读 2019-01-23 23:17:09
    1.单链表的读取 获取链表第i个数据的算法思路: 声明一个指针p指向链表的第一个结点,初始化j从1开始; 当j&amp;lt; i 时,遍历链表,让p的指针向后移动,.../*操作结果: 用e返回L中第i个数据元素的值*/ St...
  • C语言链表操作

    2018-06-02 15:03:44
    链表 1。是由结构体和指针构成的。 2。包括两个部分一个是数据域和指针域。 3。链表中的结点分为两类:头结点和一般结点。头结点是没有数据域的。...基本操作有:初始化链表,增加结点和删除结点,求链表的长度等等。
  • 使用的C语言和ege库编写的链表操作演示程序源码,对于链表的几个基本操作都具有演示动画,且数据全部随机产生
  • C语言实现链表基本操作之前说过顺序表的基本操作。显然,顺序表有一个很大的缺点,就是做插入删除操作的时候,往往要做很大量的元素移动的操作。这里我们讨论另外一种线性表的表示方法——链式存储结构。由于它不...
  • C语言实现双向列表的创建,删除,添加节点,删除节点,插入节点,遍历节点,打印节点,并结合插入排序法实现了基于双向链表的升序排序。
  • 一步一步教你从零开始写C语言链表

    万次阅读 多人点赞 2017-04-02 14:34:39
    发送"链表"即可获取。 为什么要学习链表链表主要有以下几大特性: 1、解决数组无法存储多种数据类型的问题。 2、解决数组中,元素个数无法改变的限制(C99的变长数组,C++也有变长数组可以实现)。 3、数组...
  • 链表是一种链式存储结构,其特点是用一组任意的存储单元存储数据...下面用C语言为大家讲解单链表的插入数据和删除数据操作。1. 单链表的特点(1)逻辑上相邻的元素在物理上不一定相邻。(2)删除和插入操效率高,随机访...
  • C语言链表

    2020-04-14 20:29:56
    #C语言链表的操作 我的第一篇博客文章 你们好啊,这是我的第一篇博客文章,写的是C语言的链表,嘿嘿,来咯!! C语言实现链表 我们先来看下基本操作 //函数声明 void menu(); //菜单 LinkList *initList(); //初始化...
  • C语言链表基本操作 链表是编程中经常会遇到的一种存储结构,其相对于数组的存储结构而存在,链表最大的优点在于其存储是动态的,你需要多少内存空间就申请多,而不像数组那样,有时候会造成空间的浪费,有时候会...
  • 链表是一种线性存储结构。 别名链式存储结构或者单链表,用于存储逻辑关系为“一对一”

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 39,165
精华内容 15,666
关键字:

c语言链表的基本操作

c语言 订阅