少年的歌-CSDN博客

原创将一个带头结点的单链表A分解成两个带头结点的单链表A和B，使得A表中含有原表中为奇数的元素，而b变含有原表中含有偶数的元素，并且保持其相对顺序不变。

补更：前两天熬夜去了，被tm叫着上网，回来晚了没来得及更。。。。算法思想：就是将原来的A表，把序号奇数留下来，把序号偶数的加到链表B中，判断是否为奇偶数%2还有设置一个i记录遍历的下标位置（i的序号就是用来判断奇偶的），每访问一个结点加一下面给出代码#include<stdio.h>#include <bits/stdc++.h>typedef struct lnode{ int data;//数据 struct lnode *next;//指针域 }l

2022-04-09 22:28:59 2938

原创给定一个含n(n≥1)个整数的数组，请设计一个在时间上尽可能高效的算法，找出数组中未出现的最小正整数。

算法思想：首先要知道这个正整数的范围，因为是n个整数，最小的正整数x一定在1到n+1这个范围之间，为什么呢，假如这个数组为a[1,2,3,4,5]此时最小正整数为6，就是n+1,如果出现1到n之间没有出现的这个x也在1—n+1这个范围确定了范围，我们多设立一个数组b,同时多分配两个空间b[n+2],初始值全部为0，然后对a[i]进行遍历，如果0<a[i]<=n+1,就b[a[i]]=1，这个操作其实就是把a[i]在范围的元素值放在b数组里面，同时把下标对应的赋值为1，比如a[0]=1,此

2022-04-01 18:29:22 2838 6

原创 A*算法的简单实现

【代码】A*算法的简单实现。

2023-12-12 21:27:13 992

原创 MobileNetv2

Mobile v2的网络搭建。

2023-12-12 21:24:18 429

原创 mobileNet C语言实现网络搭建

【代码】mobileNet C语言实现网络搭建。

2023-12-12 21:11:53 422

原创设A和B是两个单链表（带头结点），其中的元素都是递增，设计一个算法从A和B中的公共元素产生链表C,要求不破坏AB的结点

算法思想：挨个比较，元素值小(指针)的向后移动，最后为空，相等就复制给s插入C链表 #include<stdio.h>#include <bits/stdc++.h>typedef struct lnode{ int data;//数据 struct lnode *next;//指针域 }lnode,*LinkList;int a[5]={1,3,5,7,9};int b[5]={2,3,5,9,10};int n=5;void InitLis...

2022-04-13 23:18:23 1502 3

原创假设有两个按元素值递增次序的线性表，均已单链表的形式存储。请编写算法将这两个单链表归并为一个按元素值递减的次序排列的单链表，并要求利用原来的两个单链表的结点存放归并后的单链表。

算法思想：合并两个递增的，输出为递减，就是逆向输出采用头插法，注意中间防止断链多给一个q指向工作的后继，还有一个情况就是出现剩余一个为非空的链表，也是直接加在链表后面即可下面给出代码 #include<stdio.h>#include <bits/stdc++.h>typedef struct lnode{ int data;//数据 struct lnode *next;//指针域 }lnode,*LinkList;int a[5]={1,3,5,7,9

2022-04-12 23:07:37 3097 1

原创在一个递增有序的线性表中，有数值相同的元素存在。若存储方式为单链表，设计算法，去掉数值相同的元素，使得表中不再有重复的元素。例如（7，10，10，21，30，42，42，42，51，70）将变为（7，

算法思想：因为他是有序表，所以相邻结点如果有相同得一定是挨着得，所以用p扫描链表，如果p的后继与他相等，就删除后继还有一种解法，采用尾插法，将头结点摘下，从第一个结点开始，后面的要插入的结点依次和链表中的最后一个进行比较，如果相等就删除当前然后向后遍历处理下一个结点，不相等就插入，直到最后一个为止下面给出代码#include<stdio.h>#include <bits/stdc++.h>typedef struct lnode{ int data;//数据

2022-04-11 22:28:56 1497

原创设C=a1,b1 ,a2, b2,., an,bn,D为线性表,采用带头结点的hc单链表存放,设计一个就地算法,将其拆分为两个线性表,使得A={a, a2, an, B={bn,...b2,b2)；

算法思想：如何拆分？观察得奇数数位都是a,偶数位数都是b所以我们可以设置一个i=1初始化，然后依次累加，如果为奇数加到A表否则加到B表,B不能像A一样使用尾插法了，应该使用头插法反序输出#include<stdio.h>#include <bits/stdc++.h>typedef struct lnode{ int data;//数据 struct lnode *next;//指针域 }lnode,*LinkList;int a[10]={1,2,3,4,.

2022-04-10 23:28:18 1585

原创给定一个带表头结点的单链表，设head为头指针，结点结构为（data,next）,data为整型元素，next为指针，试写出算法：按递增次序输出单链表中各个结点的数据元素，并释放结点所占的存储空间

算法思想：对链表进行遍历，每次遍历找出整个链表的最小值输出并释放结点所占的空间，再次查找最小值元素，输出并释放空间，直到链表为空最后释放头结点#include<stdio.h>#include<stdlib.h>typedef struct lnode{ int data; struct lnode *next;}lnode,*LinkList; int a[10]={4,2,3,1,8};int n=5;void InitList(LinkList &amp

2022-04-05 19:39:00 4260

原创给定两个单链表，编写算法找出两个链表的公共结点

算法思路：首先知道什么是公共结点，公共结点其实就是从链表的某个结点开始，他们的next都指向同一个结点，之后他们所有的结点都是重合的，所以有两个公共结点部分重合的单链表，他们看起来应该是Y型，而不是x型方法一：暴力破解，就是两个链表，在第一个链表上面顺序遍历每个结点，每遍历一个然后再第二个链表上面顺序遍历所有结点，找到是否相同的结点#include<stdio.h>#include<stdlib.h>typedef struct lnode{ int data; s

2022-04-04 18:01:52 3035 11

原创设计一个带头结点的单链表中所有的元素结点的数据值是无序的，编写一个函数，删除表中所有介于给定两个值（作为函数参数给出）之间的元素

算法思想：因为是无序的所以需要挨个进行比较然后使用链表中删除的方法下面给出代码void delete(LinkList &L,int min,int max){ Lnode *pre=L,*p=L->next; while(p!=NULL){ if(p->data>min&&p->data<max){ pre->next=p->next; free(p)

2022-04-03 17:06:29 1243

原创有一个带头结点的单链表L，设计一个算法使其元素递增

算法思想：//其实可以和数组的对比起来，数组就是通过冒泡、选择、插入、快速，归并排序常见的排序来排，但是这里是链表 // 不能直接像数组那样在原有的链表上面进行排序，链表通常是有两种初始化方式，头插法，尾插法，头插法就是和原有的链表逆置，尾插和原有相同LinkList Sort(LinkList &L){ //1.直接插入排序 Lnode *p=L->next,*pre; Lnode *r=p->next;//r作为p.

2022-04-02 16:55:35 7046

原创编写算法将带头结点的单链表就地逆置，时间复杂度为O(1)。

首先容易想到就是使用头插法就是最基本的链表插入，并且刚好是读入顺序的相反，就是逆置的过程主要核心代码：L->next=nulls->data=x;s->next=L->next;L->next=s;LinkList reverse(LinkList L){ Lnode *p,*r//p为工作指针，r为p的后继，目的是为了防止断链 p=L->next; L->next=NULL; while(P!=NUL

2022-04-01 20:10:28 1267

原创试编写在带头结点的单链表L中删除一个最小值结点的高效算法（假设最小值结点是唯一的）

算法思想：首先把他看成一个数组，如何删除最小的元素，挨个遍历比较就是，这里是链表所以还需要删除，如何删除，找到他的前驱结点即可。所以现在这里设置4个元素，一个指针P，用来遍历当前元素，还需要一个他的前驱结点pre,然后需要一个min指针开始初值就是p,然后和p后面的挨个进行比较，遇到比他还小的就进行换擂主，同时还要有一个minpre指针同时初值为pre#include<stdio.h>#include<stdlib.h>typedef struct Lnode{

2022-03-31 20:01:21 5096

原创设L为带头节点的单链表，编写算法实现从头到尾反向输出每个节点的值

算法思想:用数组进行反转，然后再来加到链表中//这里使用对的数组反转来进行逆置#include<stdio.h>#include<stdlib.h> //反向输出每个节点的值，带头节点的单链表typedef struct Lnode{ int data;//数据域 struct Lnode *next;//指针域 }Lnode,*LinkList;int a[7]={1,2,3,4,5,6}; int n=6;//链表首先就要初始化，如何让数组转化为链表

2022-03-30 17:32:45 3686

原创设将n个数组存放到一维数组R中，将R中保存的序列循环左移p个位置，即将R中的数据由（X0，X1，Xn-1）变换为（Xp,Xp+1...X0,X1,Xp-1)

算法思想：就是将一个一维数组的元素依次进行左移列如：[1,2,3,4,5,6]左移一位：[2,3,4,5,6,1]左移两位：[3,4,5,6,1,2]左移三位：[4,5,6,1,2,3]不难看出我们已经发现了规律，就是首先将所有元素逆置[6,5,4,3,2,1]假设这里循环三次(left=3)，逆置所有元素后，再将[0,n-left-1]进行逆置得到数组[4,5,6,3,2,1]最后再将[n-lfet,n-1]进行逆置得到要的答案#include<stdio.h&gt

2022-03-30 16:35:33 730

原创在带头节点的单链表L中，删除所有值为X的元素，释放其空间，假设值为X的节点不唯一

这个题没什么算法思想，就是要把数据结构最基本的删除方式记住，因为删除的时候，肯定要先初始化链表，初始化就有两种方式，头插法和尾插法，这里使用的尾插法。删除主要就是找前驱节点，如果不知道前驱节点还可以另外一种假替换的方式进行删除x,后面会详细介绍#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ int data;//数据域 struct Lnode *next;//指针域 }Lnode,*LinkList

2022-03-29 15:24:09 918

原创将两个有序顺序表合并为一个新的有序顺序表（经典列题）

算法思想：首先有两个顺序表，现在要合并成一个新的顺序表C,就是将依次比较大小然后放入C中，如果还有剩下没有比较完的，直接加在C顺序表后面关键代码：#include<stdio.h>typedef int ElemType;typedef struct { ElemType *data;//指示动态分配数组的指针 int Maxsize=100,length;//数组的最大容量和当前个数 }SeqList;bool Merge(SeqList A,SeqList B,Seq

2022-03-29 15:04:57 7084 9

原创从有序顺序表中删除其所有重复的元素，让表中所有的元素不同

算法思想：设置一个a【0】,与后面的依次比较，如果不相等，依次存入bool delRepat(Sqlist &L){if(L.length==0){ return false;}就是设置data[0]与后面的依次比较，设置一个j来表示int j=0;for(int i=1;i<L.length;i++){ if(L.data[j]!=L.data[i]){ j++; L.data[j]=L.data[i] }}

2022-03-29 14:53:28 306

原创从顺序表中删除值在给定s与t之间的所有元素，要求s＜t

这个题和前面一个题不同，前面的是有序的顺序表，已经排列好，这里只是顺序表，没有排列好因为这里不是有序了，所以不能像上面一个一样，需要挨着遍历去查找）bool del(Sqlist *L,int s,int t){ if(L.length==0||s>=t) return false; //设置一个k来记录在s和t之间的个数 int k=0; for(int i=0;i<L.length;i++){//记录在s,t之间的元素，k++

2022-03-29 14:46:33 354

原创从有序顺序表中删除值在给定s与t之间的所有元素，要求s＜t

思想，首先是有序表【0,1,2,3,4,5,6,7】删除[2,4]之间的即删除元素2,3,4。s为2，t为4。1.找到与s相等的第一个元素和等于t的第一个元素，记录下标a[2],a[4]2.往前覆盖元素3.修改length长度int del_s_t(SqList &L,int s,int t){ if(L.length==0) return false; if(s<L.data[0]||t>L.data[L.length-1]|

2022-03-29 14:43:23 479

原创对于长度为n的顺序表L，删除顺序表中所有值为x的元素

算法思想：删除值为x的的数据元素，挨个遍历进行记录，有两种方式，一种是记录等于x的数据元素，另外一种是记录不等于x的数据元素。接下来两种代码附上：两种方法：设置一个k，可以用来记录等于x值得元素个数，也可以用来记录不等于x值的元素个数法1：k值记录不等于x元素的个数void del_x(Sqlist &L,int &x){ int k=0; for(int i=0;i<L.length;i++){ if(L.data[i]!=x){

2022-03-29 14:38:10 1948 2

原创设计一个高效的算法，将顺序表L所有元素逆置

逆置元素有多种方法，可以再见一个数组，挨着将他最后的顺序放进去，但是时间复杂度为O(N)也可只用双指针，这里直接使用二分在原数组上面进行逆置；话不多说直接上代码：typedef int ElemType;typedef struct{ ElemType data; int length;}Sqlist;//采用二分法来逆置在c中5/2=2 void reverse(Sqlist &L){ Elemtype temp;//辅助变量 for(i

2022-03-29 14:32:28 2753 3

原创设计一个递归算法，删除不带头节点的单链表L中所有值为x的结点

算法思想：首先知道什么是递归，递归就是函数在原来的函数基础上进行下一次的调用直到不满住条件有一个初始值结束递归#include<stdio.h>#include<stdlib.h>typedef struct Lnode{ int data;//数据域 struct Lnode *next;//指针域 }Lnode,*LinkList;int a[4]={1,2,3,4};int n=4;//这里使用尾插法，把数据放在L中 void InitList(L

2022-03-28 23:18:26 2692 2

原创从顺序表中删除具有最小值的元素，并由函数返回被删元素的值，空出的位置由最后一个元素填补，若顺序表为空则显示出错信息并退出运行

//首先定义一个结构体typedef struct{ int data; //顺序表的元素 int length; //当前顺序表的长度}Sqlist;顺序表的类型定义又叫重名命bool delMin(Sqlist &l,int &Min){ if(l.length==0) return false; //设置顺序表的第一个元素为最小 min=l.data[0]; //给他设置一个记录当前最小的值的下标 intpos=0.

2022-03-28 22:00:24 1099 1

byuvyh的博客