数据结构及单链表例题(下)

上次我们已经了解了单链表的数据结构定义以及创建单链表的两种方法,这节介绍几道例题.

文章目录

前言

一、已知L为带头结点的单链表,请依照递归思想实现下列运算

二、单链表访问第i个数据节点

三、在第i个元素前插入元素e

四、删除第i个结点

五、查找带头结点单链表倒数第m个结点并输出(m<链的长度)

六、设单链表表头指针为L,节点数据域为数字(0~9)(字符的思想一样),设计时间复杂度最低的算法判断前n/2个数字是否与后n/2数字一次相同(说人话就是是否前后一样)

 七、从非递减有序的单链表中删除值相同的多余元素

八、设有一个非递减正整数单链表(有重复数)设计算法确定比x小的节点数量

九、删除非递减单链表La中La与Lb相同元素(算法实现了但没验证)

十、已知La,Lb,Lc是三个链表,且他们已经初始化,其元素按递增顺序排序每个表中均无重复数据,设计算法在表Lc中,删除同时出现在La和Lb中的所有元素.(算法实现了但没验证)

十一、带头节点单链表中的所有元素的数据按递增顺序排列,删除链表中大于min且小于max的元素

十二、对链表进行冒泡排序

十三、设L为单链表头节点地址,其数据节点都是正整数可能存在相同的数值的节点,设计一个空间复杂度最低的算法利用直接插入排序把该链表按递增排序,并将重复点删除.

十四、给定两个单链表,编写算法找出两个链表的公共节点(算法实现没验证)

总代码与测试结果

总结

前言

这节课介绍的几道例题是考试中常考的大家应好好理解,我将注释写清楚点.单链表的数据结构定义与头插法和尾插法创建单链表在上节已经实现这节课主要做几道例题,但要想测试例题需要建立单链表,所以大家可以在最后的总代码和结果中查看.其中文章中备注的算法实现了但未验证不代表算法是错的,只是由于实现的前提条件比较困难.

一、已知L为带头结点的单链表,请依照递归思想实现下列运算

  1. 求链表中的最大整数
  2. 求表中的节点数
  3. 求链表所有元素的平均值

求链表中的最大整数

//(1)求链表中的最大整数
int getmax(Linklist L) {if (L == NULL) {return MIN;//宏定义MIN为一个很小的数例如-999999}int tmp = getmax(L->next);//获得下一个元素return tmp > L->data ? tmp : L->data;//比较两个元素大小
}

这道题要熟悉了解递归

求表中的节点数

//(2)求表中的节点数
int getnodes(Linklist L) {if (L == NULL) {return 0;//没有节点了返回0}return 1 + getnodes(L->next);//求和
}

求链表所有元素的平均值

//定义求链表所有元素之和函数
float sum(Linklist L) {//递归求和函数if (L == NULL) {return 0;}return L->data + sum(L->next);
}
void operation(Linklist L) {int max = getmax(L->next);//带头节点传入第一个数据域printf("链表中的最大值为:%d\n", max);int num = getnodes(L->next);//带头节点传入第一个数据域printf("链表中的节点个数为:%d\n", num);float sumnum = sum(L->next);printf("链表中元素的和为:%f\n", sumnum);float avg = sumnum / num;//总和除以总结点个数printf("链表元素的平均值为:%.4lf\n", avg);
}

二、单链表访问第i个数据节点

void getElem(Linklist L, int i, int& e) {int j = 0;//计数器LNode* p = L;while (NULL != p->next) {j++;if (j == i) {//到第i个节点将值赋给e返回e = p->next->data;break;}p = p->next;}
}

三、在第i个元素前插入元素e

//例5:在第i个元素前插入元素e
void insertElem(Linklist L, int i, int e) {int j = 0;LNode* p = L->next;LNode* pre = L;//前驱指针while (p != NULL) {j++;if (j == i) {LNode* pNode = (LNode*)malloc(sizeof(LNode));assert(pNode);pNode->data = e;pNode->next = pre->next;pre->next = pNode;break;}pre = p;p = p->next;}}

在单链表插入元素,需要找到插入位置元素的前驱.

核心代码

pNode->next = pre->next;
pre->next = pNode;

四、删除第i个结点

//删除第i个结点
void deleteElem(Linklist L, int i, int &e) {int j = 0;LNode* p = L->next;LNode* pre = L;while (p != NULL) {j++;if (j == i) {e = p->data;LNode* tmp = p;pre->next = p->next;//断链,删除元素的前驱节点指向删除节点的后驱free(tmp);//释放结点tmp = NULL;break;}pre = p;p = p->next;}
}

删除节点要释放节点使用free()

五、查找带头结点单链表倒数第m个结点并输出(m<链的长度)

//例6:查找带头结点单链表倒数第m个结点并输出(m<链的长度)
void getData(int m, Linklist L) {int j = 0;LNode* p = L->next;LNode* q = L->next;while (p != NULL) {j++;if (j == m) {break;}p = p->next;}if (p != NULL) {p = p->next;//指向下一个m+1个节点}while (p != NULL) {p = p->next;q = q->next;}if (q != NULL) {printf("倒数第%d个元素为:%d\n", m, q->data);}
}

查找倒数第m个节点挺常考的,但是也比较简单,知道思想问题就迎刃而解了.

算法思想:定义一个p指针和q指针同时指向首元素,使用指针p寻找第m+1个元素,这样就保证了p指针到q指针之间有m个元素,之后将p,q指针同时往后移这样当p指针为空时,q正好指向倒数第m个元素.

六、设单链表表头指针为L,节点数据域为数字(0~9)(字符的思想一样),设计时间复杂度最低的算法判断前n/2个数字是否与后n/2数字一次相同(说人话就是是否前后一样)

int isSym(Linklist L,int n) {int j = 0;LNode* p = L->next;LNode* q = L->next;while (p != NULL) {j++;if (j == n / 2) {break;}p = p->next;}if (n % 2 == 0) {//偶数移一位p = p->next;}else {//奇数移两位p = p->next->next;}while (p != NULL) {if (q->data != p->data) {return 0;}p = p->next;q = q->next;}return 1;
}

算法思想:前一半和后一半是否一样只需找到后一半的首元素,找到后只需将前一半与后一般元素一一比较即可.但中间有个细节就是链表的长度是奇数还是偶数,分情况讨论.这里我画个图方便大家理解.

 七、从非递减有序的单链表中删除值相同的多余元素

//例8:从非递减有序的单链表中删除值相同的多余元素
void deletesimilar(Linklist L) {LNode* preNode = L->next;while (preNode!=NULL && NULL != preNode->next) {if (preNode->next->data == preNode->data) {LNode* p = preNode->next;preNode->next = p->next;free(p);p = NULL;}else {preNode = preNode->next;}}
}

这道题也非常静经典.

算法思想:从非递减链表中删除重复元素只需遍历元素与前驱元素比较,如果相等就删除节点.大家只要知道思想代码就可以灵活多变.

八、设有一个非递减正整数单链表(有重复数)设计算法确定比x小的节点数量

//例9:设有一个非递减正整数单链表(有重复数)设计算法确定比x小的节点数量
//L:{1,2,2,2,4,6}比4小的节点有2个
int lessNodes(Linklist L, int x) {int i = 0;LNode* preCur = L;LNode* pCur = L->next;while (pCur != NULL && pCur->data < x) {if (pCur->data != preCur->data) {i++;}preCur = pCur;pCur = pCur->next;}return i;
}

这道题与上道题类似.

算法思想:非递减有重复数,查找比x节点有几个(去掉重复),遍历元素只要当前元素小于x且不等于前驱元素,也就是说出现了新的值,计数器i就++,最后返回i,这道题也就是上道题的变形,思想很重要,可以帮助你解决很多问题.

九、删除非递减单链表La中La与Lb相同元素(算法实现了但没验证)

//例10:删除非递减单链表La中La与Lb相同元素(算法实现了但没验证)
void delsimilar(Linklist La, Linklist Lb) {//在A表上进行修改LNode* preCurA = La;LNode* pCurA = La->next;LNode* pCurB = Lb->next;while (pCurA && pCurB) {if (pCurA->data < pCurB->data) {//说明与B相等元素在后面,移动A指针preCurA = pCurA;//因为在A表上修改记录前驱pCurA = pCurA->next;}else if (pCurA->data > pCurB->data) {说明与A相等元素在后面,移动B指针pCurB = pCurB->next;}else {//相等删除A中当前元素preCurA = pCurA->next;free(pCurA);pCurA = preCurA->next;}}
}

这道题也比较经典.

算法思想:LA非递减删除LB相同元素,设定两个指针p和q,p指向表A中元素,q指向表B中元素,如果有一方的当前指针指向的元素比另一方小则移动该链表的指针,因为如果想要找到相等的只能在后面元素里面找.

十、已知La,Lb,Lc是三个链表,且他们已经初始化,其元素按递增顺序排序每个表中均无重复数据,设计算法在表Lc中,删除同时出现在La和Lb中的所有元素.(算法实现了但没验证)

//例11:已知La,Lb,Lc是三个链表,且他们已经初始化,其元素按递增顺序排序每个表中均无重复数据,设计算法在表Lc中
//删除同时出现在La和Lb中的所有元素.(算法实现了但没验证)
void deleteOper(LNode*& preCur, LNode*& pCur, ElemType e) {while (NULL != pCur && pCur->data < e) {//找到第一个>=e的元素preCur = pCur;pCur = pCur->next;}if (pCur!=NULL && e == pCur->data) {//如果等于该元素删除preCur = pCur->next;free(pCur);pCur = preCur->next;}
}
void delsimilar2(Linklist La, Linklist Lb, Linklist Lc) {LNode* pCurA = La->next;LNode* pCurB = Lb->next;LNode* preCurC = Lc;LNode* pCurC = Lc->next;while (pCurA && pCurB) {//寻找LA与LB中相同的元素if (pCurA->data < pCurB->data) {pCurA = pCurA->next;}else if(pCurA->data > pCurB->data){pCurB = pCurB->next;}else {deleteOper(preCurC, pCurC, pCurA->data);pCurB = pCurB->next;pCurA = pCurA->next;}}
}

算法思想:这道题是上一道题的增强版,但是也是比较简单的,就是找LA与LB中相同的元素再去LC表中查找并删除即可.注意一个细节,由于不想从头开始找,所以Lc记录的前驱节点为引用传递,这其实是c++的语法,你可以改为指针,进行址传递,但考试时写伪代码即可.

十一、带头节点单链表中的所有元素的数据按递增顺序排列,删除链表中大于min且小于max的元素

//例12:带头节点单链表中的所有元素的数据按递增顺序排列,删除链表中大于min且小于max的元素
void deleteNodes(Linklist L,int min ,int max) {LNode* preCur = L;LNode* pCur = L->next;while (pCur) {//找到第一个大于min的节点if (min < pCur->data) {break;}preCur = pCur;pCur = pCur->next;}while (pCur && pCur->data < max) {//一直删除到大于maxpreCur->next = pCur->next;free(pCur);pCur = preCur->next;}
}

这个比较简单了遍历一次链表就可以了,但要记住删除单链表节点一定要记录前驱节点.

十二、对链表进行冒泡排序

//例13:对链表进行冒泡排序
void bubleSort(Linklist L) {while (1) {//每次都从第一个元素开始遇到大于的就交换int isExchange = 0;//记录是否元素发生交换LNode* p = L->next;while (p && p->next) {if (p->data > p->next->data) {//交换元素ElemType tmp = p->data;p->data = p->next->data;p->next->data = tmp;isExchange = 1;}p = p->next;}if (isExchange == 0) {//当前这一次排序没发生交换说明排序已经完成break;}}
}

算法思想:就是冒泡排序的思想这里不用交换节点直接交换数据即可.要注意与数组的冒泡排序不同由于链表在开始前无法知道元素个数,所以用while(1),结束条件就是当链表中不在发生交换说明排序以完成.后续我们在排序算法时还会提及.

十三、设L为单链表头节点地址,其数据节点都是正整数可能存在相同的数值的节点,设计一个空间复杂度最低的算法利用直接插入排序把该链表按递增排序,并将重复点删除.

//例14:设L为单链表头节点地址,其数据节点都是正整数可能存在相同的数值的节点,设计一个空间复杂度最低的算法利用直接插入排序
//把该链表按递增排序,并将重复点删除.
void insertsort(Linklist L) {LNode* p = L->next;//先把表提出来L->next = NULL;while (p != NULL) {LNode* preCur = L;LNode* pCur = L->next;while (pCur && pCur->data < p->data) {//寻找插入位置preCur = pCur;pCur = pCur->next;}LNode* tmp = p;//先记录元素节点p = p->next;//指针向后if (pCur!=NULL && pCur->data == tmp->data) {//如果第一个不小于该元素等于该元素删除节点free(tmp);tmp = NULL;}else {//插入节点tmp->next = preCur->next;preCur->next = tmp;}}
}

算法思想:采用直接插入排序,这里对直接插入排序不理解的直接跳过即可,这题主要一个思想就是对链表操作时可以将链表断开之后一个元素一个元素的进行操作.

十四、给定两个单链表,编写算法找出两个链表的公共节点(算法实现没验证)

//例15:给定两个单链表,编写算法找出两个链表的公共节点(算法实现没验证)
//定义求链表长度函数
int Length(Linklist L) {LNode* p = L->next;int length = 0;while (p!=NULL) {length++;p = p->next;}return length;
}
//寻找公共节点函数
//思想:公共节点只可能在短链的后面节点出现,故长链前的节点不用比较
LNode* search(Linklist La, Linklist Lb) {int Lalength = Length(La);int Lblength = Length(Lb);int dist = 0;LNode* shortlist = NULL;LNode* longlist = NULL;if (Lalength > Lblength) {longlist = La->next;shortlist = Lb->next;dist = Lalength - Lblength;}else {longlist = Lb->next;shortlist = La->next;dist = Lblength - Lalength;}while (dist--) {//寻找可能出现公共节点的第一个节点longlist = longlist->next;}while (longlist!=NULL) {//节点依次比较if (longlist == shortlist) {return longlist;}else {longlist = longlist->next;shortlist = shortlist->next;}}return NULL;
}

这道题王道辅导书上的课后题也有.

算法思想:要寻找两个链表的公共节点,第一个公共节点只能在长链中长链长度减短链长度之后.这里简单画个图帮助大家理解.

总代码与测试结果

测试结果有标注对应好.

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<assert.h>
#include<malloc.h>#define MIN -999999;
typedef int ElemType;//单链表的数据结构定义
typedef struct LNode {ElemType data;//数据struct LNode* next;//下一个节点
}LNode,*Linklist;
//使用头插法建立单链表
void CreateLinklist1(Linklist &L,int arr[],int arrlength) {L = (LNode*)malloc(sizeof(LNode));//申请一个头节点assert(L);L->next = NULL;for (int i = 0; i < arrlength; i++) {LNode*pNode = (LNode*)malloc(sizeof(LNode));assert(pNode);pNode->data = arr[i];pNode->next = L->next;L->next = pNode;}
}
//使用尾插法建立单链表
void CreateLinklist2(Linklist& L,int arr[],int arrlength) {L = (LNode*)malloc(sizeof(LNode));//申请一个头节点assert(L);L->next = NULL;LNode* pTail = L;for (int i = 0; i < arrlength; i++) {LNode* pNode = (LNode*)malloc(sizeof(LNode));assert(pNode);pNode->data = arr[i];pNode->next = pTail->next;pTail->next = pNode;pTail = pNode;}
}
//打印单链表函数
void print(Linklist L) {LNode* p = L->next;while (NULL != p) {printf("%d ", p->data);p = p->next;}printf("\n");
}
//例3:已知L为带头结点的单链表,请依照递归思想实现下列运算
//(1)求链表中的最大整数
int getmax(Linklist L) {if (L == NULL) {return MIN;}int tmp = getmax(L->next);return tmp > L->data ? tmp : L->data;
}
//(2)求表中的节点数
int getnodes(Linklist L) {if (L == NULL) {return 0;}return 1 + getnodes(L->next);
}
//(3)求链表所有元素的平均值
//定义求链表所有元素之和函数
float sum(Linklist L) {if (L == NULL) {return 0;}return L->data + sum(L->next);
}
void operation(Linklist L) {int max = getmax(L->next);//带头节点传入第一个数据域printf("链表中的最大值为:%d\n", max);int num = getnodes(L->next);//带头节点传入第一个数据域printf("链表中的节点个数为:%d\n", num);float sumnum = sum(L->next);printf("链表中元素的和为:%f\n", sumnum);float avg = sumnum / num;printf("链表元素的平均值为:%.4lf\n", avg);
}
//例4:单链表访问第i个数据节点
void getElem(Linklist L, int i, int& e) {int j = 0;LNode* p = L;while (NULL != p->next) {j++;if (j == i) {e = p->next->data;break;}p = p->next;}
}
//例5:在第i个元素前插入元素e
void insertElem(Linklist L, int i, int e) {int j = 0;LNode* p = L->next;LNode* pre = L;while (p != NULL) {j++;if (j == i) {LNode* pNode = (LNode*)malloc(sizeof(LNode));assert(pNode);pNode->data = e;pNode->next = pre->next;pre->next = pNode;break;}pre = p;p = p->next;}}
//删除第i个结点
void deleteElem(Linklist L, int i, int &e) {int j = 0;LNode* p = L->next;LNode* pre = L;while (p != NULL) {j++;if (j == i) {e = p->data;LNode* tmp = p;pre->next = p->next;//断链free(tmp);//释放结点tmp = NULL;break;}pre = p;p = p->next;}
}
//例6:查找带头结点单链表倒数第m个结点并输出
void getData(int m, Linklist L) {int j = 0;LNode* p = L->next;LNode* q = L->next;while (p != NULL) {j++;if (j == m) {break;}p = p->next;}if (p != NULL) {p = p->next;//指向下一个m+1个节点}while (p != NULL) {p = p->next;q = q->next;}if (q != NULL) {printf("倒数第%d个元素为:%d\n", m, q->data);}
}
//例7:设单链表表头指针为L,节点数据域为数字(0~9)(字符的思想一样),设计时间复杂度最低的算法判断前n/2
//个数字是否与后n/2数字一次相同(说人话就是是否前后一样)
int isSym(Linklist L,int n) {int j = 0;LNode* p = L->next;LNode* q = L->next;while (p != NULL) {j++;if (j == n / 2) {break;}p = p->next;}if (n % 2 == 0) {p = p->next;}else {p = p->next->next;}while (p != NULL) {if (q->data != p->data) {return 0;}p = p->next;q = q->next;}return 1;
}
//例8:从非递减有序的单链表中删除值相同的多余元素
void deletesimilar(Linklist L) {LNode* preNode = L->next;while (preNode!=NULL && NULL != preNode->next) {if (preNode->next->data == preNode->data) {LNode* p = preNode->next;preNode->next = p->next;free(p);p = NULL;}else {preNode = preNode->next;}}
}
//例9:设有一个非递减正整数单链表(有重复数)设计算法确定比x小的节点数量
//L:{1,2,2,2,4,6}比4小的节点有2个
int lessNodes(Linklist L, int x) {int i = 0;LNode* preCur = L;LNode* pCur = L->next;while (pCur != NULL && pCur->data < x) {if (pCur->data != preCur->data) {i++;}preCur = pCur;pCur = pCur->next;}return i;
}
//例10:删除非递减单链表La中La与Lb相同元素(算法实现了但没验证)
void delsimilar(Linklist La, Linklist Lb) {LNode* preCurA = La;LNode* pCurA = La->next;LNode* pCurB = Lb->next;while (pCurA && pCurB) {if (pCurA->data < pCurB->data) {preCurA = pCurA;pCurA = pCurA->next;}else if (pCurA->data > pCurB->data) {pCurB = pCurB->next;}else {preCurA = pCurA->next;free(pCurA);pCurA = preCurA->next;}}
}
//例11:已知La,Lb,Lc是三个链表,且他们已经初始化,其元素按递增顺序排序每个表中均无重复数据,设计算法在表Lc中
//删除同时出现在La和Lb中的所有元素.(算法实现了但没验证)
void deleteOper(LNode*& preCur, LNode*& pCur, ElemType e) {while (NULL != pCur && pCur->data < e) {preCur = pCur;pCur = pCur->next;}if (pCur!=NULL && e == pCur->data) {preCur = pCur->next;free(pCur);pCur = preCur->next;}
}
void delsimilar2(Linklist La, Linklist Lb, Linklist Lc) {LNode* pCurA = La->next;LNode* pCurB = Lb->next;LNode* preCurC = Lc;LNode* pCurC = Lc->next;while (pCurA && pCurB) {if (pCurA->data < pCurB->data) {pCurA = pCurA->next;}else if(pCurA->data > pCurB->data){pCurB = pCurB->next;}else {deleteOper(preCurC, pCurC, pCurA->data);pCurB = pCurB->next;pCurA = pCurA->next;}}
}
//例12:带头节点单链表中的所有元素的数据按递增顺序排列,删除链表中大于min且小于max的元素
void deleteNodes(Linklist L,int min ,int max) {LNode* preCur = L;LNode* pCur = L->next;while (pCur) {//找到第一个大于min的节点if (min < pCur->data) {break;}preCur = pCur;pCur = pCur->next;}while (pCur && pCur->data < max) {//一直删除到大于maxpreCur->next = pCur->next;free(pCur);pCur = preCur->next;}
}
//例13:对链表进行冒泡排序
void bubleSort(Linklist L) {while (1) {//每次都从第一个元素开始遇到大于的就交换int isExchange = 0;LNode* p = L->next;while (p && p->next) {if (p->data > p->next->data) {ElemType tmp = p->data;p->data = p->next->data;p->next->data = tmp;isExchange = 1;}p = p->next;}if (isExchange == 0) {break;}}
}
//例14:设L为单链表头节点地址,其数据节点都是正整数可能存在相同的数值的节点,设计一个空间复杂度最低的算法利用直接插入排序
//把该链表按递增排序,并将重复点删除.
void insertsort(Linklist L) {LNode* p = L->next;L->next = NULL;while (p != NULL) {LNode* preCur = L;LNode* pCur = L->next;while (pCur && pCur->data < p->data) {//寻找插入位置preCur = pCur;pCur = pCur->next;}LNode* tmp = p;p = p->next;if (pCur!=NULL && pCur->data == tmp->data) {//如果第一个不小于该元素等于该元素删除节点free(tmp);tmp = NULL;}else {//插入节点tmp->next = preCur->next;preCur->next = tmp;}}
}
//例15:给定两个单链表,编写算法找出两个链表的公共节点(算法实现没验证)
//定义求链表长度函数
int Length(Linklist L) {LNode* p = L->next;int length = 0;while (p!=NULL) {length++;p = p->next;}return length;
}
//寻找公共节点函数
//思想:公共节点只可能在短链的后面节点出现,故长链前的节点不用比较
LNode* search(Linklist La, Linklist Lb) {int Lalength = Length(La);int Lblength = Length(Lb);int dist = 0;LNode* shortlist = NULL;LNode* longlist = NULL;if (Lalength > Lblength) {longlist = La->next;shortlist = Lb->next;dist = Lalength - Lblength;}else {longlist = Lb->next;shortlist = La->next;dist = Lblength - Lalength;}while (dist--) {//寻找可能出现公共节点的第一个节点longlist = longlist->next;}while (longlist!=NULL) {//节点依次比较if (longlist == shortlist) {return longlist;}else {longlist = longlist->next;shortlist = shortlist->next;}}return NULL;
}
int main() {Linklist L=NULL;int arr[10] = { 1,50,88,49,66,13,12,17,19,44 };int arrlength = sizeof(arr) / sizeof(arr[0]);//使用头插法建立单链表CreateLinklist2(L, arr, arrlength);printf("输出尾插法链中序列L:");print(L);printf("**************************************\n");printf("对例3进行测试!\n");operation(L);printf("**************************************\n");printf("对例4进行测试!\n");int e = 0;getElem(L, 4, e);printf("e的值为:%d\n", e);int a = 777;printf("**************************************\n");printf("对例5进行测试!\n");insertElem(L, 4, a);print(L);printf("删除第i个节点!\n");int b = 0;deleteElem(L, 4, b);printf("b的值为:%d\n", b);print(L);printf("**************************************\n");printf("对例6进行测试!\n");getData(4,L);printf("**************************************\n");printf("对例7进行测试!\n");Linklist La;int arr1[11] = { 1,2,3,4,5,6,1,2,3,4,5 };int arrlength1 = sizeof(arr1) / sizeof(arr1[0]);//使用头插法建立单链表CreateLinklist2(La, arr1, arrlength1);print(La);printf("判断单链表是否对称(是返回1不是为0):%d\n", isSym(La, 11));printf("**************************************\n");printf("对例8进行测试!\n");Linklist Lb;int arr2[10] = { 1,1,2,2,3,3,4,4,5,6};int arrlength2 = sizeof(arr2) / sizeof(arr2[0]);//使用头插法建立单链表CreateLinklist2(Lb, arr2, arrlength2);printf("删除前:");print(Lb);deletesimilar(Lb);printf("删除后:");print(Lb);printf("**************************************\n");printf("对例9进行测试!\n");CreateLinklist2(Lb, arr2, arrlength2);printf("比4小的节点个数为:%d\n", lessNodes(Lb, 4));printf("**************************************\n");printf("对例12进行测试!\n");print(Lb);deleteNodes(Lb,2,6);print(Lb);printf("**************************************\n");printf("对例13进行测试!\n");print(L);bubleSort(L);print(L);printf("**************************************\n");printf("对例14进行测试!\n");CreateLinklist2(L, arr, arrlength);print(L);insertsort(L);print(L);printf("**************************************\n");printf("对例15进行测试!\n");printf("链表长度为:%d",Length(L));return 0;
}

总结

几道关于单链表的题目,希望可以帮助大家,本人制作不易,麻烦点点赞,谢谢家人们.

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.hqwc.cn/news/338104.html

如若内容造成侵权/违法违规/事实不符，请联系编程知识网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

从0开始python学习-45.pytest框之将所有的用例封装到一个类中，实现极限封装，并测试用例校验

从0开始python学习-45.pytest框之将所有的用例封装到一个类中，实现极限封装，并测试用例校验

目录 1. 封装一个用于校验yaml测试用例参数的方法&#xff1a;model_util.py 2. 校验方法是否正确 3. 封装一个方法&#xff0c;用于读取所有的用例&#xff1a;test_all_case.py 1. 封装一个用于校验yaml测试用例参数的方法&#xff1a;model_util.py from dataclasses imp…
阅读更多...
Python从入门到网络爬虫（23个Python开源项目）

Python从入门到网络爬虫（23个Python开源项目）

前言 随着互联网的快速发展&#xff0c;大量的信息被不断地产生和积累&#xff0c;这也使得网络爬虫变得越来越重要。而Python作为一门高效、易用的编程语言&#xff0c;被广泛地应用于网络爬虫领域。本文将从多个角度分析Python开源爬虫项目的优缺点、应用场景以及未来发展方…
阅读更多...
Kubernets(K8S)启动和运行01 快速入门

Kubernets(K8S)启动和运行01 快速入门

简介 Kubernetes is an open source orchestrator for deploying containerized applications. It was originally developed by Google, inspired by a decade of experience deploying scalable, reliable systems in containers via application-oriented APIs. Kubernete…
阅读更多...
智能合约笔记

智能合约笔记

前言&#xff1a; 首先了解下为什么会出现智能合约&#xff0c;打个比方现在有两个人A和B打赌明天会不会下雨&#xff0c;每个人赌注100元&#xff0c;如果第二天下雨则A拿走200元&#xff0c;否则B拿走200元&#xff0c;这样就有一个问题&#xff0c;赌注要到第二天才能见效&…
阅读更多...
three.js实现雷达扫描效果（纹理贴图）

three.js实现雷达扫描效果（纹理贴图）

three.js实现雷达扫描效果&#xff08;纹理贴图&#xff09; 图例 步骤 创建两个平面&#xff0c;分别纹理贴图&#xff0c;底图模型.add&#xff08;光波模型&#xff09;关闭材质的深度测试光波旋转 代码 <template><div class"app"><div ref&q…
阅读更多...
RT-Thread：SPI万能驱动 SFUD 驱动Flash W25Q64，通过 STM32CubeMX 配置 STM32 SPI 驱动

RT-Thread：SPI万能驱动 SFUD 驱动Flash W25Q64，通过 STM32CubeMX 配置 STM32 SPI 驱动

关键词&#xff1a;SFUD,FLASH,W25Q64&#xff0c;W25Q128&#xff0c;STM32F407 说明&#xff1a;RT-Thread 系统 使用 SPI万能驱动 SFUD 驱动 Flash W25Q64&#xff0c;通过 STM32CubeMX 配置 STM32 SPI 驱动。 提示&#xff1a;SFUD添加后的存储位置 1.打开RT-Thread Sett…
阅读更多...
Python 日志模块 logging 的最佳实践，内容干练简洁

Python 日志模块 logging 的最佳实践，内容干练简洁

文章目录 1. 引言2. 定义日志类3. 引用日志4. 参考 1. 引言 每次写 python 代码&#xff0c;想找一个日志模块 logging 的最佳实践&#xff0c;都要找一大圈&#xff0c;确不一定可以找到合适的最佳实践。 痛定思痛&#xff0c;我决定下笔记录目前觉得合适的 python 日志的用…
阅读更多...
206. 反转链表（Java）

206. 反转链表（Java）

题目描述&#xff1a; 给你单链表的头节点 head &#xff0c;请你反转链表&#xff0c;并返回反转后的链表。 输入&#xff1a; head [1,2,3,4,5] 输出&#xff1a; [5,4,3,2,1] 代码实现&#xff1a; 1.根据题意创建一个结点类&#xff1a; public class ListNode {int val…
阅读更多...
【AI】CycleGan对抗生成网络遥感影像生成地图效果测试

【AI】CycleGan对抗生成网络遥感影像生成地图效果测试

今天看到一个有趣的项目&#xff0c;CycleGan对抗生成网络把马生成成斑马&#xff0c;还有一个测试用例是用遥感影像生成平面地图的效果&#xff0c;效果如下图所示&#xff0c;我大学是遥感专业&#xff0c;看到遥感影像就触动了我的原神&#xff0c;于是原神启动&#xff0c;…
阅读更多...
centos下系统全局检测工具dstat使用

centos下系统全局检测工具dstat使用

目录 一&#xff1a;没有需要安装 二&#xff1a;dstat命令参数 三、监测界面各参数含义&#xff08;部分&#xff09; 四、dstat的高级用法 一&#xff1a;没有需要安装 yum install dstat 二&#xff1a;dstat命令参数 有默认选项&#xff0c;执行dstat命令不加任何参数…
阅读更多...
springCould中的Bus-从小白开始【11】

springCould中的Bus-从小白开始【11】

目录 &#x1f9c2;1.Bus是什么❤️❤️❤️ &#x1f32d;2.什么是总线❤️❤️❤️ &#x1f953;3.rabbitmq❤️❤️❤️ &#x1f95e;4.新建模块3366❤️❤️❤️ &#x1f373;5.设计思想 ❤️❤️❤️ &#x1f37f;6.添加消息总线的支持❤️❤️❤️ &#x1f9…
阅读更多...
springboot医院信管系统源码和论文

springboot医院信管系统源码和论文

随着信息技术和网络技术的飞速发展&#xff0c;人类已进入全新信息化时代&#xff0c;传统管理技术已无法高效&#xff0c;便捷地管理信息。为了迎合时代需求&#xff0c;优化管理效率&#xff0c;各种各样的管理系统应运而生&#xff0c;各行各业相继进入信息管理时代&#xf…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023