C语言链表代码

合集下载

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码

数据结构经典题目及c语言代码一、线性表1. 顺序表顺序表是一种利用连续存储空间存储元素的线性表。

以下是一个顺序表的经典题目及C语言代码实现:```c#define MaxSize 50typedef struct {int data[MaxSize]; // 存储元素的数组int length; // 顺序表的当前长度} SeqList;// 初始化顺序表void initList(SeqList *L) {L->length = 0;}// 插入元素到指定位置void insert(SeqList *L, int pos, int elem) {if (pos < 1 || pos > L->length + 1) {printf("插入位置无效\n");return;}if (L->length == MaxSize) {printf("顺序表已满,无法插入\n"); return;}for (int i = L->length; i >= pos; i--) { L->data[i] = L->data[i - 1];}L->data[pos - 1] = elem;L->length++;}// 删除指定位置的元素void delete(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("删除位置无效\n");return;}for (int i = pos - 1; i < L->length - 1; i++) {L->data[i] = L->data[i + 1];}L->length--;}// 获取指定位置的元素值int getElement(SeqList *L, int pos) {if (pos < 1 || pos > L->length) {printf("位置无效\n");return -1;}return L->data[pos - 1];}```2. 链表链表是一种利用非连续存储空间存储元素的线性表。

《数据结构(C语言版)》严蔚敏代码实现———链表

《数据结构(C语言版)》严蔚敏代码实现———链表

《数据结构(C语⾔版)》严蔚敏代码实现———链表⼀、前⾔哈喽,⼤家好~我是熊⼦q,我⼜来了!他来了他来了,他带着代码过来了!今天要分享的代码是链表!快快搬着⼩板凳!⼆、代码严奶奶的书中预定义了⼀些预定义常量和类型,⼤家可以 新建⼀个y.h⽂件粘贴以下内容, 然后再去复制代码哦。

y.h⽂件内容:/*** 严奶奶书中的预定义常量和类型**///函数结果状态代码#define TRUE 1 //成功#define FALSE 0 //失败#define OK 1 //成功#define ERROR 0 //错误#define INFEASIBLE -1 //不可实⾏#define OVERFLOW -2 //溢出//Status 是函数的类型,其值是函数结果状态代码typedef int Status;链表LinkList.cpp:#include "y.h"#include <iostream>#include <cstdlib>#include <cstdio>using namespace std;typedef int ElemType;/*** 严奶奶单链表的实现* by 熊⼦q 2021.2.1**/typedef struct LNode{ElemType data;struct LNode *next;}LNode,*LinkList;//获取元素Status GetElem(LinkList L, int i, ElemType &e){//L为带头结点的单链表的头指针//当第i个元素存在时,其值赋给e并返回OK,否则返回ERRORLNode *p = L->next; //p指向第⼀个结点int j = 1; //j为计数器while(p && j<i){ //寻找第i个位置p = p->next;++j;}if(!p || j>i) return ERROR; //第i个元素不存在e = p->data; //否则获取第i个元素return OK;}//插⼊元素,时间复杂度O(n)Status Insert(LinkList &L, int i, ElemType e){//在带头结点的单链表L中第i个位置之前插⼊元素eLNode *p = L;int j = 0;while(p && j<i-1){p = p->next;++j;}if(!p || j>i-1) return ERROR; //i⼩于1或者⼤于表长加1LNode *q = (LNode*)malloc(sizeof(LNode));q->data = e; //插⼊数据q->next = p->next;p->next = q;return OK;}//删除元素,时间复杂度O(n)Status ListDelete(LinkList &L, int i, ElemType e){//在带头结点的单链表L中,删除第i个元素,并由e返回其值LNode *p = L->next;int j = 1;while(p && j<i-1){p = p->next;++j;} //寻找i的前驱元素if(!(p->next) || j>i-1) return ERROR; //删除位置不合理,i元素不存在或 LNode *q = p->next; //删除第i个位置元素,并释放该结点 p->next = q->next;e = q->data;free(q);return OK;}//创建链表void CreateList(LinkList &L, int n){//逆序输⼊n个元素的值,建⽴带头结点的单链表LL = (LinkList)malloc(sizeof(LNode));L->next = NULL; //建⽴⼀个头结点printf("请输⼊数据:\n");for(int i=n;i>0;--i){LNode *p = (LNode*)malloc(sizeof(LNode));scanf("%d",&(p->data));p->next = L->next; L->next = p;}}//合并两个有序链表void MergeList(LinkList &La, LinkList &Lb, LinkList &Lc){//已知单链表La和Lb的元素按值⾮递减排列//归并La和Lb得到新的单链表Lc,Lc的元素也按值⾮递减排列LNode *pa = La->next;LNode *pb = Lb->next;LNode *pc = La; //⽤La的头结点作为Lc的头结点Lc = pc;while(pa && pb){//取⼆者中较⼤值添加到Lc中if(pa->data > pb->data){//先添加该节点为pc的后继元素,然后pc和pa指针都后移pc->next = pa; pc = pc->next; pa = pa->next;}else{pc->next = pb; pc = pc->next; pb = pb->next;}}pc->next = pa? pa: pb; //插⼊剩余段free(Lb); //释放Lb的头结点}//输出单链表void Display(LinkList &L){LNode *p = L->next;printf("单链表的内容为:");while(p){printf("%d",p->data);if(p->next) printf("->");else printf("\n");p = p->next;}}int main(){LinkList l;CreateList(l, 5);Display(l);// printf("在第%d位插⼊%d",1,123);// Insert(l, 1, 123);// Display(l);int tmp;GetElem(l, 2, tmp);printf("%d",tmp);return 0;}三、运⾏截图四、附录如果你想看其他的代码,下⾯有链接哦:。

链表的基本操作代码c语言

链表的基本操作代码c语言

链表的基本操作代码c语言链表是一种常见的数据结构,其基本操作包括创建、插入、删除和遍历等。

以下是链表的基本操作代码(C语言实现):1. 链表节点的定义cCopy codetypedef struct ListNode { int val; // 节点的值struct ListNode *next; // 指向下一个节点的指针 } ListNode;2. 创建链表cCopy codeListNode* createList(int arr[], int n) { ListNode *head = NULL, *tail = NULL; for (int i = 0; i < n; i++) { ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = arr[i]; node->next = NULL; if (tail == NULL) { head = tail = node; } else { tail->next = node; tail = node; } } return head; }3. 插入节点cCopy codevoid insertNode(ListNode **head, int val, int index) { if (index < 0) { return; } ListNode *node = (ListNode *)malloc(sizeof(ListNode)); node->val = val; node->next = NULL; if (index == 0) { node->next = *head; *head = node; } else { ListNode *prev = *head; for (int i = 0; i < index - 1; i++) { if (prev == NULL) { return; } prev = prev->next; }if (prev == NULL) { return; } node->next = prev->next; prev->next = node; } }4. 删除节点cCopy codevoid deleteNode(ListNode **head, int index) { if (*head == NULL || index < 0) { return; } if (index == 0) { ListNode *node = *head; *head = (*head)->next; free(node); } else { ListNode *prev = *head; for (int i = 0; i < index - 1; i++) { if (prev->next == NULL) { return; } prev = prev->next; } if (prev->next == NULL) { return; } ListNode *node = prev->next; prev->next = node->next; free(node); } }5. 遍历链表cCopy codevoid traverseList(ListNode *head) { while (head != NULL) { printf("%d ", head->val); head = head->next; } printf("\n"); }以上是链表的基本操作代码,可以根据需要进行调整和扩展。

十字链表(C语言版本)

十字链表(C语言版本)

⼗字链表(C语⾔版本)内容其实跟以前写的⼀样的,改⼀个C语⾔版本。

#include <stdio.h>#include <stdlib.h>#include <math.h>typedef struct DoubleNode {int roleId;int x;int y;struct DoubleNode* xPrev;struct DoubleNode* xNext;struct DoubleNode* yPrev;struct DoubleNode* yNext;} DoubleNode;typedef struct Scene {DoubleNode* _head;DoubleNode* _tail;} Scene;void _add_node(struct Scene* scene, DoubleNode* node);void _leave_scene(DoubleNode* node);// 初始化场景struct Scene* new_scene();// 进⼊场景DoubleNode* enter_scene(struct Scene* scene, int roleId, int x, int y);// 离开场景void leave_scene(DoubleNode* node);// 场景内移动void role_move(struct Scene* scene, DoubleNode* node, int x, int y);// 获取AOIvoid get_aoi(struct Scene* scene, DoubleNode* node, int xAreaLen, int yAreaLen);// --------------------------------------------------struct Scene* new_scene() {struct Scene* scene = (struct Scene*)malloc(sizeof(struct Scene));DoubleNode* _head = (struct DoubleNode*)malloc(sizeof(struct DoubleNode));DoubleNode* _tail = (struct DoubleNode*)malloc(sizeof(struct DoubleNode));_head->roleId = _head->x = _head->y = 0;_tail->roleId = _tail->x = _tail->y = 0;_head->xPrev = _tail->xNext = NULL;_head->yPrev = _tail->yNext = NULL;_head->xNext = _head->yNext = _tail;_tail->xPrev = _tail->yPrev = _head;scene->_head = _head;scene->_tail = _tail;return scene;}DoubleNode* enter_scene(struct Scene* scene, int roleId, int x, int y) {DoubleNode* node = (DoubleNode*)malloc(sizeof(DoubleNode));node->roleId = roleId;node->x = x;node->y = y;_add_node(scene, node);return node;}void _add_node(struct Scene* scene, DoubleNode* node) {DoubleNode* cur = scene->_head->xNext;while(cur != NULL){if((cur->x > node->x) || cur == scene->_tail) {node->xNext = cur;node->xPrev = cur->xPrev;cur->xPrev->xNext = node;cur->xPrev = node;break;}cur = cur->xNext;}cur = scene->_head->yNext;while(cur != NULL){if((cur->y > node->y) || cur == scene->_tail) {node->yNext = cur;node->yPrev = cur->yPrev;cur->yPrev->yNext = node;cur->yPrev = node;break;}cur = cur->yNext;}}void _leave_scene(DoubleNode* node) {node->xPrev->xNext = node->xNext;node->yPrev->yNext = node->yNext;node->xNext->xPrev = node->xPrev;node->yNext->yPrev = node->yPrev;node->xPrev = node->xNext = NULL;node->yPrev = node->yNext = NULL;}void leave_scene(DoubleNode* node) {_leave_scene(node);free(node);}void print_scene(struct Scene* scene) {DoubleNode* cur = scene->_head->xNext;while(cur != scene->_tail) {printf("%d(%d, %d)\n", cur->roleId, cur->x, cur->y);cur = cur->xNext;}printf("\n");cur = scene->_head->yNext;while(cur != scene->_tail) {printf("%d(%d, %d)\n", cur->roleId, cur->x, cur->y);cur = cur->yNext;}}void role_move(struct Scene* scene, DoubleNode* node, int x, int y) {_leave_scene(node);node->x = x;node->y = y;_add_node(scene, node);}void get_aoi(struct Scene* scene, DoubleNode* node, int xAreaLen, int yAreaLen) { DoubleNode* cur = node->xNext;while(cur != scene->_tail){if(cur->x < node->x + xAreaLen){if(abs(cur->y - node->y) < yAreaLen){printf("aoi = %d(%d, %d)\n", cur->roleId, cur->x, cur->y);}}else{break;}cur = cur->xNext;}cur = node->xPrev;while(cur != scene->_tail){if(node->x < cur->x + xAreaLen){if(abs(cur->y - node->y) < yAreaLen){printf("aoi = %d(%d, %d)\n", cur->roleId, cur->x, cur->y);}}else{break;}cur = cur->xPrev;}}void main() {struct Scene* scene = new_scene();printf("\n== enter_scene == \n");enter_scene(scene, 1001, 1, 5);enter_scene(scene, 1002, 6, 6);enter_scene(scene, 1003, 3, 1);enter_scene(scene, 1004, 2, 2);struct DoubleNode* node1 = enter_scene(scene, 1005, 5, 4); struct DoubleNode* node2 = enter_scene(scene, 1006, 3, 3); print_scene(scene);printf("\n== leave_scene == \n");leave_scene(node1);print_scene(scene);printf("\n== role_move == \n");role_move(scene, node2, 2, 2);print_scene(scene);printf("\n== get_aoi == \n");get_aoi(scene, node2, 2, 2);}。

c 链表使用完整代码

c  链表使用完整代码

C ++ 链表使用完整代码/**//*练习使用链表:创建链表、遍历链表、查找节点、添加节点、删除节点*/#include "stdio.h"#include "string.h"#include "assert.h"#include "stdlib.h"#include "windows.h"#define COUNT 3//定义一个节点结构体struct NODE{unsigned long uID;char strName[16]; //用指针的话会出访问冲突异常NODE *next;};//创建一个具有n个节点的链表,从键盘输入数据将其初始化,并返回链表的首节点指针NODE *createNode(int n){NODE *pHead, //首节点指针*pRear, //尾节点指针*pNew; //新节点指针int i;char *strName = new char[16];for (i=0; i&lt;n; i++)...{pNew = new NODE;do...{printf("请输入ID和名称:");scanf("%d %s",&amp;pNew-&gt;uID, strName);if (strlen(strName) &gt; 16)...{printf("输入名称长度超出范围,请重新输入:");Sleep(1000);}} while(strlen(strName) &gt; 16);strcpy(pNew-&gt;strName, strName); if (0==i)...{pRear = pHead = pNew;}else...{pRear-&gt;next = pNew;}pNew-&gt;next = NULL;pRear = pNew;}delete []strName;return pHead;}//打印链表中所有节点的数据void printNode(NODE *pHead){NODE *pTemp = pHead;assert(pTemp != NULL);while (pTemp != NULL)...{printf("%d %s ",pTemp-&gt;uID,pTemp-&gt;strName);pTemp = pTemp-&gt;next;}}//查询链表中具有指定ID的节点,并返回此节点指针NODE *searchNode(NODE *pHead, unsigned long uID) {NODE *pDest = pHead;assert(pDest != NULL);while (pDest-&gt;next!=NULL &amp;&amp;pDest-&gt;uID!=uID)...{pDest = pDest-&gt;next;}if (pDest-&gt;uID == uID)...{return pDest;}else...{printf("搜索失败,未找到找定ID的节点!");return NULL;}}//删除指定ID的节点NODE *deleteNode(NODE *pHead, unsigned long uID) {NODE *pDest, //要删除的节点*pBefore; //前一个节点pDest = pHead;assert(pDest != NULL);while (pDest-&gt;next!=NULL &amp;&amp; pDest-&gt;uID!=uID)...{pBefore = pDest;pDest = pDest-&gt;next;}if (pDest-&gt;uID == uID)...{if (pDest == pHead)...{pHead = pDest-&gt;next;}else...{pBefore-&gt;next = pDest-&gt;next;}free(pDest);printf("节点已被删除!");}else...{printf("未找到指定节点,无法将其删除!");}return pHead;}//在指定ID的节点后插入一个新的节点NODE *insertNode(NODE *pHead, unsigned long uID) {NODE *pDest, *pNew;pDest = pHead;assert(pDest != NULL);while(pDest-&gt;next!=NULL &amp;&amp;pDest-&gt;uID!=uID)...{pDest = pDest-&gt;next;}if(pDest-&gt;uID == uID)...{pNew = new NODE;printf("请输入新节点的ID和名称:");scanf("%d %s",&amp;pNew-&gt;uID,pNew-&gt;strName);pNew-&gt;next = pDest-&gt;next;pDest-&gt;next = pNew;printf("节点插入完成!");}else...{printf("未找到指定节点!");}return pHead;}void main(){NODE *pHead, *pDest;int nSelect;bool isExit = false;unsigned long uID;printf("请根据提示输入数据初始化链表:");pHead = createNode(COUNT);assert(pHead != NULL);printf("链表创建成功!存储数据如下:");printNode(pHead);while (!isExit)...{printf("-------------------------- ");printf("请选择要进行的操作:");printf("1.打印出链表所有节点数据:");printf("2.输入ID查询名称。

c语言链表的创建方法

c语言链表的创建方法

c语言链表的创建方法在C语言中,链表是一种常见的数据结构,它由一系列节点组成,每个节点包含一个值和一个指向下一个节点的指针。

链表可以动态地添加或删除节点,因此在许多应用程序中被广泛使用。

链表的创建方法大致可以分为以下几个步骤:1. 定义一个节点结构体链表的节点通常包含一个值和一个指针,指针指向下一个节点。

因此,我们需要定义一个结构体来表示节点:```struct Node {int data;struct Node* next;};```其中,`data`表示节点的值,`next`表示指向下一个节点的指针。

2. 创建第一个节点创建第一个节点时,我们需要先分配一段内存,然后将节点的值和指针都赋值为NULL:```struct Node* head = NULL;head = (struct Node*)malloc(sizeof(struct Node));head->data = 1;head->next = NULL;```这里我们使用了`malloc`函数来分配内存,并将返回的指针强制转换为`struct Node*`类型,然后将节点的值和指针赋值为1和NULL。

3. 添加新节点添加新节点时,我们需要先找到链表的末尾,然后在末尾添加新节点:```struct Node* newNode = NULL;newNode = (struct Node*)malloc(sizeof(struct Node));newNode->data = 2;newNode->next = NULL;struct Node* current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;```这里我们定义了一个新节点`newNode`,然后遍历链表找到末尾节点,将末尾节点的指针指向新节点。

代码实现链式队列,输入数字入队,输入字符出队(c语言)

代码实现链式队列,输入数字入队,输入字符出队(c语言)

以下是使用C语言实现链式队列的代码,可以实现输入数字入队,输入字符出队的功能:#include <stdio.h>#include <stdlib.h>#include <string.h>// 定义链式队列结构体typedef struct QueueNode {int data; // 存储数字struct QueueNode* next; // 指向下一个节点} QueueNode;// 定义链式队列结构体typedef struct {QueueNode* front; // 指向队头节点QueueNode* rear; // 指向队尾节点} LinkedQueue;// 初始化链式队列void InitQueue(LinkedQueue* queue) {queue->front = NULL;queue->rear = NULL;}// 入队操作void EnQueue(LinkedQueue* queue, int data) {QueueNode* newNode =(QueueNode*)malloc(sizeof(QueueNode)); // 创建新节点newNode->data = data; // 将数字存储到新节点中newNode->next = NULL; // 新节点的下一个节点为空if (queue->rear == NULL) { // 如果队列为空,将新节点设置为队头和队尾queue->front = newNode;queue->rear = newNode;} else { // 如果队列不为空,将新节点添加到队尾,并更新队尾指针queue->rear->next = newNode;queue->rear = newNode;}}// 出队操作,返回出队的字符,如果队列为空,返回-1char DeQueue(LinkedQueue* queue) {if (queue->front == NULL) { // 如果队列为空,返回-1表示失败return -1;} else { // 如果队列不为空,将队头节点从队列中删除,并返回其存储的字符,同时更新队头指针char data = queue->front->data;QueueNode* temp = queue->front;queue->front = queue->front->next;free(temp); // 释放已删除节点的内存空间return data;}}。

数据结构c语言版创建单链表的代码

数据结构c语言版创建单链表的代码

数据结构c语言版创建单链表的代码单链表作为常用的线性结构之一,常常用于解决以链式方式存储数据的问题。

创建单链表需要掌握一些基础的数据结构知识以及对C语言的熟练运用。

接下来,本文将分步骤地阐述数据结构C语言版创建单链表的代码。

第一步,定义单链表结构体并定义节点类型。

在C语言中,我们可以通过结构体的方式定义单链表,其中结构体中包含两个成员变量,分别为存储数据的data和指向下一个节点的指针next。

对于节点类型,我们可以使用typedef对节点类型进行定义,例如:```struct ListNode {int data;struct ListNode *next;};typedef struct ListNode ListNode;```在以上代码中,我们首先定义了一个结构体ListNode作为单链表的元素类型,其中包含存储数据的data和指向下一个元素的指针next。

接着我们使用typedef将结构体ListNode定义为仿函数ListNode,从而使其更加方便使用。

第二步,初始化单链表。

在创建单链表之前,我们需要先将单链表的头指针初始化为NULL,表示当前链表为空。

具体代码如下:```ListNode *createLinkedList() {ListNode *head = NULL;return head;}```以上代码中,函数createLinkedList用于创建并初始化单链表,其中head表示单链表头指针,我们将其初始化为NULL。

第三步,向单链表中添加元素。

在单链表中添加元素需要借助于指针的指向关系。

具体来说,我们需要先创建新的节点,将其数据添加到节点中,然后将新节点的next指针指向之前的头节点,最后将头指针指向新节点。

具体过程如下:```ListNode *addListNode(ListNode **head, int val) {ListNode *newNode = (ListNode *)malloc(sizeof(ListNode)); newNode->data = val;newNode->next = *head;*head = newNode;return *head;}```在以上代码中,函数addListNode接收一个指向头指针的指针head,以及需要添加的元素值val。

c语言单链表尾插法

c语言单链表尾插法

C语言单链表尾插法1. 简介单链表是一种常用的数据结构,它由一系列节点组成,每个节点包含数据和指向下一个节点的指针。

单链表尾插法是一种在链表尾部插入新节点的方法,通过将新节点插入到链表尾部,可以方便地实现链表的动态扩展和插入操作。

本文将详细介绍C语言中单链表尾插法的实现方法,包括链表结构的定义、节点的插入操作、遍历和释放链表等。

2. 链表结构定义在C语言中,我们可以通过结构体来定义链表的节点。

每个节点包含两个部分:数据域和指针域。

typedef struct Node {int data; // 数据域struct Node* next; // 指针域,指向下一个节点} Node;在上述代码中,我们定义了一个名为Node的结构体,其中data表示节点的数据,next表示指向下一个节点的指针。

通过typedef关键字,我们将struct Node重命名为Node,方便后续使用。

3. 节点的插入操作3.1 创建新节点在进行节点的插入操作之前,我们需要先创建一个新的节点。

可以通过动态内存分配函数malloc来分配内存,并使用free函数释放内存。

Node* createNode(int data) {Node* newNode = (Node*)malloc(sizeof(Node));if (newNode == NULL) {printf("内存分配失败\n");exit(1);}newNode->data = data;newNode->next = NULL;return newNode;}上述代码中,我们定义了一个名为createNode的函数,该函数接受一个整数参数data,用于初始化新节点的数据域。

首先使用malloc函数分配内存,并将返回的指针强制转换为Node*类型。

然后,我们检查内存分配是否成功,如果失败,则打印错误信息并调用exit函数退出程序。

接着,我们将新节点的数据域设置为传入的data值,指针域设置为NULL,最后返回新节点的指针。

C语言的循环链表和约瑟夫环

C语言的循环链表和约瑟夫环

C语言的循环链表和约瑟夫环C语言的循环链表和约瑟夫环约瑟夫问题)是一个数学的应用问题,对于学习C语言四非常挺有帮助的,下面是店铺为大家搜集整理出来的有关于C语言的循环链表和约瑟夫环,一起了解下吧!循环链表的实现单链表只有向后结点,当单链表的尾链表不指向NULL,而是指向头结点时候,形成了一个环,成为单循环链表,简称循环链表。

当它是空表,向后结点就只想了自己,这也是它与单链表的主要差异,判断node->next是否等于head。

代码实现分为四部分:1. 初始化2. 插入3. 删除4. 定位寻找代码实现:1 2 3 4 5 6 7 8 9 1 0 1 1 1 2 1 3 1void ListInit(Node *pNode){int item;Node *temp,*target;cout<<"输入0完成初始化"<<endl; cin="">>item;if(!item)return ;if(!(pNode)){ //当空表的时候,head==NULLpNode = new Node ;if(!(pNode))exit(0);//未成功申请pNode->data = item;pNode->next = pNode;}else{//for(target = pNode;target->next!=pNode;target = target->next);4 15 16 17 18 19 2 0 2 1 2 2 2 3 2 4 2 5 2 6 2 7 2 8 2 9 3 0 3 1 3 2 3 3 3 4 3 5 3temp = new Node;if(!(temp))exit(0);temp->data = item;temp->next = pNode;target->next = temp;}}}void ListInsert(Node *pNode,int i){ //参数是首节点和插入位置Node *temp;Node *target;int item;cout<<"输入您要插入的值:"<<endl; cin="">>item;if(i==1){temp = new Node;if(!temp)exit(0);temp->data = item;for(target=pNode;target->next != pNode;target = target->next);temp->next = pNode;target->next = temp;pNode = temp;}else{target = pNode;for (int j=1;j<i-1;++j) target="target-">next;temp = new Node;if(!temp)exit(0);temp->data = item;temp->next = target->next;target->next = temp;}}void ListDelete(Node *pNode,int i){Node *target,*temp;if(i==1){for(target=pNode;target->next!=pNode;target=target ->next);temp = pNode;//保存一下要删除的首节点 ,一会便于释放6 37 38 39 4 0 4 1 4 2 4 3 4 4 4 5 4 6 4 7 4 8 4 9 5 0 5 1 5 2 5 3 5 4 5 5 5 6 5 7 5pNode = pNode->next;target->next = pNode;temp;}else{target = pNode;for(int j=1;j<i-1;++j) target="target-">next;temp = target->next;//要释放的nodetarget->next = target->next->next;temp;}}int ListSearch(Node *pNode,int elem){ //查询并返回结点所在的位置Node *target;int i=1;for(target = pNode;target->data!=elem && target->next!= pNode;++i)target = target->next;if(target->next == pNode && target->data!=elem)return 0;else return i;}</i-1;++j)></i-1;++j)></endl;></endl;>5 96 0 6 1 6 2 6 3 6 4 6 5 6 6 67 68 69 7 0 7 1 7 2 7 3 7 4 7 5 7 6 7 7 7 8 7 9 8约瑟夫问题约瑟夫环(约瑟夫问题)是一个数学的'应用问题:已知n个人(以编号1,2,3…n分别表示)围坐在一张圆桌周围。

c语言链表指针编程题

c语言链表指针编程题

以下是一个使用链表和指针的 C 语言编程题:题目:将一个无序整数数组按照升序排列,并存储在链表中。

要求:1.定义一个链表节点结构体,包含一个整数和一个指向下一个节点的指针。

2.实现一个函数,将无序整数数组按照升序排列,并将结果存储在链表中。

3.实现一个函数,遍历链表并输出每个节点的值。

示例:输入:复制代码无序整数数组:[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]输出:复制代码链表节点值:[1, 1, 2, 3, 3, 4, 5, 5, 5, 6, 9]以下是一个可能的实现:c复制代码#include<stdio.h>#include<stdlib.h>// 定义链表节点结构体typedef struct Node {int value;struct Node* next;} Node;// 插入节点到链表尾部Node* insertNode(Node* head, int value) {Node* newNode = (Node*)malloc(sizeof(Node));newNode->value = value;newNode->next = NULL;if (head == NULL) {head = newNode;} else {Node* current = head;while (current->next != NULL) {current = current->next;}current->next = newNode;}return head;}// 将无序整数数组按照升序排列,并将结果存储在链表中Node* sortAndBuildList(int arr[], int n) {Node* head = NULL; // 头节点指针,初始为空for (int i = 0; i < n; i++) { // 将数组元素插入链表尾部head = insertNode(head, arr[i]);}// 对链表进行排序(可以使用快速排序、归并排序等算法)// 这里简单起见,只使用了冒泡排序算法进行排序,实际应用中应使用更高效的排序算法。

C语言数据结构实现链表逆序并输出

C语言数据结构实现链表逆序并输出

C语言数据结构实现链表逆序并输出c语言数据结构实现链表逆序并输出实例代码:头文件:#include<stdio. h>ftinclude<stdlib. h> #include<malloc・ h> typedefintElemType; typedefstructNode{//结点结构ElemTypevalue; //值域structNode*next; //指针域}Node, *ptr_Node;typedefstructLinkList{//链表结构ptr_Nodehead;//链表头结点指针ptr_Nodetail;//链表尾结点指针intlength;//链表长度}LinkList, *ptr_LinkList; ptr_LinkLi stCreateList(void) {//创建一个空琏表ptr_LinkListlinklist;linklist=(LinkList*)malloc(sizeof(LinkList));if (!linklist){printf("allocationfailed. \n");linklist-〉head二NULL;linklist->tail=XULL;linklist->length=O;returnlinklist;}boolIsListEmpty(ptr_LinkListlinklist){//判断链表是否为空if(linklist->length==0){returntrue;}returnfalse;}voidlnsertListHead(ptr_LinkListlinklist, ElemTypeelement) {//在表头插入值为element的结点作为新的表头ptr_Nodeptr_node;ptr_node= (Node*)malloc(sizeof (Node)) ;//生成插入结点if (!p t:r_node) printf(^allocationfailed. \n");}elseptr_node~>value=element;if (linklist->length==0){linklist-〉head二ptr_node;linklist->tail=linklist~>head;1inklisl->next=NULL;}else{ptr_node~>next=linklist~>head;1 inklist->head=p tr_node; / / 链表头}linklist->length++;//^ 表长度加 1}} voidlnsertListTail(ptr_LinkListlinklist, ElemTypeelement) ptr_Nodeptr_node;ptr_node= (Node*)malloc(sizeof (Node)) ;//生成插入结点if(!ptr_node){printf("allocationfailed. \n");}else{ptr_node->value=element;if (linklis t - >length=0){linklist一>head二ptr_node;linklist->tail=linklist一>head;1 inklist->tail->next=NULL;}else{1 inklist->tail~>next=ptr_node;linklist->ta 订二ptr_node; // 链表尾}linklist->length++;// 链表长度加 1}}voidlnsertListPosition(pt:r_LinkListlinklist, intpos, ElemT ypeelement){inti;ptr_Nodeptr_node;ptr_Nodetemp_ptr_node;if(pos<l :pos>linklist->length){printf ("Theinsertpositionisinvalidate・ \n〃);}else{ptr_node= (Node*)malloc(sizeof (Node)) ;//生成插入结点if(!ptr_node){printf(^allocationfailed. \n");}ptr_node->value=element;if (pos==l)InsertListHead(linklist, element);}elseif(pos==linklist->length)InsertListTail(linklist,element);}else{temp_ptr_node=linklist->head;for (i=l;i<pos-l;i++){//找到第posT个结点temp_ptr_node二temp_pt:r_node->next;}ptr_node->next二temp_ptr_node->next; temp_ptr_node->next二ptr_node; linklist->length++;}}}voidDestroy(ptr_LinkListlinklist) {//销毁链表ptr_Nodep=linklist->head; ptr_Nodeq;while(p){//释放每个结点空间q=p->next;free (p);p二NULL;P 二q;}}voidTraverse(ptr_LinkListlinklist){//输出整个链表ptr_Nodep;p二linklist-〉head;while(p){printf("%4d", p->value);p=p->next;}}头文件中实现了链表的几个基本的操作,有的是必须的,有些是非必须的。

单链表存储结构c语言

单链表存储结构c语言

单链表存储结构c语言单链表是一种常见的数据结构,它由节点组成,每个节点包含数据和指向下一个节点的指针。

在C语言中,可以使用结构体来表示单链表的节点,然后通过指针来连接这些节点。

首先,我们需要定义单链表节点的结构体。

这个结构体包含两部分,数据部分和指针部分。

数据部分可以是任何我们想要存储的数据类型,指针部分用来指向下一个节点。

c.struct Node {。

int data; // 以整数为例,实际可以是任何数据类型。

struct Node next; // 指向下一个节点的指针。

};接下来,我们可以编写一些操作单链表的函数,比如创建节点、插入节点、删除节点等。

以下是一些常用的单链表操作函数的示例:1. 创建节点函数。

c.struct Node createNode(int data) {。

struct Node newNode = (structNode)malloc(sizeof(struct Node));newNode->data = data;newNode->next = NULL;return newNode;}。

2. 插入节点函数。

c.void insertNode(struct Node head, int data) {。

struct Node newNode = createNode(data);struct Node temp = head;while (temp->next != NULL) {。

temp = temp->next;}。

temp->next = newNode;}。

3. 删除节点函数。

c.void deleteNode(struct Node head, int data) {。

struct Node temp = head;struct Node prev = NULL;while (temp != NULL && temp->data != data) {。

c语言单链表程序代码

c语言单链表程序代码

c语言单链表程序代码C语言单链表程序代码单链表是一种常见的数据结构,它由多个节点组成,每个节点包含一个数据域和一个指向下一个节点的指针。

以下是C语言实现单链表的程序代码:1. 定义节点结构体首先需要定义一个节点结构体,用来存储每个节点的数据和指针信息。

```typedef struct node {int data; // 数据域struct node *next; // 指向下一个节点的指针} Node;```2. 创建链表头节点创建一个头节点,它不存储任何数据,只是作为链表的起始点。

```Node *head = NULL;head = (Node*)malloc(sizeof(Node));head->next = NULL;```3. 插入新节点插入新节点时需要先创建一个新的节点,并将其插入到链表中合适的位置。

```Node *new_node = NULL;new_node = (Node*)malloc(sizeof(Node));new_node->data = new_data;// 找到插入位置Node *current = head;while (current->next != NULL && current->next->data < new_data) {current = current->next;}// 插入新节点new_node->next = current->next;current->next = new_node;```4. 删除指定数据的节点删除指定数据的节点时需要先找到该节点,并将其从链表中删除。

```// 找到要删除的节点Node *current = head;while (current->next != NULL && current->next->data != data) {current = current->next;}// 删除节点if (current->next != NULL) {Node *del_node = current->next;current->next = del_node->next;free(del_node);```5. 遍历链表遍历链表时需要从头节点开始,依次访问每个节点的数据。

双链表的初始化c语言

双链表的初始化c语言

双链表的初始化c语言
在C语言中,双链表的初始化通常涉及创建一个头节点并将其指针设置为NULL。

以下是双链表的初始化过程:
首先,我们需要定义双链表的节点结构。

节点结构通常包括数据域和两个指针域,分别指向前驱节点和后继节点。

定义节点结构的代码如下所示:
c.
struct Node {。

int data;
struct Node prev;
struct Node next;
};
接下来,我们需要编写初始化双链表的函数。

该函数将创建一个头节点并将其指针设置为NULL。

代码如下所示:
c.
void initializeList(struct Node head) {。

head = NULL; // 将头指针设置为NULL.
}。

在主函数中,我们可以调用initializeList函数来初始化双链表。

示例代码如下:
c.
int main() {。

struct Node head;
initializeList(&head); // 初始化双链表。

// 其他操作...
return 0;
}。

通过以上步骤,我们成功地初始化了一个双链表。

在实际应用中,我们可以根据需要进一步扩展双链表的功能,例如插入节点、删除节点等操作。

希望这些信息能够帮助到你。

c语言链表定义

c语言链表定义

c语言链表定义链表是一种非常基础的数据结构,它的定义可以用多种编程语言来实现,其中最为常见的就是C语言。

本文将着重介绍C语言的链表定义。

第一步:首先,我们需要定义一个链表节点的结构体,用来存储链表中每个节点的数据信息以及指向下一个节点的指针。

具体代码如下所示:```struct ListNode {int val;struct ListNode *next;};```在这个结构体中,我们定义了两个成员变量,一个是表示节点值的val,一个是表示指向下一个节点的指针next。

其中,节点值可以是任意类型的数据,而指针next则是一个指向结构体类型的指针。

第二步:我们需要定义链表的头节点,通常会将头节点的指针定义为一个全局变量,方便在程序的不同部分中都能够访问。

这个头节点的作用是指向链表的第一个节点,同时也充当了哨兵节点的作用,使得链表的操作更加方便。

具体代码如下所示:```struct ListNode *list_head = NULL;```在这个全局变量中,我们定义了一个指向链表头节点的指针list_head,并将它初始化为NULL,表示目前链表为空。

第三步:链表的基本操作主要包括创建、插入、删除和遍历等。

我们将逐一介绍它们的定义方法。

1. 创建链表创建链表时,我们需要动态地分配内存,以保证每个节点的空间都是连续的而不会被覆盖。

具体代码如下所示:```struct ListNode *create_list(int arr[], int n) {struct ListNode *head = NULL, *tail = NULL;for (int i = 0; i < n; i++) {struct ListNode *node = (struct ListNode*)malloc(sizeof(struct ListNode));node->val = arr[i];node->next = NULL;if (head == NULL) {head = node;tail = node;} else {tail->next = node;tail = node;}}return head;}```在这个代码中,我们首先定义了链表的头节点head和尾节点tail,并将它们初始化为空。

c语言-链表-头插法代码例子

c语言-链表-头插法代码例子

c语⾔-链表-头插法代码例⼦1 #include <stdio.h>2 #include <stdlib.h>34struct Book5 {6char title [128];7char author [40];8struct Book *next;9 };1011void getInput(struct Book *book)12 {13 printf("请输⼊书名:");14 scanf("%s",book->title);15 printf("请输⼊作者:");16 scanf("%s",book->author);17//book->next = NULL;18 }19202122//因为返回值是void类型的所以要修改头指针指向的地址,就要传⼊头指针的地址23void addBook(struct Book **plibrary)24 {25struct Book *book,*temp;26 book = (struct Book *)malloc(sizeof(struct Book));27if(book ==NULL)28 {29 printf("动态申请内存失败");30 exit(1);31 }3233 getInput(book);34if(*plibrary!=NULL)35 {3637//这⾥是尾插法38 temp= *library;39//定位单链表的尾部位置40while(temp->next!=NULL)41 {42 temp = temp->next;43 }44//插⼊数据45 temp->next = book;46 book->next = NULL;4748/*这⾥是头插法49 temp = *plibrary;50 *plibrary = book;51 book->next = temp;*/5253 }54else55 {56 *plibrary = book;57 book->next = NULL;5859 }60 book->next = NULL;61 }62void printLibrary(struct Book *library)63 {64struct Book *book;65int count = 1;66 book = library;67while(book!=null)68 {69 printf("Book%d:",cout);70 printf("书名:",book->title);71 printf("作者",author);72 count++;73 book = book->next;7475 }76 }77void releaseLibrary(struct Book *library)78 {79while(library!=NULL)80 {81free(library);82 library = library->next;83//要先取到next 再清空84 }85 }86int main(void)87 {88struct Book *library = NULL;89int ch;9091while(1)92 {93 printf("请问是否需要录⼊书籍信息 (Y/N):"); 94do95 {96 ch=getchar();97 }while(ch!='Y'&&ch!='N');98if(ch =='Y')99 {100 addBook(&library);101 }102else103 {104break;105 }106 }107 printf("请问是否需要打印图书馆信息(Y/N):"); 108do109 {110 ch=getchar();111 }while(ch!='Y'&&ch!='N');112if(ch =='Y')113 {114 printLibrary(library);115 }116 reaseLibrary(library);117118119return0;120 }。

C语言链表详解及代码分析

C语言链表详解及代码分析

C语⾔链表详解及代码分析⽬录什么是链表环境构建建⽴静态链表包含所需要的头⽂件宏定义相关变量创建⼀个结构体主函数结果展⽰说明建⽴动态链表包含所需要的头⽂件宏定义相关变量创建⼀个结构体建⽴链表函数主函数结果展⽰链表的输出输出函数主函数链表的修改主函数删除函数主函数输出结果插⼊函数主函数结果显⽰出现的问题什么是链表链表是⼀种常见的重要的数据结构。

它是动态地进⾏存储分配的⼀种结构。

链表和数组⽐较,不⽤事先确定存储空间,⽽是根据需要开辟内存单元。

下图1是最简单的⼀种链表(单向链表)的结构第 0 个结点称为头结点,它存放有第⼀个结点的⾸地址,它没有数据,只是⼀个指针变量。

以下的每个结点都分为两个域,⼀个是数据域,存放各种实际的数据,如学号 num,姓名name,性别 sex 和成绩 score 等。

另⼀个域为指针域,存放下⼀结点的⾸地址。

链表中的每⼀个结点都是同⼀种结构类型。

环境构建⽤的Visual Studio 2019软件在源⽂件中添加C⽂件建⽴静态链表包含所需要的头⽂件#include<stdio.h> //标准输⼊输出头⽂件#include<stdlib.h>//包含了C、C++语⾔的最常⽤的系统函数宏定义相关变量#define LEN sizeof(struct Student)//宏定义节点长度得命名#define TYPE struct Student//宏定义结构体变量命名创建⼀个结构体struct Student//定义⼀个学⽣类型结构体,包括学号,分数{long num;float score;struct Student* next;//next是指针变量,指向结构体变量};//指向结构体对象得指针变量既可以指向结构体变量,也可以指向结构体数组中得元素主函数int main(){TYPE* head,*p;//定义头指针struct Student a,b,c;//定义三个结构体变量a.num = 101; a.score = 20;//分别对三个结点赋值b.num = 102; b.score = 20;c.num = 103; c.score = 20;/*1、A.B则A为对象或者结构体2、A->B则A为指针,->是成员提取,A->B是提取A中的成员B,A只能是指向类、结构、联合的指针;*/head = &a;a.next = &b;b.next = &c;c.next = NULL;p = head;//把⾸地址给变量do{printf("%ld %5.1f\n",p->num,p->score);//输出每个结点信息p = p->next;//使P指向下⼀个结点} while (p != NULL);//直到指针域指向空值return 0;}结果展⽰说明将第⼀个结点的起始地址赋值给头指针head,将第⼆个结点的起始地址赋值给第⼀个结点的next成员,将第⼆个结点的起始地址赋给第⼀个结点的next…第三个结点的next赋值为NULL,这就形成了简单的链表。

数据结构C语言实现----销毁链表

数据结构C语言实现----销毁链表

数据结构C语⾔实现----销毁链表1.⾸先,将*list(头指针)赋值给p,这样p也指向链表的第⼀个结点,成为链表的表头2.然后判断只要p不为空,就将p指向下⼀个的指针赋值给q,再释放掉p3.之后再将q赋值给p,⽤来找到下⼀轮释放掉的结点的下⼀个结点代码如下:#include<stdio.h>#include<stdlib.h>typedef struct Node{char date;struct Node *next;}Node , *LinkList;//创建链表LinkList creat_linklist(int n){LinkList New_node,Tail_node;LinkList Head_node = NULL;char c;for (size_t i = 0; i < n; i++){printf("请输⼊在第%d个结点存⼊的数据:",i+1);scanf("%c",&c);fflush(stdin);New_node = (LinkList)malloc( sizeof(Node) );New_node->date = c;New_node->next = NULL;if (Head_node == NULL){Head_node = New_node;}else{Tail_node->next = New_node;}Tail_node = New_node;}return Head_node;}//销毁链表void destoryLinkList(LinkList *List){LinkList p,q;p = *List;while (p){q = p->next;free(p);p = q;}*List = NULL;}int main(){int n;char c;LinkList List , List2;//List⽤于第⼀次打印单链表,List2⽤于第⼆次打印单链表printf("请输⼊结点个数:");scanf("%d",&n);fflush(stdin);List = creat_linklist(n);List2 = List;//复制⼀遍链表,第⼀次打印链表后链表后头指针会直接指向NULL,导致第⼆次打印失败printf("打印单链表:");while ( List != NULL ){printf("%c" , List->date);List = List->next;}putchar('\n');printf("即将销毁链表,请按任意键确认!");getchar();destoryLinkList(&List2);if (List2 == NULL){printf("链表已被销毁!");}else{while ( List2 != NULL ){printf("%c" , List2->date); List2 = List2->next;}}return 0;}运⾏结果:。

实现链表的完整代码

实现链表的完整代码

实现链表的完整代码# 这个只是next来赋值变量给另外⼀个,有点复杂,头晕,变量太多了class Node:'''单向链表的节点包含两部分,⼀部分是存放数据的变量data另⼀部分是指向下⼀个节点的指针next'''def __init__(self,data):'''只有头节点,next指针为空'''self.data = dataself.next = None# ⽽双向链表除了拥有data和next指针外# 还拥有指向前置节点的prev指针# a = Node(1)# print(a)# print(a.next)# print(a.data)class LinkedList:'''链表的第⼀个节点称为头节点最后⼀个节点称为尾节点尾节点的next指针指向空链表寻找元素,只能根据前⼀个节点的next指针指向后⼀个节点'''def __init__(self):self.size = 0self.head = Nonest = Nonedef get(self,index): # O(n)if index < 0 or index >= self.size: # 链表这⾥为啥要等于呢raise Exception("超出链表节点范围!")p = self.headfor i in range(index): # 链表中节点的查询操作要从头节点开始,⼀个⼀个next指针查下去p = p.nextreturn pdef insert(self,data,index): #O(1)'''只要执⾏插⼊操作,self.size加⼀'''if index < 0 or index > self.size:raise Exception('超出链表节点范围!')node = Node(data) # 这⾥的node具有头节点和next指针,头节点就是data数据,next为空if self.size == 0:# 空链表self.head = node # 新插⼊的节点为头节点st = node # 新插⼊的节点为尾节点elif index == 0:# 插⼊头部node.next = self.head # 对称交叉互换;把新节点的next指针指向原先的头节点;后⾯链接前⾯self.head = node # 把新节点变为链表的头节点elif self.size == index:# 插⼊尾部st.next = node # 最后⼀个节点的next指针指向新插⼊的节点;后⾯链接前⾯st = node # 新插⼊的节点等于最后⼀个节点else:# 插⼊中间prev_node = self.get(index-1)# 两个next指针相等为啥;后⾯链接前⾯,也就是data连接nextnode.next = prev_node.next # prev_node原本后⾯的data元素指向node的next指针prev_node.next = node #插⼊位置前置节点的next指针指向新节点self.size += 1def remove(self,index):# O(1)'''只要执⾏删除操作,self.size减1'''if index < 0 or index >= self.size:raise Exception('超出链表节点范围!')# 暂存被删除的节点,⽤于返回if index == 0:# 删除头节点remove_node = self.headself.head = self.head.next # 把第⼆个节点设置为头节点if self.size == 1:st == Nodeelif index == self.size - 1:# 删除尾节点prev_node = self.get(index-1)# remove_node = prev_noderemove_node = self.get(index) # 这才是要指定要删除的节点prev_node.next = None # 倒数第⼆个节点指向空,也就是Nonest = prev_node # 最后⼀个节点设置为到数第⼆个节点else:# 删除中间节点prev_node = self.get(index-1)next_node = prev_node.next.next # 把要删除的前置节点的后2位节点数据找到remove_node = prev_node.next # 前置节点的后⼀位节点解释要删除的节点prev_node.next = next_node # 前置节点的后2位节点等于前置节点的next指针;也可以说前置节点的next指针指向后2位节点的数据 self.size -= 1# print(remove_node)return remove_node # remove_node打印出来是这个<__main__.Node object at 0x000002B1C6389438>def output(self): # 难道是由于链表只能⼀个⼀个next输出;还是从头节点开始⼀个⼀个输出出来p = self.headwhile p is not None:print(p.data)p = p.nextlinkedList = LinkedList()linkedList.insert(3,0)linkedList.insert(4,0)linkedList.insert(9,2)linkedList.insert(5,3)linkedList.insert(6,1)print(linkedList.remove(1)) # remove删除的具体值打印不出来print('---------------')linkedList.output()。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
ListInsert(L,1,b[i]);
}
InitList(L1);
for (i=0;i<5;i++)
{
ListInsert(L1,i+1,b[i]);
}
CreateListF(L2,b,5);
CreateListR(L3,b,5);
printf("L:");
return(i);
}
void DispList(LinkList *L)
{
LinkList *p=L->next;
while (p!=NULL)
{ printf("%c ",p->data);
p=p->next;
}
printf("\n");
}
int GetElem(LinkList *L,int i,ElemType &e)
void CreateListF(LinkList *&L,ElemType a[],int n)
//头插法建立单链表
{
LinkList *s;int i;
L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
L->next=NULL;
for (i=0;i<n;i++)
return 1;
}
}
void main()
{
LinkList *L,*L1,*L2,*L3,*L4;
ElemType b[]={'a','b','c','d','e'};
ElemType e;
int i;
InitList(L);
for (i=0;i<5;i++)
{
return 0;
else //找到位序为i-1的结点*p
{ q=p->next; //q指向要删除的结点
if (q==NULL) return 0; //若不存在第i个结点,返回0
e=q->data;
p->next=q->next; //从单链表中删除*q结点
free(q); //释放*q结点
{
int j=0;
LinkList *p=L;
while (j<i && p!=NULL)
{ j++;
p=p->next;
}
if (p==NULL) //不存在第i个数据结点
return 0;
else //存在第i个数据结点
{ e=p->data;
return 1;
}
}
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
s->data=a[i];
s->next=L->next; //将*s插在原开始结点之前,头结点之后
L->next=s;
}
}
void CreateListR(LinkList *&L,ElemType a[],int n)
return 0;
else //找到位序为i-1的结点*p
{ s=(LinkList *)malloc(sizeof(LinkList));//创建新结点*s
s->data=e;
s->next=p->next; //将*s插入到*p之后
p->next=s;
return 1;
}
}
DestroyList(L);
for (i=0;i<5;i++)
{
ListDelete(L2,1,e);
printf("L2中删除的元素是: %c\n")
{
printf("L2是空表\n");
}
else
{
printf("L2不是空表\n");
s->data=a[i];
r->next=s; //将*s插入*r之后
r=s;
}
r->next=NULL; //终端结点next域置为NULL
}
void InitList(LinkList *&L)
{
L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
}
}
int LocateElem(LinkList *L,ElemType e)
{
LinkList *p=L->next;
int n=1;
while (p!=NULL && p->data!=e)
{ p=p->next;
n++;
}
if (p==NULL)
return(0);
else
printf("删除后的L:");
DispList(L);
printf("Length of L:%d\n",ListLength(L));
GetElem(L,3,e);
printf("L中的第三个元素为%c\n",e);
i=LocateElem(L,e);
printf("e元素在L中的位置为%d\n",i);
#include <stdio.h>
#include <malloc.h>
typedef char ElemType;
typedef struct LNode //定义单链表结点类型
{
ElemType data;
struct LNode *next; //指向后继结点
} LinkList;
//尾插法建立单链表
{
LinkList *s,*r;int i;
L=(LinkList *)malloc(sizeof(LinkList)); //创建头结点
L->next=NULL;
r=L; //r始终指向终端结点,开始时指向头结点
for (i=0;i<n;i++)
{
s=(LinkList *)malloc(sizeof(LinkList));//创建新结点
L->next=NULL;
}
void DestroyList(LinkList *&L)
{
LinkList *p=L,*q=p->next;
while (q!=NULL)
{ free(p);
p=q;
q=p->next;
}
free(p); //此时q为NULL,p指向尾结点,释放它
DispList(L);
printf("L1:");
DispList(L1);
printf("L2:");
DispList(L2);
printf("L3:");
DispList(L3);
L4=L;
ListDelete(L,2,e);
printf("L中删除第二个元素是: %c\n",e);
return(n);
}
int ListInsert(LinkList *&L,int i,ElemType e)
{
int j=0;
LinkList *p=L,*s;
while (j<i-1 && p!=NULL) //查找第i-1个结点
{ j++;
p=p->next;
}
if (p==NULL) //未找到位序为i-1的结点
}
int ListEmpty(LinkList *L)
{
return(L->next==NULL);
}
int ListLength(LinkList *L)
{
LinkList *p=L;int i=0;
while (p->next!=NULL)
{ i++;
p=p->next;
}
int ListDelete(LinkList *&L,int i,ElemType &e)
{
int j=0;
LinkList *p=L,*q;
while (j<i-1 && p!=NULL) //查找第i-1个结点
{ j++;
p=p->next;
}
if (p==NULL) //未找到位序为i-1的结点
相关文档
最新文档