- 博客(101)
- 收藏
- 关注
RSS订阅原创 顺序表-顺序表表示集合-差集（for + while ,不断遍历）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：差集是什么意思？C = A-BC中元素为A中所有不属于B的元素。例如：A: 2,3,4 B: 3,5,7那么C: 2,4遍历顺序表A,如果它与B中所有元素都不相同，则表示差集元素。 将其放到C中。思路:1.定义三个变量 i , j , k = 0;2.通过fo
2020-12-28 22:47:37
620
原创 顺序表-有序顺序表表示集合-并集（两者比较，小者放入C，未遍历继续放入）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里有序的顺序表，可以利用有序顺序表的归并算法来解题。用第三个顺序表C来存放并集元素。因为是有序的，所以两个顺序表比较，谁小谁放入C中，如果相等，那么就比较一个。将剩余的元素（A或B）放入C中。思路：1.定义三个变量 ，i ,j ,k 初始值都为0。2.通过while循
2020-12-28 22:29:04
564
原创 顺序表-顺序表表示集合-并集（A复制到C，B遍历比较C）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里是求并集 ，也就是 C = A u B (表示并集)也就是C 中元素为A和B中非重复出现的元素，这里我们先将A复制到C中，再将B中元素 与 C中元素一个一个比较，如果不相同，表示是并集元素，那么把它放入C中思路：1.定义三个变量i ,j k2.先将A复制到C中。
2020-12-27 22:55:31
719
1
原创 顺序表-有序顺序表表示集合-交集（while + 值比较）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：前面的顺序表是没有在有序的前提下，所以，要通过两个循环（for+while）一个一个比而这里是有序顺序表，在有顺序的前提下，可以降低算法的时间复杂度。这里我们不用每个都比较（一个循环 while），先比较它们的值，后移坐标即可。(画图更好理解)思路：1，定义三个变量i ,
2020-12-27 22:27:39
434
原创 TCP和UDP的区别和联系
TCP（Transmission Control Protocol，传输控制协议）是基于连接的协议，也就是说，在正式收发数据前，必须和对方建立可靠的连接。一个TCP连接必须要经过三次“对话”才能建立起来，其中的过程非常复杂，我们这里只做简单、形象的介绍，你只要做到能够理解这个过程即可。我们来看看这三次对话的简单过程：1.主机A向主机B发出连接请求数据包：“我想给你发数据，可以吗？”，这是第一次对话；2.主机B向主机A发送同意连接和要求同步（同步就是两台主机一个在发送，一个在接收，协调工作）的数据包
2020-12-27 21:05:44
2812
1
原创 顺序表-顺序表表示集合-交集( for + whlie ,不断遍历）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析： (for + whlie ,不断遍历 )这里要求交集运算，交集的结果肯定要用一个顺序表存放。所以要用一个顺序表存放，C = A^B (这里表示交集)，C表示一个新的集合通过A和B比较，如果A.data[i]，有元素在B中，那么将它放入C中。思路：1.定义两个变量i ,
2020-12-26 23:35:21
801
原创 顺序表-有序顺序表的归并算法（新建表+小的先放+余下归并）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里两个有序顺序表L1,L2将两个顺序表归并为一个顺序表。所有要新建一个顺序表存在。比较两个顺序表，把小的元素放入L3。之后再把两个顺序表多余元素归并到新建的顺序表L3中。思路：1.定义各自顺序表的下标，i ,j ，k ,分别对应 L1.L2.L32.通过while
2020-12-26 23:14:44
949
原创 顺序表-顺序表的基本操作（插入元素+删除元素）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;一.插入元素分析：在顺序表中，插入一个元素，跟单链表是不一样的。顺序表中，无论是插入还是删除，都是通过移动元素的来实现。这里插入元素，插入位置是自己定的，所以有可能出现参数错误的情况。因此，我们首先要判断参数是否错误。其次，还需要注意的是:这里要输入的参数是：逻辑序号所以要
2020-12-25 21:58:59
8732
6
原创 顺序表-顺序表的基本操作(初始化+指定位置元素值 + 用元素值求下标)
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;一.初始化顺序表算法：void InitList(SqList &L){ L.length = 0; }二.求顺序表中指定位置元素值的算法1.首先要判断输入参数位置是否有误，有，则返回02.如果没有，则用e保存所要得到元素值int GetElem
2020-12-25 21:39:21
1593
原创 顺序表-给定的顺序表L中删除元素值在x到y（x＜=y）之间的所有的元素
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这题和删除顺序表所有值的相等的结点相同，只不过这里：所有值为x结点 ---------->元素值在x和y 之间。所有这题只需将条件换一下即可。方法一：C代码实现：****（另外新建表）void delallxy1(SqList & L,int x,int
2020-12-24 22:43:31
5559
5
原创 顺序表-删除所有元素值为x结点（另建表存放+复制到原表）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里要删除顺序表的所有值为x的结点，跟单链表那题题意类似。主要区别就是：存储结构不同这里是顺序存储结构单链表是链式存储结构所以解题方法也跟链表的不一样。这里 ：另建表存放不同+复制到原表我们另建一个顺序表L1，将 L中不为x的值放入L1，相等的不管，最后将L1复制到L中
2020-12-24 22:21:14
1233
原创 顺序表-删除所有元素值为x结点（相等加一，不等前移k）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里要删除顺序表的所有值为x的结点，跟单链表那题题意相同。主要区别就是：存储结构不同这里是顺序存储结构单链表是链式存储结构所以解题方法也跟链表的不一样。这里采用：相等加一，不等前移k我们用k记录下元素值等于x的元素个数，其初始值为0.如果L.data[i] 等于x,那
2020-12-23 23:08:49
1220
5
原创 顺序表-删除所有元素值为x结点（遍历.新建顺序表（共享原空间））
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里要删除顺序表的所有值为x的结点，跟单链表那题题意相同。主要区别就是：存储结构不同这里是顺序存储结构单链表是链式存储结构所以解题方法也跟链表的不一样。这里我们采用遍历顺序表L，来新建一个顺序表这里只是共享了原顺序表的空间，并没有开辟内存。思路：1.定义循环变量i,
2020-12-23 22:55:51
2011
原创 单链表-删除重复节点（递增链表）
单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：这里删除重复节点，分两种情况：1.第一种是链表本身递增的2.第二种是链表可能是无序的无序的更复杂些，递增更简单些。这里是递增，说明重复的结点是在一起的，连续的。既然要删除结点，肯定要定义两个指针，pre,p思路：1.定义两个指针pre,p ,pre一开始指向第一个节点，p暂且不指向2.通过while循环,条件为p !
2020-12-22 22:15:07
554
原创 单链表-插入一个元素为x的节点后，使链表仍然有序
单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：这里和顺序表那题题意是一样的，都是插入一个元素节点x后，使链表仍然有序。那这两者有啥区别吗？存储结构不一样。顺序表是顺序存储结构，单链表是链表存储结构。二者区别：1.顺序表是先找到插入位置，然后将后面元素全体后移，让它插入。2.而这里单链表，通过判断数据域，找到该位置，不需要移动大量元素，直接插入即可，比顺序表更方便。
2020-12-22 21:51:21
6586
2
原创 单链表-两个线性表的合并（不破坏原链表+尾插法）
题意：令L1 = (X1,X2,X3,X4…Xn), L2 = (y1,y2,y3,y4…ym);是两个线性表。采用带头节点的链表存储，设计一个算法合并L1,L2，结果放在线性表L3中，要求如下：L3 = (X1,Y1,X2,Y2,X3,Y3,…XmYm,Xm+1,…Xn) 当m<= nL3 = (X1,Y1,X2,Y2,X3,Y3,…XnYn,Yn+1,…Ym) 当n<= mL3采用单链表存储。单链表的存储结构：typedef struct LinkList{ in
2020-12-21 22:53:50
3262
1
原创 单链表-两个线性表的合并1（破环原链表+尾插法）
题意：令L1 = (X1,X2,X3,X4…Xn), L2 = (y1,y2,y3,y4…ym);是两个线性表。采用带头节点的链表存储，设计一个算法合并L1,L2，结果放在线性表L3中，要求如下：L3 = (X1,Y1,X2,Y2,X3,Y3,…XmYm,Xm+1,…Xn) 当m<= nL3 = (X1,Y1,X2,Y2,X3,Y3,…XnYn,Yn+1,…Ym) 当n<= mL3采用单链表存储。单链表的存储结构：typedef struct LinkList{ in
2020-12-21 22:08:09
1196
原创 单链表-单链表拆分为A和B链表（尾插法+头插法）
题意：设C{a1,b1,a2.b2…an,bn}为一线性表，采用带头结点的单链表hc存放，设计一个就地算法，将其拆分为两个线性表，每个线性表均采用带头结点的单链表存储，使得：A = {a1,a2.a3.a4…an},B = {bn,bn-1,b3,b2,b1}单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：看到这个题目又有几分类似，之前的拆分为两个线性表，两个链表都是正序
2020-12-20 19:44:14
1436
原创 单链表-删除单链表L中奇数号节点（双指针法）
题意：有一个带头节点的单链表L，设计一个算法，删除其中第1，3，5，7号…节点,即删除奇数号的节点。单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：要删除肯定要定义两个指针pre,p，但是这里是删除奇数号节点，也就是说，要隔一个才删除。以往后移操作都是，p=p->next但是，这是p指向的节点的删除了。free(q)，这里就不能用这个了， 但是可以用前驱节点pr
2020-12-20 19:18:10
2879
2
原创 单链表-单链表拆分为两个线性表（同序的）（尾插法+尾插法）
题意：设C{a1,b1,a2.b2…an,bn}为一线性表，采用带头结点的单链表hc存放，设计一个就地算法，将其拆分为两个线性表，每个线性表均采用带头结点的单链表存储，使得：A = {a1,a2.a3.a4…an},B = {b1,b2,b3.b4…bn}单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：这里的拆分线性表与拆分奇偶链表类似。但是，但是这两者有啥不同呢？1
2020-12-19 22:39:18
2078
3
原创 单链表-单链表A拆分为A（偶）和C（奇） （尾插法建表）
题意：有一个整数元素建立的单链表A，设计一个算法，将其拆分成两个链表A 和B，使得链表A中含有所有偶数的结点，B链表中含有所有的奇数结点。且保持原来的相对次序。单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：这里采用新建链表的方法，而题意要求保持相对次序，所以这里采用尾插法建立单链表。这里可以用原来的单链表A的头结点作为新链表的头结点。所有不用再生成一个新头结点。思路：
2020-12-19 22:18:55
3535
3
原创 顺序表-元素逆置（首尾交换）
题意：要求空间复杂度为O(1)顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：这里要实现元素的逆置。想想和单链表的区别。这里如何逆置？ 单链表是如何逆置的？这里是首尾交换元素，常用那个交换操作。而单链表有两种方法，一是头插法，二是修改指针。思路：1.定义循环变量i 和中间变量x,用于交换,这里中间变量注意类型2.通
2020-12-18 22:19:59
1240
1
原创 顺序表-插入一个元素x后保持该顺序表L递增有序排序（查找+元素后移插入）
顺序表的存储结构：typedef struct{ int data[Maxsize]; //存在顺序表中的元素 int length; //存放顺序表的长度 }SqList;分析：要保持插入一个元素后，仍然要保持有序。肯定先要查找插入位置。怎么找插入位置？ 和单链表有什么不同？定义一个位置变量i, 通过循环i++. 而单链表是p = p->next;找到了位置如何插入？这里又和单链表有什么不同？这里是元素后移，让位插入， 而单链表是
2020-12-18 22:08:16
3736
1
原创 单链表-逆置单链表（修改指针指向且三个指针）
题意：采用带头结点的单链表，设计一个算法将其就地逆置，所谓“就地”是指辅助空间O（1）。这里可以有两种方法做：1.头插法且双指针2.改变指针指向且三指针两方法共同点：头结点还是作为头结点。第一个结点作为尾节点。单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：这里先解释第二种方法：改变指针指向且三指针将第一个结点（pre指向）置为空，作为尾节点。然后再改变结点间的
2020-12-17 20:51:41
1040
原创 单链表-逆置单链表（头插法且双指针）
题意：采用带头结点的单链表，设计一个算法将其就地逆置，所谓“就地”是指辅助空间O（1）。这里可以有两种方法做：1.头插法且双指针2.改变指针指向且三指针两方法共同点：头结点还是作为头结点。第一个结点作为尾节点。单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：这里先解释第一种方法：头插法且双指针先将L看成一个空表，让头结点置为空。然后后面的链表元素，利用头插法，一个
2020-12-17 20:38:46
592
原创 单链表-在带头结点的单链表L中删除一个最小值结点（四指针）
单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：要删除一个链表的最小值节点，首先想到的是肯定是要定义两个指针，但是 ，这里首先要找到最小。 所以两个指针变量肯定不够。 肯定是先要找出最小值。那么如何找出最小值呢？这里先定义pre 和p指针,然后定义minp保存最小节点指针（初值为p）,minpre指向*minp节点的前驱节点（初值为pre）。思路:1.定义四个指针变量
2020-12-16 19:49:00
1987
1
原创 单链表-删除单链表L中第一个值为x的结点的前驱结点（三指针法）
单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：首先，我们要删除第一个值为x结点的前驱结点，则该链表要包含两个及以上结点才行。 在前面通常都是删除该节点，而这次是删除该节点的前驱结点。所以不能向以往一样定义两个指针。而应该定义三个指针。prepre , pre ,p;思路：1.定义三个指针prepre = L,pre = prepre->next; p = p
2020-12-16 19:27:01
5302
2
原创 单链表-删除并释放以L为表头指针的单链表的所有结点（双指针法）
单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：要删除所有结点，怎么删除？往往都要定义前后指针 pre ，p 毕竟一个指针不够用。思路：1.定义两个指针pre，p ，其中pre开始指向头结点 （pre = L）.2.通过while循环,首先释放头结点。然后两个指针，同步后移3. 循环跳出后，pre指向最后一个节点，最后把该节点删除C代码实现：void Dest
2020-12-15 22:14:43
1046
原创 单链表-判断单链表L是否是递增的（双指针法）
单链表的存储结构：typedef struct LinkList{int data;LinkList * next;}分析：定义一个指针p够不够用？你要判断是否递增，说明要比较前后两节点的数据域。如果前者一直大于后者，那么可判断该单链表递增。所以这里要定义两个指针，pre ,p.思路：1.定义两个前后指针pre ,p,并pre开始指向头结点2.通过while判断，条件为p ！= null如果pre->data > p->data ,说明为正序，则继续比较下
2020-12-15 22:04:53
4445
2
原创 单链表-删除单链表L中第一个值为x的结点（双指针法）
单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }分析：如果我们用一个指针p ，指向要删除的结点，要删除第一个还好，可以删，如果光一个指针p在中间你怎么删？所以，这里我们要定义两个指针，一个前驱指针pre,一个指针p思路：1.定义两个指针变量pre,p 其中 pre = L, p = pre->next;2.当p不为空时，p->data不等于x时。pr
2020-12-14 22:26:42
4266
原创 二叉树的中序遍历（递归）
中序遍历二叉树的过程如下：二叉树的存储结构： typedef struct node{ int data; struct node * lchild; //指向左孩子的结点 struct node * rchild; //指向右孩子的结点 }BTNode;思路：1.遍历左子树节点2.访问根节点3.遍历右子树节点C代码实现：void InOrder(BTNode * b){ //中序遍历 if(b != null){
2020-12-14 22:11:09
5266
1
原创 二叉树的先序遍历（非递归）
虽然递归简单理解，但是用递归内存开销大，耗时长，性能往往不如非递归方式所以这里通过栈，用非递归方法实现二叉树的先序遍历二叉树的存储结构定义：typedef struct node{ int data; struct node * lchild; //指向左孩子的结点 struct node * rchild; //指向右孩子的结点 }BTNode;思路：（根 右 左，由于要使用栈，会和原本的不同）1，定义一个栈，定义初始化。2.判断二叉树是否为
2020-12-13 21:31:13
6900
2
原创 二叉树的先序遍历（递归）
先序遍历二叉树的过程如下：1.访问根节点2.先序遍历左子树3.先序遍历右子树二叉树的存储结构定义： typedef struct node{ int data; struct node * lchild; //指向左孩子的结点 struct node * rchild; //指向右孩子的结点 }BTNode;思路；1.先判断该树是否为空，不为空则继续2.访问根节点3.调用本函数遍历左子树3.调用本函数遍历右子树C代码实现：void P
2020-12-13 21:12:47
4008
原创 建立循环双链表（尾插法）
该方法是将节点插入在当前循环双链表的表尾上，为此增加一个尾指针r ,并始终指向当前链表的尾节点，最后让r->next 指向头结点。头结点的prior 指向尾节点。注意：这里头结点，尾节点 要相互指向 才是循环双链表双链表的存储结构： typedef strcut DLinkList{ int data; DLinkList *next; DLinkList *prior; }思路；1.创建头结点，并定义一个尾指针r ,始终指向尾结
2020-12-12 22:32:53
2828
1
原创 建立循环双链表（头插法）
该方法从一个空表开始，读取数组a中元素，生成新节点，将读取的数据存在该节点的数据域中，然后将该新节点插入到当前节点的表头上，直到结束为止。双链表的存储结构： typedef strcut DLinkList{ int data; DLinkList *next; DLinkList *prior; }思路：1.创建头结点L,这里是循环链表，注意表头和表尾是相连的2.通过for循环，创建新节点。然后将节点插入在头结点后，首结点之前。注意循环
2020-12-12 22:19:55
1280
2
原创 建立循环单链表（尾插法）
循环链表的操作实现算法与非循环链表的操作算法基本相同，只是对表尾的判断做了改变。定义单链表的存储结构：typedef struct LinkList{ int data; LinkList * next; }思路；（尾插法，定义尾指针）1.建立头结点L.并置为空的循环单链表 ，并定义一个尾指针2.通过for循环，生成新节点，链接到头结点之后，一个接一个。注意：最后要让r->next 指向头结点C代码实现：void CreateClistF(
2020-12-11 23:01:06
3274
空空如也
空空如也
TA创建的收藏夹 TA关注的收藏夹
TA关注的人