2020年07月_vector<>

12月 11月 10月 09月 08月 07月 06月

原创【数据结构】-排序-【2016真题】-划分满足要求的两个子集

1.思路： //划分规则：元素个数尽可能相同，元素值和尽可能相差大，整数集合中不会有相同元素，因此可以按照下面的思路划分 //第一步，将数组A中的所有元素从小到大排序； //第二步，如果是偶数个元素，则前n/2个划分在A1,后n/2个划分在A2；如果是奇数个元素，前n/2向下取整个在A1,后n/2向下取整+1个在A2 //第一种情况元素个数相差0，第二种情况元素个数相差1。2.要使排序效率尽可能高，肯定是快速排序，笔者之前详细写过快速排序的过程，但是答案用的是非递归的快速...

2020-07-28 21:53:52 695

原创【数据结构】-线性表-【2013真题】找出数组的主元

值得注意的是，这个题目就算写出来是n2的时间复杂度，最后给的分数也只扣了一分，所以花大量时间来思考时间复杂度最高的算法是得不偿失的，应该在短时间内精进自己第一时间想到的那个算法。 //思路： //由于ai的取值只可能是0-n-1中中间的整数，因此可以创建一个大小为n的整数数组showtime来记录ai出现的次数 //shotime[j]>n/2说明j就是主元，若找不到这样的j则返回-1. //时间复杂度n;空间复杂度：n答案： //出现的次数大于所有元素...

2020-07-27 21:45:51 788

原创【数据结构】-单链表-【2012真题】-查找共同后缀的起始位置

https://blog.csdn.net/qq_39328436/article/details/106715561与之前做的一个练习题，去单链表的公共节点大同小异。练习题时还写得更加简洁一点。2012年真题思路：分别求得两个链表的长度，长链表长度为longer,短链表长度为shorter,设置两个遍历指针，long和short,长链表从第longer-shorter+1个位置开始，锻炼表从第一个位置开始，同时遍历，当两个指向同一个节点的时候就是目标节点。时间复杂度：主要消耗在求两个单链表

2020-07-26 20:33:57 1207 2

原创【数据结构】-单链表-【2015真题】删除绝对值第二次出现的节点

1.算法思路：创建一个大小为n的数组showtime,标记绝对值出现的次数，并且初试化为0；遍历指针p，以及p的前驱指针pre。遍历单链表，求链表节点绝对值x,以x为下标查找showtime中的值，若showtime[x]=0,则修改showtime[x]为1，并继续遍历若showtime[x]=1时要删除p指针指向的节点。2.单链表节点的数据类型定义：typedef struct LNode{int data;struct LNode* next;}LNode,*LinkList;3

2020-07-25 14:41:45 413

原创【数据结构】-线性表-【2018真题】找出未出现的最小正整数

原本我的思路：创建一个大数组show，表示整数数组是否出现的标记。遍历整数数组，把以该整数为下标的show中的值改为1（如果是负数统一修改0位置上的标记）遍历show,第一个不为1的位置就是答案，时间复杂度为o(n)，空间复杂度由整数数组的最大值决定。虽然把握住了“空间换时间”的精髓，但是未免也要得太多了，发生错误的关键在于，没有把握结果只可能是1-n+1中的一个正整数。int find_min(vector<int> A) { vector<int> B(A..

2020-07-24 17:43:53 1001

原创【数据结构】-单链表-不断删除并输出循环单链表的最小节点

刚开始做这个题目的时候，设置了五个指针，pre_p,p,min.pre_min还有q,用q来做内循环，当p==q的时候标记内循环结束，后来发现多此一举了。既然内循环每次从第一个节点开始，那么内循环结束的标价就是p==L,想得太复杂了。编程注意事项：外循环标记：L->next!=L内循环标记：p!=L;例子如下：...

2020-07-23 14:30:08 226

原创【单链表】-剑指22-2009考研真题-查找链表中倒数第k个位置上的节点

2009统考真题思路很巧妙两个指针：p指针先向前走k步，然后pq一起移动，这样，q永远都在p前面k个位置，所以当p到达链表尾部的时候，q就是尾部之前的k位置，也就是倒数k位置。 bool findTail_K(LinkList List,int k) { LNode *p = List->next; LNode *q = List->next; int step = 0; while (step<k) { p = p->next; .

2020-07-21 20:47:52 1037

原创【数据结构】-单链表-按照递减的顺序合并两个递增的单链表

这道题融汇了单链表编程中的几个重要技巧1.前后指针2.头指针next设置为空，用原始节点组合成新的单链表根据下面这个例子不难看懂 LinkList Re_Con_Sort(LinkList L, LinkList M){ LNode*p = L->next, *q = M->next; LNode *p_rear = NULL; LNode *q_rear = NULL; L->next = NULL; M->ne...

2020-07-20 21:02:00 1178 11

原创【数据结构】-图-用DFS实现拓扑排序-环路检测

void BubbleSort(vector<int> &p, int length,vector<int> &ind_diff){ for (int m = 0; m < length; m++) { ind_diff[m] = m; } for (int i = 0; i < length; i++) { for (int j = 0; j < length - i - 1; j++) { if (p[j] &g.

2020-07-19 20:02:59 3381 9

原创【数据结构】-单链表-将一个单链表奇偶位置节点原地拆分成两个单链表

L=a1,b1,a2,b2,....an,bn返回值：a1,a2,a3,.....an原始单链表：b1,b2,b3..bn LinkList split(LinkList &L) { //分成的两个单链表一个是返回值M,另一个在原始单链表L中 LNode *p = L->next; LNode *q = p->next; LinkList M = (LinkList)malloc(sizeof(LNode)); M->next = ..

2020-07-18 16:28:45 3216 2

原创【数据结构】-图-判断图中是否存在vi到vj的路径

方法一：深度优先，不断向前走，采用递归形式比较简单，下图是递归的例子编程注意事项：1.递归出口：i==j2.判断i到j是否存在路径，把问题化解到最简单的情况，一步一步向前走，能向前迈步的条件是：本次已经有连通路径，并且下一个要加进来的点没被访问过。bool exit_path(ALGraph G, int i, int j) { if (i == j)return true; else { visited[i] = true; for (ArcNode* p = G.

2020-07-16 17:04:28 2968

原创【数据结构】-单链表-按递增顺序输出单链表节点的值

思路：采用最简单的打擂台的办法，题目要求删除节点，因此必须保留前驱。引入遍历指针p,前驱指针pre，最小值指针min,最小值前驱pre_min。（最小值前驱可以省略，但是加入之后会使得程序更加清晰，况且一个指针的内存开销也不大）。编程注意事项：1.教材上最后free(L)了，个人觉得好像没有必要，只要将节点全部删除一直到最后L->next=null即可。2.要明白free(p)干了什么，它只是把p所指向的内存空间交还给了操作系统，并不会将指针变为null,所以建议每次用完free后，手

2020-07-15 17:12:31 2275

原创【数据结构】-排序-基于单链表的简单选择排序

方法一：不进行任何断链插入操作，找到目标节点之后，只是交换data值，这个思路很简单，与简单选择排序的思路一摸一样。编程注意事项：min不能标记最小值，应该要标记最小值对应的链表节点LinkList createLink(LinkList L) { cout << "尾插法创建单链表:"<<endl; int a; L = (LinkList)malloc(sizeof(LinkNode)); L->next = NULL; LinkNode *p=L,

2020-07-12 11:08:18 9898 9

原创【数据结构】-图-输出顶点u到v的所有简单路径

思路：一步一步递归向下走，以下面这个图为例，详细的递归过程如下所示：编程注意事项：1.path数组少为开大一点，避免越界2.一定记得返回之前要把visited恢复3.path和visited要加引用，但是d一定不能加void printPath(vector<int> &path,int d) { for (int i = 0; i <= d; i++) cout << path[i] << " ";...

2020-07-08 11:47:00 4954 11

原创【数据结构】-图-判断一个无向图是否是一棵树

思路：判断一个无向图是否是一棵树，只需要判断该图是否是一个包含n个顶点的连通子图且边数为n-1,只要这两个条件都满足，那么就是一棵树。因此我们可以采用深度遍历，若图连通，那么只要一次深度遍历就可以遍历出所有的顶点，于是只需要调用一次dfs，并设置两个计数器记录边和顶点的数目即可。变成注意事项：邻接表在存储无向图的时，每一条边都存储了两次，所以计数器中得到的是两边的边数void DFS_my(ALGraph &G, int v, int &count_vec, int &a

2020-07-08 09:35:42 8136 6

原创【数据结构】-单链表-判断序列B是否是序列A的连续子序列

算法思路：用两个指针来遍历两个单链表，当节点值相同的时候，两个指针同时向后移动一个位置当节点值不相同的时候，A表的指针继续向后面遍历，B表的指针回到头部重新开始遍历例子如下： bool isSon(LinkList A, LinkList B) { LNode *p,*q; p = A->next; q = B->next; while (p) { if (p->data != q->data) { p = p->n.

2020-07-07 14:29:51 1956 1

原创【数据结构】-排序-快速排序的改进算法

快速排序的最好情况是每一趟排序的基准值都将序列划分成两个长度尽可能一样的序列在默认情况下，我们通常选择第一个元素作为基准值，但是，则会有问题。最坏情况是原序列顺序和逆序的情况，此时基准值左右的序列长度一个是0，一个是n-1即使序列原本就是顺序的，但是快排它无法判断有序，还是不断地做比较；逆序的情况下是不断地比较，不断地移动元素。因此，将基准值的选取对快排的效率有很大的影响，我们用“随机”法和“三数取中”法来选取基准值，这样的方法基本可以避免上述两种最坏的情况发生。编程注意事项：1.c

2020-07-05 09:53:40 735

原创【数据结构】-排序-外部排序总结

1.影响内部排序时间效率的是移动和比较的次数，影响外部排序时间效率的是i/o次数2.减少平衡归并中i/o次数的有两个办法:第一：增大归并路数第二：减少归并段（有序段）个数为了提高效率，我们考虑将归并路数尽可能地增大可是归并路数一旦增大，内部比较的压力就会变大，内部比较效率降低。那么，增大归并路数而提高的时间效率就被内部排序给抵消了。那怎么办呢？有没有可能使得内部排序效率不受归并路数增加的影响呢？这个办法就是“败者树”，用败者树的方法挑选出每一路中的最小值。 ...

2020-07-04 18:00:54 3357

原创【数据结构】-双链表-判断循环单链表是否对称

两个指针分别从双链表的两端向中间遍历奇数个节点时：p==q为出口偶数个节点时：p->next=q为出口编程注意事项：不需要讨论奇数个节点还是偶数个节点，因为以上两种情况并不会同时出现。typedef struct DLNode { int data; struct DLNode *next; struct DLNode *prior;}DLNode, *DLinkList;/*双链表*/DLinkList DList_HeadInsert(DLinkList L)

2020-07-04 17:27:02 834

原创【来不及刷题之】36、删除排序链表中的重复元素 || （快慢指针）

思路:既然是递增有序，那么重复的元素第一是紧挨着一起的。方法：遍历单链表，检查后继节点是否和自己相同，相同则删除后继节点，否则继续遍历出口：没有节点或者只有一个节点的情况下直接return LinkList DeleteSame(LinkList L) { if (L == NULL||L->next==NULL)return L; LNode*p = L,*q=p; while (p) { q = p->next; if (q && (p-

2020-07-03 22:51:19 2323

原创【数据结构】-排序-内排序总结

1.时间复杂度总结n2: 直接插入排序，冒泡排序，简单选择排序（这三种里面直接插入排序好一点）nlogn: 快速排序，堆排序，归并排序n: 基数排序其他：n22.时间性能与初始序列无关：口诀：“一堆乌龟选基友”堆排序，归并排序，选择排序，基数排序3.空间性能：快速排序：logn归并排序：n基数排序：rd其他：14.不稳定的有：口诀：尔快选（你快选！！）希尔排序，快速排序，选择排序两个选择排序都...

2020-07-02 17:42:32 604 2

原创【数据结构】-排序-基数排序

关于基数排序要记住1.唯一不基于比较的内排序2.唯一时间复杂度在线性级别的内排序3.稳定4.事件复杂度与初始状态无关基数排序的思想：先分配后收集类别排序方法最好时间最坏时间平均时间空间复杂度稳定性序列特征适用于基数排序 .

2020-07-02 17:37:11 403

原创【数据结构】-排序-归并排序

归并的思想是：将两个已经有序的序列合并成一个有序的序列，这也是归并排序的核心算法。合并low-mid以及mid+1-high两个序列，需要开辟一个等长的临时序列，所以空间复杂度是所有排序算法中最高的n 类别排序方法最好时间最坏时间平均时间空间复杂度稳定性序列特征适用于归并排序

2020-07-02 16:32:39 329 6

原创【数据结构】-排序-堆排序

堆的操作有以下几种：1.建堆2.删除（删除根节点，将根节点与最后一个节点替换，调整剩下的节点为堆）3.插入（放入堆尾，从下向上调整为新堆）其中与堆排序有关的是第一个，第二个操作堆排序算法由三个部分组成1.从某个节点开始向下调整堆AdjustHeap2.建堆：实际上就是从n/2个位置开始，逐个调用AdjustHeap,因为n/2是第一个非叶子节点的序号，所有的叶子节点都已经满足堆的定义了，所以所有的叶子节点都不需要调整。时间复杂度n。下面用一个例子说明调整堆的过程3.输有序

2020-07-01 16:49:39 460

原创【数据结构】-排序-简单选择排序

简单选择排序真的很简单------so:无论什么情况下时间复杂度都很高，而且还不稳定原因是，即使有序，也还是要比较很多次编程注意事项：1.外循环是n-1轮，剩下最后一个元素大的时候就不需要比较了2. 在无序序列中寻找最小值的办法是打擂台void SelectSort(vector<int> a) { int k, temp; for (int i = 1; i < a.size() - 1; i++) { k = i; for (int j = i +

2020-07-01 14:20:51 493