C语言数据结构——链表
2024-07-01 22:05:14
目录
前言
一、什么是链表
1.1链表的结构和概念
1.2 链表的分类
二、无头单向非循环链表
2.1 创建结构体
2.2 动态申请一个节点
2.3 单链表打印
2.4 单链表尾插/尾删
2.4.1 单链表尾插
2.4.2 单链表尾删
2.5 单链表头插/头删
2.5.1 头插
2.5.2 头删
2.6 单链表查找
2.7 单链表中间插入/中间删除
2.7.1 中间插入
2.7.2 中间删除
2.8 单链表销毁
三、双向带头循环链表
3.1 结构体的创建
3.2 创造节点
3.3 创建返回链表的头结点(哨兵位)
3.4 双链表打印
3.5 双链表的尾插/尾删
3.5.1 尾插
3.5.2 尾删
3.6 双链表的头插/头删
3.6.1 头插
3.6.2 头删
3.7 双链表的查找
3.8 双链表的中间插入/中间删除
3.8.1 中间插入
3.8.2 中间删除
3.9 双链表的销毁
四、链表和顺序表的区别
五、代码及代码展示
5.1 单向链表
5.1.1 效果展示
5.1.2 代码
5.2 双向带头循环链表
5.2.1 效果展示
5.2.2 代码
总结
前言
大家好，本篇文章主要带领大家了解一下什么是链表，链表的两个主要结构，以及链表和顺序表的差别。
一、什么是链表
1.1链表的结构和概念
概念：链表是一种物理存储结构上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的 。
链表就像是火车，每块空间都独立存在，彼此通过指针相链接。
链表的数据结构如下所示：
注意：
1.从上图看出，链式结构逻辑上是连续的，但在内存中的存储可能是不连续的。
2.现实中的节点一般都是在堆上面申请的。
3.从堆上面申请空间是有其规律的，两次申请的空间可能连续也可能不连续。
1.2 链表的分类
实际中链表的结构非常多样，以下情况组合起来就有8种链表结构：
1.单向或者双向
2.带头(哨兵位)或者不带头
3.循环或者非循环
8种链表结构分别是：单向链表，单向带头，单向循环，单向带头循环，双向链表，双向带头，双向循环，双向带头循环
其中最常用的有两个分别是单向链表，双向带头循环链表。
1. 无头单向非循环链表：结构简单，一般不会单独用来存数据。实际中更多是作为其他数据结构的子结构，如哈希桶、图的邻接表等等
2.带头双向循环链表：结构最复杂，一般用在单独存储数据。实际中使用的链表数据结构，都是带头双向循环链表。
接下来我们就带领大家实现这两个最常用的链表结构
ps：建议大家在完成链表时，每完成一个功能都测试一下，以免最后调bug调崩溃
二、无头单向非循环链表
本次链表我们将其分成三个文件SList.c，SList.h，test.c，分别用来实现，声明，测试。
ps：链表的全部代码以及效果展示会在文章末尾贴出
2.1 创建结构体
创建结构体，其中有两个成员，一个用来存储数据，一个用来指向下一个空间，并将其名字定义为SListNode方便后续使用
typedef int SLTDateType;typedef struct SListNode
{SLTDateType data;struct SListNode* next;
}SListNode;2.2 动态申请一个节点
申请节点我们用malloc函数，申请成功后返回空间地址，需要注意此时未和其他节点链接
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{SListNode* ptr = (SListNode*)malloc(sizeof(SListNode));if (ptr == NULL){perror("malloc");exit(-1);}SListNode* Phead = ptr;Phead->data = x;Phead->next = NULL;return Phead;}2.3 单链表打印
先写打印的函数，方便后续测试，将链表遍历一遍即可
// 单链表打印
void SListPrint(SListNode* plist)
{SListNode* tail = plist;while (tail){printf("%d->", tail->data);tail = tail->next;}printf("NULL\n");
}2.4 单链表尾插/尾删
2.4.1 单链表尾插
先判断链表是否为空，为空则直接为其创建一个节点即可，不为空则需要遍历到最后一个节点进行插入。
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist=BuySListNode(x);}else{SListNode* tail = *pplist;while (tail->next){tail = tail->next;}tail->next = BuySListNode(x);}
}2.4.2 单链表尾删
尾删也就是尾插反着来即可，但是需要判断是否为空，为空则无法删除
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{assert(*pplist);SListNode* tail = *pplist;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;
}2.5 单链表头插/头删
2.5.1 头插
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist = BuySListNode(x);}else{SListNode* cur = BuySListNode(x);cur->next = *pplist;*pplist = cur;}
}2.5.2 头删
// 单链表头删
void SListPopFront(SListNode** pplist)
{assert(*pplist);SListNode* cur = *pplist;*pplist = cur->next;free(cur);
}2.6 单链表查找
单链表查找主要是为了后面的中间插入删除，需要先找到要删的位置，遍历一遍链表就可以
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{assert(plist);SListNode* cur = plist;while (cur){if (cur->data == x){return cur;}cur = cur->next;}return NULL;}2.7 单链表中间插入/中间删除
由于单链表只能从前往后走，而想要从中间位置插入或者删除数据，则需要改变前一个结构体的指针，所以只能插入或者删除指定位置后面的数据。
2.7.1 中间插入
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{assert(pos);SListNode* a=BuySListNode(x);SListNode* cur = pos->next;pos->next = a;a->next = cur;}2.7.2 中间删除
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{assert(pos);if (pos->next == NULL){return;}SListNode* cur = pos->next;pos->next = cur->next;free(cur);
}2.8 单链表销毁
遍历一遍，一个一个释放即可
// 单链表的销毁
void SListDestroy(SListNode** pplist)
{assert(*pplist);while (*pplist){SListNode* cur = (*pplist)->next;free(*pplist);*pplist = cur;}*pplist = NULL;
}三、双向带头循环链表
本次链表我们将其分成三个文件List.c，List.h，test.c，分别用来实现，声明，测试。
ps：链表的全部代码以及效果展示会在文章末尾贴出
3.1 结构体的创建
创建结构体，其中有三个成员，一个用来存放数据，另外两个指针，分别指向前一个空间和后一个空间
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{LTDataType _data;struct ListNode* _next;struct ListNode* _prev;
}ListNode;3.2 创造节点
创造节点我们仍用malloc函数
//创造节点
ListNode* BuyLTNode(LTDataType x)
{ListNode* cur = (ListNode*)malloc(sizeof(ListNode));if (cur == NULL){perror("malloc");exit(-1);}cur->_data = x;return cur;}3.3 创建返回链表的头结点(哨兵位)
当创建哨兵位时，我们一般将其中的数据赋为0，而且创建哨兵位的时候，链表只有哨兵位一个数据，所以其前后指针都指向自己以达到循环的目的。
// 创建返回链表的头结点.
ListNode* ListCreate()
{ListNode* head = BuyLTNode(0);head->_next = head;//循环列表创建头时头的首尾都指向自己head->_prev = head;return head;
}3.4 双链表打印
从头的下一个节点开始遍历，当重新遍历到头部时，说明遍历完成。
// 双向链表打印
void ListPrint(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;while (cur!=pHead){printf("%d->", cur->_data);cur = cur->_next;}printf("head\n");
}3.5 双链表的尾插/尾删
3.5.1 尾插
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_prev = pHead->_prev;//要尾插的节点的prev指向原来的尾节点newnode->_next = pHead;//要尾插的节点的next指向头pHead->_prev->_next = newnode;//原来的尾节点的next指向新尾pHead->_prev = newnode;//头的prev指向新尾}3.5.2 尾删
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{assert(pHead);assert(pHead->_next!=pHead);ListNode* tail = pHead->_prev;//用一个指针保存尾巴tail->_prev->_next = pHead;//将倒数第二个节点的next指向头pHead->_prev = tail->_prev;//头节点的prev指向倒数第二节点free(tail);}3.6 双链表的头插/头删
3.6.1 头插
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_next = pHead->_next;//新空间的next指向原来的第一个数据newnode->_prev = pHead;//新空间的prev指向头pHead->_next->_prev = newnode;//原来的的一个数据的prev指向newnodepHead->_next = newnode;//头的next指向newnode
}3.6.2 头删
// 双向链表头删
void ListPopFront(ListNode* pHead)
{assert(pHead);assert(pHead->_next != pHead);//先判断链表中除了头有无其他数据ListNode* oldnode = pHead->_next;//将要删除的数据的位置保存起来，以防后面丢失pHead->_next = oldnode->_next;//头的next指向第二个数据oldnode->_next->_prev = pHead;//第二个数据的prev指向头free(oldnode);//释放数据空间即可
}3.7 双链表的查找
主要是为后面的中间插入删除服务
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* cur = pHead->_next;while (cur != pHead){if (cur->_data == x){return cur;}cur = cur->_next;}return NULL;
}3.8 双链表的中间插入/中间删除
3.8.1 中间插入
要插入指定位置，其实就是插入到指定位置的前面即可
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{assert(pos);//调整pos newnode pos前面的数据这三个空间的prev和next即可ListNode* newnode = BuyLTNode(x);ListNode* prev = pos->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = pos;pos->_prev = newnode;
}3.8.2 中间删除
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{assert(pos);ListNode* prev = pos->_prev;ListNode* next = pos->_next;free(pos);prev->_next = next;next->_prev = prev;}3.9 双链表的销毁
// 双向链表销毁
void ListDestory(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;ListNode* next = cur->_next;while (cur != pHead)//先释放除头以外的所有节点，再释放头{free(cur);cur = next;next = next->_next;}free(cur);
}四、链表和顺序表的区别
顺序表：
优点：尾删尾插效率高，访问随机下标快
缺点：空间不够需扩容（扩容代价大）；头插头删及中间插入删除需要挪动数据，效率低
链表
优点：需要扩容时，按需申请小块空间；任意位置插入效率都高（O(1)）
缺点：不支持下标随机访问
五、代码及代码展示
5.1 单向链表
5.1.1 效果展示
5.1.2 代码
SList.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x)
{SListNode* ptr = (SListNode*)malloc(sizeof(SListNode));if (ptr == NULL){perror("malloc");exit(-1);}SListNode* Phead = ptr;Phead->data = x;Phead->next = NULL;return Phead;}
// 单链表打印
void SListPrint(SListNode* plist)
{SListNode* tail = plist;while (tail){printf("%d->", tail->data);tail = tail->next;}printf("NULL\n");
}
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist=BuySListNode(x);}else{SListNode* tail = *pplist;while (tail->next){tail = tail->next;}tail->next = BuySListNode(x);}
}
// 单链表的尾删
void SListPopBack(SListNode** pplist)
{assert(*pplist);SListNode* tail = *pplist;while (tail->next->next){tail = tail->next;}free(tail->next);tail->next = NULL;
}
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x)
{if (*pplist == NULL){*pplist = BuySListNode(x);}else{SListNode* cur = BuySListNode(x);cur->next = *pplist;*pplist = cur;}
}
// 单链表头删
void SListPopFront(SListNode** pplist)
{assert(*pplist);SListNode* cur = *pplist;*pplist = cur->next;free(cur);
}
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x)
{assert(plist);SListNode* cur = plist;while (cur){if (cur->data == x){return cur;}cur = cur->next;}return NULL;}
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x)
{assert(pos);SListNode* a=BuySListNode(x);SListNode* cur = pos->next;pos->next = a;a->next = cur;}
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos)
{assert(pos);if (pos->next == NULL){return;}SListNode* cur = pos->next;pos->next = cur->next;free(cur);
}
// 单链表的销毁
void SListDestroy(SListNode** pplist)
{assert(*pplist);while (*pplist){SListNode* cur = (*pplist)->next;free(*pplist);*pplist = cur;}*pplist = NULL;
}SList.h
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
typedef int SLTDateType;typedef struct SListNode
{SLTDateType data;struct SListNode* next;
}SListNode;
// 动态申请一个节点
SListNode* BuySListNode(SLTDateType x);
// 单链表打印
void SListPrint(SListNode* plist);
// 单链表尾插
void SListPushBack(SListNode** pplist, SLTDateType x);
// 单链表的尾删
void SListPopBack(SListNode** pplist);
// 单链表的头插
void SListPushFront(SListNode** pplist, SLTDateType x);
// 单链表头删
void SListPopFront(SListNode** pplist);
// 单链表查找
SListNode* SListFind(SListNode* plist, SLTDateType x);
// 单链表在pos位置之后插入x
void SListInsertAfter(SListNode* pos, SLTDateType x);
// 单链表删除pos位置之后的值
void SListEraseAfter(SListNode* pos);
// 单链表的销毁
void SListDestroy(SListNode** pplist);test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "SList.h"void menu()
{printf("*******************************\n");printf("****1.尾部插入 2.尾部删除 ****\n");printf("****3.头部插入 4.头部删除 ****\n");printf("****5.中间插入 6.中间删除 ****\n");printf("****7.打印 0.退出 ****\n");printf("*******************************\n");}int main()
{menu();SListNode* Phead = NULL;int input;do{printf("请选择:");scanf("%d", &input);switch (input){case 1:printf("请输入要写入的数字：");SLTDateType i;scanf("%d", &i);SListPushBack(&Phead,i);break;case 2:SListPopBack(&Phead);break;case 3:printf("请输入要写入的数字：");SLTDateType a;scanf("%d", &a);SListPushFront(&Phead, a);break;case 4:SListPopFront(&Phead);break;case 5:printf("会将数据插入进输入数字之后的位置\n");printf("请输入要插入位置的数字及要插入的数字：");SLTDateType b, j;scanf("%d %d", &b, &j);SListNode* ret1 = SListFind(Phead, b);if (ret1 != NULL){SListInsertAfter(ret1, j);}else{printf("该数字不存在");}break;case 6:printf("请输入要删除的数字之前的数字:");SLTDateType c;scanf("%d", &c);SListNode* ret2 = SListFind(Phead, c);if (ret2 != NULL){SListEraseAfter(ret2);}else{printf("未找到该数字");}break;case 7:SListPrint(Phead);break;case 0:printf("退出");SListDestroy(&Phead);break;default:printf("输入错误，请重新输入");break;}} while (input);return 0;
}5.2 双向带头循环链表
5.2.1 效果展示
5.2.2 代码
List.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"
// 创建返回链表的头结点.
ListNode* ListCreate()
{ListNode* head = BuyLTNode(0);head->_next = head;//循环列表创建头时头的首尾都指向自己head->_prev = head;return head;
}
//创造节点
ListNode* BuyLTNode(LTDataType x)
{ListNode* cur = (ListNode*)malloc(sizeof(ListNode));if (cur == NULL){perror("malloc");exit(-1);}cur->_data = x;return cur;}
// 双向链表打印
void ListPrint(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;while (cur!=pHead){printf("%d->", cur->_data);cur = cur->_next;}printf("head\n");
}
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_prev = pHead->_prev;//要尾插的节点的prev指向原来的尾节点newnode->_next = pHead;//要尾插的节点的next指向头pHead->_prev->_next = newnode;//原来的尾节点的next指向新尾pHead->_prev = newnode;//头的prev指向新尾}
// 双向链表尾删
void ListPopBack(ListNode* pHead)
{assert(pHead);assert(pHead->_next!=pHead);ListNode* tail = pHead->_prev;//用一个指针保存尾巴tail->_prev->_next = pHead;//将倒数第二个节点的next指向头pHead->_prev = tail->_prev;//头节点的prev指向倒数第二节点free(tail);}
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* newnode = BuyLTNode(x);newnode->_next = pHead->_next;//新空间的next指向原来的第一个数据newnode->_prev = pHead;//新空间的prev指向头pHead->_next->_prev = newnode;//原来的的一个数据的prev指向newnodepHead->_next = newnode;//头的next指向newnode
}
// 双向链表头删
void ListPopFront(ListNode* pHead)
{assert(pHead);assert(pHead->_next != pHead);//先判断链表中除了头有无其他数据ListNode* oldnode = pHead->_next;//将要删除的数据的位置保存起来，以防后面丢失pHead->_next = oldnode->_next;//头的next指向第二个数据oldnode->_next->_prev = pHead;//第二个数据的prev指向头free(oldnode);//释放数据空间即可
}
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x)
{assert(pHead);ListNode* cur = pHead->_next;while (cur != pHead){if (cur->_data == x){return cur;}cur = cur->_next;}return NULL;
}
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x)
{assert(pos);//调整pos newnode pos前面的数据这三个空间的prev和next即可ListNode* newnode = BuyLTNode(x);ListNode* prev = pos->_prev;prev->_next = newnode;newnode->_prev = prev;newnode->_next = pos;pos->_prev = newnode;
}
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos)
{assert(pos);ListNode* prev = pos->_prev;ListNode* next = pos->_next;free(pos);prev->_next = next;next->_prev = prev;}
// 双向链表销毁
void ListDestory(ListNode* pHead)
{assert(pHead);ListNode* cur = pHead->_next;ListNode* next = cur->_next;while (cur != pHead)//先释放除头以外的所有节点，再释放头{free(cur);cur = next;next = next->_next;}free(cur);
}List.h
#define _CRT_SECURE_NO_WARNINGS 1
#include <stdio.h>
#include <assert.h>
#include <stdlib.h>
// 带头+双向+循环链表增删查改实现
typedef int LTDataType;
typedef struct ListNode
{LTDataType _data;struct ListNode* _next;struct ListNode* _prev;
}ListNode;
//创造节点
ListNode* BuyLTNode(LTDataType x);
// 创建返回链表的头结点.
ListNode* ListCreate();
// 双向链表销毁
void ListDestory(ListNode* pHead);
// 双向链表打印
void ListPrint(ListNode* pHead);
// 双向链表尾插
void ListPushBack(ListNode* pHead, LTDataType x);
// 双向链表尾删
void ListPopBack(ListNode* pHead);
// 双向链表头插
void ListPushFront(ListNode* pHead, LTDataType x);
// 双向链表头删
void ListPopFront(ListNode* pHead);
// 双向链表查找
ListNode* ListFind(ListNode* pHead, LTDataType x);
// 双向链表在pos的前面进行插入
void ListInsert(ListNode* pos, LTDataType x);
// 双向链表删除pos位置的节点
void ListErase(ListNode* pos);test.c
#define _CRT_SECURE_NO_WARNINGS 1
#include "List.h"
void menu()
{printf("*******************************\n");printf("****1.尾部插入 2.尾部删除 ****\n");printf("****3.头部插入 4.头部删除 ****\n");printf("****5.中间插入 6.中间删除 ****\n");printf("****7.打印 0.退出 ****\n");printf("*******************************\n");}int main()
{menu();ListNode* head = ListCreate();int input;do{printf("请选择:");scanf("%d", &input);switch (input){case 1:printf("请输入要写入的数字：");LTDataType i;scanf("%d", &i);ListPushBack(head, i);break;case 2:ListPopBack(head);break;case 3:printf("请输入要写入的数字：");LTDataType a;scanf("%d", &a);ListPushFront(head, a);break;case 4:ListPopFront(head);break;case 5:printf("会将数据插入进输入数字之前的位置\n");printf("请输入要插入位置的数字及要插入的数字：");LTDataType b,j;scanf("%d %d", &b,&j);ListNode* ret1 = ListFind(head, b);if (ret1 != NULL){ListInsert(ret1, j);}else{printf("该数字不存在");}break;case 6:printf("请输入要删除的数字:");LTDataType c;scanf("%d", &c);ListNode* ret2 = ListFind(head, c);if (ret2 != NULL){ListErase(ret2);}else{printf("未找到该数字");}break;case 7:ListPrint(head);break;case 0:printf("退出");ListDestory(head);break;default:printf("输入错误，请重新输入");break;}} while (input);return 0;
}总结
以上就是今天文章的内容，希望铁子们可以有所收货。
C语言数据结构——链表相关推荐
- C语言 数据结构 链表的增删查改
分别用函数实现了链表的: 1.增加(头插法,尾插法,有序插入) 2.删除 3.修改 4.查找 C代码 #define _CRT_SECURE_NO_WARNINGS #include<stdio ...
- C语言数据结构之二叉树的层次建树及遍历方法（前序，中序，后序，层次遍历）
C语言数据结构之二叉树的层次建树及遍历方法(前序,中序,后序,层次遍历) tips:前些天学习了C语言数据结构链表,栈,队列.今天来学习一下C语言数据结构之二叉树的各种操作. 注意:二叉树的层次建树是 ...
- c语言将一个已知头结点的单链表逆序_C语言数据结构实现链表逆序并输出
C语言数据结构实现链表逆序并输出 将一个链表逆序并输出.我用了两种方法来实现,第一种是借助了一个新的空链表:第二种是在原来链表的基础上直接实现逆序. 实例代码: 头文件: #include #incl ...
- c语言仓库管理系统链表,仓库管理系统 C语言 C++ 数据结构 链表 课程设计
仓库管理系统 C语言 C++ 数据结构 链表 课程设计 #include #include #include #include #define MAX 64 typedef struct node{ ...
- c语言单链表功能,[数据结构]单链表（C语言）的各种功能
06-03阅读200,000 + 链表是一种常见的基本数据结构,在此充分利用了结构指针. 链表可以动态存储和分配,即链表是一个功能非常强大的数组. 他可以在节点中定义多种数据类型,并可以根据需要随意添 ...
- C语言中用链表构建栈讲解,C语言数据结构之使用链表模拟栈的实例
C语言数据结构之使用链表模拟栈的实例 以下是"使用链表模拟栈"的简单示例: 1. 用C语言实现的版本 #include #include typedef char datatype ...
- c语言实现链表的逆序输出,C语言数据结构实现链表逆序并输出
C语言数据结构实现链表逆序并输出 将一个链表逆序并输出.我用了两种方法来实现,第一种是借助了一个新的空链表:第二种是在原来链表的基础上直接实现逆序. 实例代码: 头文件: #include #incl ...
- c语言仓库管理系统链表,仓库管理系统 C语言 C 数据结构 链表 课程设计.doc
仓库管理系统 C语言 C 数据结构 链表 课程设计 #include #include #include #include #define MAX 64 typedef struct node{ /* ...
- 用c语言实现链表数据保存,数据结构链表C语言实现.doc
数据结构链表C语言实现 数学与信息技术学院2016~2017(下)学年 计科专业2015级<数据结构>实验报告 2 学号:2015201018 姓名:汪继超 实验名称线性表的链式存储结构完 ...
最新文章
- vue-cli中的webpack的config配置详细说明
- Android之解决PC浏览器上传表单文件到手机服务器read数据错误导致有时候下载到手机的文件打开文字错乱问题
- [CSS] Scale on Hover with Transition
- phpMyAdmin 尝试连接到MySQL 服务器的错误解决方法
- oracle迁移需要注意配置文件,xtts迁移实践
- 百度又要开放哪些无人车新能力？“老司机”Apollo3.5要来了，市中心开车无压力...
- java8 function 固定0_Java8特性使用Function代替分支语句
- Windows 7 系统的旧版IE浏览器升级到IE11
- 什么是ASO，GooglePlayASO优化的方法有哪些
- 2020年阴历二月二十九 投资理财～业余投资者如果不深入研究财报该怎么办？
- 浅谈聊天机器人 ChatBot 涉及到的技术点 以及词性标注和关键字提取
- quanTIseq:肿瘤浸润免疫细胞定量分析
- 网址出现dns_probe_finished_no_internet
- 数据分析需要掌握的知识（2）
- 电商运营到底做什么？说出来你也不信。
- Ext js 下拉框模糊匹配查询，并支持反复输入检索
- 七日杀服务器怎么修改天数,七日杀调整游戏天数 | 手游网游页游攻略大全
- 中职计算机英语c答案,公共课计算机+英语答案.doc
- 【东方博宜】【基础】1878--哥德巴赫猜想
- Android 控件view的可见,不可见,隐藏的设置和区别