精华内容
下载资源
问答
  • 链表 c语言

    2011-12-09 23:56:24
    链 表
  • 链表C语言实现

    2018-06-03 22:27:27
    链表C语言实现,详细参考博客 https://blog.csdn.net/qq_28261343/article/details/53584995#t40
  • 数据结构 链表 C语言 单向链表
  • 简易客房管理系统 链表 c语言 链表 c语言你懂的
  • CH9 4A 链表c语言教案 精选文档.ppt
  • 牛客反转链表C语言

    2021-03-24 12:02:15
    牛客反转链表C语言 struct ListNode* ReverseList(struct ListNode* pHead ) { struct ListNode *next=pHead->next; struct ListNode *cur=pHead; struct ListNode *pre=NULL; while(cur)//旧的链表不为空就...

    牛客反转链表C语言

    struct ListNode* ReverseList(struct ListNode* pHead ) {
       struct ListNode *next=pHead->next;
       struct ListNode *cur=pHead;
       struct ListNode *pre=NULL;
        while(cur)//旧的链表不为空就继续循环
        {
            //在遍历旧链表的时候 将每一个结点的指针改变 注意要先将旧链表中的next赋值给新创建的next,然后将结点next指向前一个结点pre,让后通过next遍历
            next=cur->next;//该指针用来使cur能遍历旧链表
            cur->next=pre;//把当前节点的指针域指向前一个结点
            pre=cur;//旧链表中前一个结点遍历到旧链表中的下一个结点
            cur=next;//就连表中的当前结点遍历到下一个结点
        }
        return pre;
    }
    
    展开全文
  • 数据结构 链表 C语言实现 先将代码分享出来,后续更新使用说明 链表难度大于队列,使用的双重指针实现,对C语言基础要求稍微高一点。 /** * 文件名: ulist.c * 说明: 链表实现源文件 * 作者: HAUE.Y2C */ #...

    数据结构 链表 C语言实现

    先将代码分享出来,后续更新使用说明
    链表难度大于队列,使用的双重指针实现,对C语言基础要求稍微高一点。

    /**
     * 文件名:	ulist.c
     * 说明:	链表实现源文件
     * 作者: 	HAUE.Y2C
     */
    #include "ulist.h"
    
    //链表初始化
    SListNode ** SListInit(void)
    {
        SListNode **ppFirst;
    	ppFirst = (SListNode**)malloc(sizeof(SListNode*));
        *ppFirst = NULL;
        return ppFirst;
    }
    
    //申请新节点
    static SListNode* CreateNode(DataType stdata)
    {
    	SListNode*node = (SListNode*)malloc(sizeof(SListNode));
    	if( node != NULL)
    	{   
    	    //为结构体内的pData数据指针申请内存空间和进行数据存储,使用长度复制,不使用字符串长度复制
         	unsigned char *pTempData = malloc(stdata.dataLen);  
            memcpy((char *)pTempData, (char *)stdata.pData, stdata.dataLen);
            
            node->data.dataLen = stdata.dataLen;
            node->data.pData = pTempData;
        	node->next = NULL;
    	}
    	return node;
    }
    
    //尾部插入 
    void SListPushBack(SListNode** ppFirst, DataType stdata)
    {
        SListNode *node = CreateNode(stdata);	
    	if (*ppFirst == NULL)       		//空链表      
    	{	
    		*ppFirst = node;
    		return;
    	}
    	else                            	//非空链表,寻找链表中的最后一个节点      
    	{  
            SListNode* cur = *ppFirst;  
            while (cur->next != NULL)
            {
            	cur = cur->next;
            }
            cur->next = node;//插入新申请的节点
        }
    }
    
    //头部插入
    void SListPushFront(SListNode **ppFirst, DataType stdata)
    {
    	SListNode *node = CreateNode(stdata);
    	node->next = *ppFirst;
    	*ppFirst = node;
    }
    
    //尾部删除 
    void SListPopBack(SListNode **ppFirst)
    {
    	if(*ppFirst == NULL)            	//空链表退出
    	{
            return;  
    	}
    	else                            	//非空链表,进行删除操作
    	{   
    	    SListNode*cur = *ppFirst;  
    	            
            while (cur->next != NULL)       //寻找链表中的最后一个节点
            {
                cur = cur->next;
            }
            free(cur->data.pData);
            free(cur->next);
            cur->next = NULL;
    
            if ((*ppFirst)->next == NULL)   //最后一个节点,清空链表
            {
                *ppFirst = NULL;
            }
    	}
    }
    
    //头部删除 
    void SListPopFront(SListNode **ppFirst)
    {
    	if(*ppFirst == NULL)            	//空链表退出
    	{
            return;  
    	}
    	else                            	//非空链表,进行删除操作
    	{ 
        	SListNode *first = *ppFirst;    
        	*ppFirst = (*ppFirst)->next;
            free(first->data.pData);
        	free(first);
        }
    }
    
    
    /**
     * 文件名:	ulist.h
     * 说明:	链表实现头文件
     * 作者: 	HAUE.Y2C
     */
    #ifndef __ULIST_H
    #define __ULIST_H
    #include "sys.h"
    #include "main.h"
    
    typedef struct  
    {
     	unsigned char dataLen;				//数据长度
    	unsigned char *pData;		    	//数据指针     
    }DataType;
    
    typedef struct SListNode 
    {
    	DataType data; 						// 值 
    	struct SListNode *next;			 	// 指向下一个结点 
    }SListNode;
    
    //初始化 ,构造一条空的链表
    SListNode ** SListInit(void);
    //尾部插入 
    void SListPushBack(SListNode** ppFirst, DataType data);
    //头部插入 
    void SListPushFront(SListNode **ppFirst, DataType data);
    //尾部删除 
    void SListPopBack(SListNode **ppFirst);
    //头部删除 
    void SListPopFront(SListNode **ppFirst);
    
    #endif 
    
    

    其他

    如果有用请点赞,谢谢!!!

    展开全文
  • 链表c语言代码

    2018-08-30 15:31:40
    数据结构c语言链表的代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode; struct LinkList { Lnode pHeader; //头节点 int m_Size; //长度 }; typedef struct ...
  • 关于严蔚敏版数据结构的静态链表的代码实现,C语言实现
  • 双向链表C语言实现

    2018-12-13 13:36:34
    通过双向链表实现按照ID序列插入,可以排序实现插入、删除、更新、修改;
  • 循环链表C语言实现

    2018-02-03 17:48:33
    1.创建链表 2.销毁链表 3.获取链表长度 4.清空链表 5.获取第pos个元素操作 6.插入元素到位置pos 7.删除位置pos处的元素 8.获取当前游标指向的数据元素; 9.将游标重置指向链表中的第一个数据元素; 10.将游标移动...
  • 同质链表 C语言实现

    2013-04-16 22:47:13
    同质链表C语言实现 ,方便大家参考
  • 数据结构实验之 链表 c语言 写的控制台程序,功能齐全,包含了对链表的各种操作,
  • 有序插入建立链表 C语言实现

    千次阅读 2016-01-13 13:24:49
    实现代码/*有序插入建立链表 C语言实现*/#include #include<stdlib.h>/*定义一个linklist结构体类型*/ typedef struct linklist { int data; struct linklist *next; }list, *plist;/*按从小到大顺序插入*/ void ...

    实现代码

    /*有序插入建立链表 C语言实现*/
    
    #include<stdio.h>
    #include<stdlib.h>
    
    /*定义一个linklist结构体类型*/
    typedef struct linklist
    {
        int data;
        struct linklist *next;
    }list, *plist;
    
    /*按从小到大顺序插入*/
    void order_insert_list(plist *head,int number)
    {
        plist p_new = (plist)malloc(sizeof(list));
        plist pre = NULL;           /* pre指针作为temp指向next前的备份 */
        p_new->data = number;       /* 赋予新值给新结点 */
        p_new->next = NULL;         
    
        plist temp = (plist)malloc(sizeof(list));
        temp = *head;  /*每次插入前从链表头开始的位置*/
    
        /*首位空结点赋初值*/
        if (NULL == *head)
        {
            *head = p_new;
            return;
        }
    
        /*若新data比头结点小,头结点前插入*/
        if (p_new->data < temp->data)
        {
            p_new->next = temp; 
            *head = p_new;
            return;
        }
        else
        {
            while (NULL != temp)
            {   
                if (p_new->data >= temp->data)/* 新结点对当前结点data比较 */
                {
                    pre = temp;     
                    temp= temp->next;/*当前结点后移,直至5(比如1 2 3 5 插入4)的位置*/
                    continue;
                }
                else
                {
                    p_new->next = temp;/* 插入新结点 */
                    pre->next = p_new; /* temp的前一个的位置的next指向新结点p_new */
                    break;
                }           
            }
            if (NULL == temp)/* 当temp最终为尾结点时,说明新元素data最大,将结点作为尾结点 */
            {
                p_new->next = NULL;
                pre->next = p_new;   /* temp的前一个的位置的next指向新结点p_new */
            }
        }
    }
    
    void print_list(plist head)
    {
        plist elem = head; 
        while (elem != NULL)
        {
            printf("%d ", elem->data);
            elem = elem->next;
        }
        printf("\n");
    }
    
    void main()
    {
        int number;
        plist head;     /*定义表头*/
        head = NULL;
    
        printf("input some numbers:\n");
        scanf("%d", &number);
        while (number != -1) /*输入-1终止*/
        {
            order_insert_list(&head,number);
            scanf("%d", &number);
        }
    
        print_list(head);/*打印输出*/
    
        system("pause");
    }

    运行结果:

    这里写图片描述

    展开全文
  • 静态链表C语言实现

    2018-02-02 11:53:24
    代码经过产品验证,可以直接用于产品,有利于提高产品开发进度。
  • 顺序链表C语言实现

    千次阅读 2019-11-04 18:15:14
    顺序链表没什么说的啦,直接上代码,参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了,不过没关系,都一样。 Operation中有一处语法上的疑惑,就是插入的那个函数中,node为什么要强制转换成整型,...

    顺序链表没什么说的啦,直接上代码,参考了传智播客出版的数据结构。创建工程的时候不小心弄成c++了,不过没关系,都一样。

    Operation中有一处语法上的疑惑,就是插入的那个函数中,node为什么要强制转换成整型,既然等式两边都是指针,为什么不是转化成int* ,有心人帮忙解答一下,谢谢。

    SeqList.h头文件

    #ifndef _SEQLIST_H_
    #define _SEQLIST_H_
    
    typedef void SeqList;
    typedef void SeqListNode;
    
    /*
    顺序存储线性表操作
    创建-Create()
    初始化-Init()
    获取长度-GetLength()
    判断表是否为空-IsEmpty()
    获取元素-Get()
    插入-Insert()
    删除-Delete()
    清空表-Clear()
    */
    
    SeqList* SeqList_Create(int capacity);
    void SeqList_Destory(SeqList *list);
    void Seqlist_Clear(SeqList * list);
    int SeqList_Length(SeqList * list);
    int SeqList_Capacity(SeqList * list);
    int SeqList_Insert(SeqList * list,SeqListNode * node,int pos);
    SeqList * SeqList_Get(SeqList *list, int pos);
    SeqList * SeqList_Delete(SeqList * list, int pos);
    
    #endif

    Operation.cpp

    /*
    顺序存储线性表操作
    创建-Create()
    初始化-Init()
    获取长度-GetLength()
    判断表是否为空-IsEmpty()
    获取元素-Get()
    插入-Insert()
    删除-Delete()
    清空表-Clear()
    思路:创建一个头节点存储线性表的容量、长度、首地址等信息,顺序线性表的优点是可以随机访问
    缺点是插入删除等操作效率较低。
    */
    #include<stdio.h>
    #include<stdlib.h>
    #include<string.h>
    #include "SeqList.h"
    typedef struct _tag_SeqList//定义一个头结点
    {
    	int capacity;
    	int length;
    	int * node;
    }TSeqList;
    
    //创建顺序表
    SeqList * SeqList_Create(int capacity)//返回值是void类型的指针,可以用任何类型的指针接住,但是需要强制类型转换
    {
    	int ret;
    	TSeqList *temp = NULL;//声明一个指向头结点的指针
    	temp = (TSeqList*)malloc(sizeof(TSeqList));//为头结点分配空间
    	if (temp == NULL)//健壮性保护,每次malloc后都要判断是否malloc成功,养成好习惯
    	{
    		ret = 1;
    		printf("func SeqList_Create() error:%d\n", ret);
    		return NULL;
    	}
    	memset(temp, 0, sizeof(TSeqList));//初始化将temp指向处到TSeqList个字节的内容置为0
    	temp->capacity = capacity;
    	temp->length = 0;
    	temp->node = (int *)malloc(sizeof(void *) * capacity);//指针不管什么类型,实际上大小都是一样的,所以参数表出用void *。
    	if (temp->node == NULL)
    	{
    		ret = 2;
    		printf("func SeqList_Create() error:%d\n", ret);
    		return NULL;
    	}
        return temp;
    }
    
    int SeqList_Capacity(SeqList * list)//传入的参数是万能指针void类型的,可以用任何类型的指针接着,但是需要强制转换,非常灵活
    {
    	TSeqList *temp = NULL;
    	if (list == NULL)//健壮性判断
    	{
    		return -1;
    	}
    	temp = (TSeqList *)list;//因为传入的万能指针,所以要做个强制类型转化
    	return temp->capacity;
    }
    
    int SeqList_Length(SeqList * list)//传入的参数是万能指针void类型的,可以用任何类型的指针接着,但是需要强制转换,非常灵活
    {
    	TSeqList *temp = NULL;
    	if (list == NULL)//健壮性判断
    	{
    		return -1;
    	}
    	temp = (TSeqList *)list;//因为传入的万能指针,所以要做个强制类型转化
    	return temp->length;
    }
    
    int SeqList_Insert(SeqList *list, SeqListNode * node, int pos)
    {
    	int i;
    	TSeqList *temp = NULL;
    	if (list == NULL || node == NULL)
    	{
    		return -1;
    	}
    	temp = (TSeqList*)list;
    	//如果顺序表满
    	if (temp->length >= temp->capacity)
    	{
    		return -2;
    	}
    	if (pos > temp->length)//如果给出的位置超过了顺序表的长度,就填补到顺序表最后一位
    		pos = temp->length;
    	for (i = temp->length; i > pos; i--)//将插入位置的元素一次向后移动
    	{
    		temp->node[i] = temp->node[i - 1];
    	}
    	temp->node[i] = (int)node;//在插入位置插入新元素节点
    	//node是一个指针数组,且都是万能指针,所以node[i]应该是一个万能指针的地址,那传入的node也是万能指针,要对它明确化
    	//但是为什么是int型呢,应该是指向传入类型的指针,但是又不确定传入类型是什么,只好转成int了? 没太搞懂。
    	//printf("%p\n", temp->node[i]);
    	temp->length++;
    	return 0;
    }
    
    SeqList* SeqList_Delete(SeqList* list, int pos)
    {
    	int i = 0;
    	TSeqList * tlist = NULL;
    	SeqListNode * temp = NULL;
    	tlist = (TSeqList*)list;
    	if (list == NULL || pos < 0 || pos >= tlist->capacity)
    	{
    		printf("SeqList_Delete() error\n");
    		return NULL;
    	}
    	temp = (SeqListNode*)tlist->node[pos];
    	for (i = pos + i; i < tlist->length; i++)
    	{
    		tlist->node[i - 1] = tlist->node[i];
    	}
    	tlist->length--;
    	return temp;
    }
    
    SeqList * SeqList_Get(SeqList *list, int pos)
    {
    	TSeqList * tlist = NULL;
    	SeqListNode *temp = NULL;
    	tlist = (TSeqList *)list;
    	if (list == NULL || pos < 0 || pos >= tlist->capacity)
    	{
    		printf("SeqList_Get() error\n");
    		return NULL;
    	}
    
    	temp = (SeqListNode*)tlist->node[pos];
    	return temp;
    }
    
    void SeqList_Clear(SeqList *list)
    {
    	TSeqList * temp = NULL;
    	if (list == NULL)
    	{
    		return;
    	}
    	temp = (TSeqList *)list;
    	temp->length = 0;
    	memset(temp->node, 0, (temp->capacity * sizeof(void *)));
    	return;
    }
    
    void SeqList_Destory(SeqList * list)
    {
    	TSeqList * temp = NULL;
    	if (list == NULL)
    	{
    		return;
    	}
    	temp = (TSeqList *)list;
    	if (temp->node != NULL)
    	{
    		free(temp->node);
    	}
    	free(temp);
    	return;
    }

    main.cpp测试函数

    #include<stdio.h>
    #include<stdlib.h>
    #include "SeqList.h"
    
    typedef struct _Teacher
    {
    	char name[32];
    	int age;
    }Teacher;
    
    int main()
    {
    	int ret = 0;
    	SeqList * list = NULL;
    	Teacher t1, t2, t3, t4, t5;
    	t1.age = 31;
    	t2.age = 32;
    	t3.age = 33;
    	t4.age = 34;
    	t5.age = 35;
    	//创建结点10个
    	list = SeqList_Create(10);
    	//插入结点
    	ret = SeqList_Insert(list, (SeqListNode *)&t1, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t2, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t3, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t4, 0);
    	ret = SeqList_Insert(list, (SeqListNode *)&t5, 0);
    	//printf("Teacher:%p\n", &t5);
    
    	printf("顺序表容量:%d\n", SeqList_Capacity(list));
    	printf("顺序表长度:%d\n", SeqList_Length(list));
    
    	printf("遍历顺序表:\n");
    	for (int i = 0; i < SeqList_Length(list); i++)
    	{
    		Teacher * temp = (Teacher *)SeqList_Get(list, i);
    		if (temp == NULL)
    		{
    			printf("func SeqList_Get() error: %d\n", ret);
    			return 0;
    		}
    		printf("age:%d\n", temp->age);
    	}
    
    	//销毁链表
    	printf("销毁顺序表时:\n");
    	while (SeqList_Length(list) > 0)
    	{
    		Teacher * temp = (Teacher*)SeqList_Delete(list, 0);//删除头部元素
    		if (temp == NULL)
    		{
    			printf("func SeqList_Get() error %d\n", ret);
    			return 0;
    		}
    		printf("age:%d\n", temp->age);
    	}
    	SeqList_Destory(list);
    	system("pause");
    	return 0;
    }

     

    展开全文
  • 课程要求,线性表链式存储结构。有尾接法也有头接法。
  • 单向链表C语言实现

    千次阅读 2019-11-05 18:27:28
    printf("元素删除成功,删除元素%d后,链表中元素为:\n",num); print(ph); ret = find(ph,3); if (ret) printf("Get!"); else printf("NO!\n"); system("pause"); return 0; }  
  • 据 结 构 课 程 设 计 设计题目:两个链表的交叉合并 专业班级08软件工程3班 姓名xxxxxx 学号080107031123 设计时间2010/9/25 指导教帅杨薇薇 一 设计题目 实现两个链表的合并 设计目的 .掌握线性链表的建立 .掌握...
  • 单向循环链表C语言实现

    千次阅读 2016-06-27 22:03:14
    我们都知道,单向链表最后指向为NULL,也就是为空,那单向循环链表就是不指向为NULL了,指向头节点,所以下面这个程序运行结果就是,你将会看到遍历链表的时候就是一个死循环,因为它不指向为NULL,也是周而复始的...
  • acm编程训练 单向链表 C语言程序设计教程(第三版)课后习题11.8 Description 已有a、b两个链表,每个链表中的结点包括学号、成绩。要求把两个链表合并,按学号升序排列。 Input 第一行,a、b两个链表元素的数量...
  • void insert(struct Node* headNode, int data) { struct Node *newNode = creatNode(data); newNode->next = headNode->next; // 先② headNode->next = newNode; // 后① }
  • 中序遍历二叉树将遍历结果存入双向循环链表C语言实现 新浪面试题 #include #include #include #define OK 1 #define Error 0 typedef int Status; typedef char ElemType; //循环链表的定义 typedef ...
  • leetcode 707设计链表 c语言实现

    千次阅读 2018-10-04 15:07:34
    这道题我用c写的,写过程中出现了好多bug,唉,还是对链表不是很熟,比如在插入结点时,如果是首结点该如何处理。好在最后还能正常写出来了~~~ 题目描述 设计链表的实现。您可以选择使用单链表或双链表。单链表中...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 21,080
精华内容 8,432
关键字:

链表c语言

c语言 订阅