qq_46672746的博客

链表的基本操作单链表单链表#include <stdio.h>#include <stdlib.h> // malloctypedef int ElemType;/* 单链表 */ typedef struct LNode{ ElemType data; LNode *next;}LNode, *LinkList;/* 头插法建立单链表 逆向建立 */LinkList List_HeadInsert(LinkList &L){ LNode

3、随机产生100 个整数构成的序列,分别以直接插入、希尔、快速、归并等排序算法排序,并统计各自的比较次数#include <iostream>using namespace std;typedef int KeyType;typedef int InfoType;# define Maxsize 200 //待排序序列中记录的最大个数# define T 7int InsertSortCount = 0, ShellSortCount = 0, QSortCount =

文章目录java-数组赋值java-交换最小完全平方数java-数组赋值int [] d = {88,99,100};java-交换import java.util.Scanner;public class Main { public static void main(String[] args) { Scanner input = new Scanner(System.in); int s[] = new int[2]; s[0] =

文章目录十进制转十六进制十六进制转十进制方法1方法2方法3-1方法3-2方法3-3十进制转十六进制import java.math.BigInteger;import java.util.*;/**输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647输出格式　　输出这个整数的16进制表示** */public class Main { public static String zhuan(int a){ StringBuf

文章目录先序创建二叉树二叉树的中序、后须、层次遍历二叉排序树的建立先序创建二叉树/*二叉链表存储结构*/typedef struct BiTNode { TElemType data; struct BiTNode* lchid, * rchid;}BiTNode,*BiTree;/*先序创建二叉树*/BiTree CreateBiTree(){ BiTree T;//根节点 TElemType item; cin >> item;

第一章 线性表第二章 栈与队列第三章 树与二叉树第四章 图第五章 查找第六章 排序

一、静态查找表1.1 顺序表查找1.2 有序表查找1.2 .1折半查找（二分查找）优点：查找的效率高缺点：已排好序，只适用于顺序存储例题：随机产生80 个整数构成的递增序列，使用折半查找算法查找指定的整数，并统计比较次数。提示：可用 a[i] = a[i-1] + rand() % 10 + 1 产生递增序列。 (1,10-1+1)/** rand() % n +a; 其中的a是起始值，n-1+a是终止值，n是整数的范围 */#include &

文章目录一、图的存储结构有向图的邻接矩阵存储无向图的邻接表存储二、图的遍历2.1 深度优先搜索（DFS）2.2 广度优先搜索（BFS）三、图的连通性3.1 连通分量和生成树3.2 最小生成树普里姆(Prim)算法克鲁斯卡尔 (Kruskal) 算法四、有向无环图及其应用拓扑排序关键路径五、最短路径一、图的存储结构有向图的邻接矩阵存储//邻接矩阵typedef struct{ VertexType vexs[MAX_VERTAX_NUM]; AdjMatrix arcs[MAX_VERTAX_N

文章目录二、图的遍历2.1 深度优先搜索（DFS）DFS森林应用2.2 广度优先搜索（BFS）基本操作应用二、图的遍历2.1 深度优先搜索（DFS）DFS森林Vertextype GetVex(ALGraph G, int v){ return G.vertices[v].data;}void DFSTree(ALGraph G, int v, CSTree& T){ int w, first; CSTree p, q=NULL; ArcNode*

文章目录一、栈栈的实现顺序栈栈的应用1.数制转换(十进制转换为R进制)2.括号匹配的检验二、队列队列的实现1.队列的链式表示和实现2.循环队列-队列的顺序表示和实现队列的应用1.用循环队列模拟银行窗口排队一、栈栈的实现顺序栈#include <iostream>using namespace std;#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1 //不可执行#de

文章目录一、顺序表二、链表一、顺序表初始化、赋值、插入、删除、输出、有序合并#include <iostream>#include <string>using namespace std;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10/*数组定义*/typedef struct { ElemType* elem;//首地址 int length;

文章目录直接插入排序希尔排序归并排序快速排序应用直接插入排序一个一个逐步插入//直接插入排序void InsertSort(SqList& L){ int i, j; for (i = 2; i <= L.length; i++) { InsertSortCount++; if (L.r[i].key < L.r[i - 1].key) //小于时,将R[i]插入有序表 { L.r[0] = L.r[i]; // R[0]作监测哨兵 L.r[i

文章目录题解分析java-queuemap-containsKey()map-put()map-get()题解分析给定骑士在棋盘上的 初始 位置(一个2进制矩阵 0 表示空 1 表示有障碍物)，找到到达 终点 的最短路线，返回路线的长度。如果骑士不能到达则返回 -1 。起点跟终点必定为空.骑士不能碰到障碍物.路径长度指骑士走的步数.样例例1:输入:[[0,0,0], [0,0,0], [0,0,0]]source = [2, 0] destination = [2, 2] 输出:

文章目录一、字符串的一些常用方法二、键盘输入未知的多行字符串1.以空行结束2.以EOF结束一、字符串的一些常用方法#include<iostream>#include<fstream>using namespace std;int main(){ string str; cin >> str; int count[100] = { 0 }; /*输出字符串*/ cout << "输出字符串方法1:" <&l

文章目录十进制转十六进制十六进制转十进制方法1方法2方法3-1方法3-2方法3-3java-数组赋值java-交换最小完全平方数十进制转十六进制import java.math.BigInteger;import java.util.*;/**输入包含一个非负整数a，表示要转换的数。0<=a<=2147483647输出格式　　输出这个整数的16进制表示** */public class Main { public static String zhuan(in

一、顺序表初始化、赋值、插入、删除、输出、有序合并#include <iostream>#include <string>using namespace std;typedef int ElemType;#define LIST_INIT_SIZE 100#define LISTINCREMENT 10/*数组定义*/typedef struct { ElemType* elem;//首地址 int length;//当前长度 int

文章目录1.给定出生年月日及现在年月日，计算天数2.指定年月日距离1990年1月1日的天数及小时3.计算某年某月某日是本年度第几天4.给出年月日，计算该日是星期几5.给出年份，计算元旦那天是星期几总结1.给定出生年月日及现在年月日，计算天数思想：计算由两部分组成1.现在年到出生年是几年，并算出这些年的天数之和2.现在月日距出生月日的天数完整代码：#include <stdio.h>int main(){ int sum_day(int, int); //? int lea

文章目录大整数的存储比较大小高精度加法高精度减法高精度乘法高精度除法完整代码演示（加法）大整数的存储定义结构体struct bign{ int d[1000]; int len; bign(){ memset(d, 0, sizeof(d)); len = 0; }};将整数转换为bignbign change(char str[]){ bign a; a.len = strlen(str); for(int i=0; i<a.len; i++)

文章目录A小x的奇遇-adventureB数位dp-dpA小x的奇遇-adventure#include <cstdio>const int N = 1e6 + 5;int tot, p[N];bool flg[N];void sieve(int n){ for(int i=2; i<=n; i++){ if(!flg[i]){ p[++tot] = i; } for(int j=1; j<=tot&&i*p[j]<=

文章目录树排序树叶子节点数=度为2的节点数+1总叶子节点数=叶子节点数+度为1的节点数+度为2的节点数排序栗子：一组记录的排序码为（46，79，56，38，40，84），一趟排序的结果为（40，38，46，56，79，84），则采用的是（）排序算法。A选项起泡算法：相邻元素两两比较，一个元素大于右侧相邻元素交换位置，否则位置不变。 一趟排序为：46，56，38，40，79，84B选项直接插入：每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。一

目录-----------------8.28-----------------------16、最接近的三数之和18.四数之和209、长度最小的子数组39、组合总和-----------------8.28-----------------------16、最接近的三数之和class Solution { public int threeSumClosest(int[] nums, int target) { Arrays.sort(nums); int n

文章目录210.课程表II207.课程表210.课程表IIclass Solution { // 存储有向图 List<List<Integer>> edges; // 标记每个节点的状态：0=未搜索，1=搜索中，2=已完成 int[] visited; // 用数组来模拟栈，下标 n-1 为栈底，0 为栈顶 int[] result; // 判断有向图中是否有环 boolean valid = true;

文章目录3.无重复字符的最长子串3.无重复字符的最长子串class Solution { public int lengthOfLongestSubstring(String s) { // 哈希集合，记录每个字符是否出现过 Set<Character> occ = new HashSet<Character>(); int n = s.length(); // 右指针，初始值为 -1，相当于我们在字符

目录2.两数相加2.两数相加/** * Definition for singly-linked list. * public class ListNode { * int val; * ListNode next; * ListNode(int x) { val = x; } * } */class Solution { public ListNode addTwoNumbers(ListNode l1, ListNode l2) { Lis

目录632.最小区间(没懂）632.最小区间(没懂）/** * Note: The returned array must be malloced, assume caller calls free(). */#define maxn 100005int heap[maxn];int heap_count;int **rec, *nx;bool heap_comp(int *first, int *second) { //返回0 1 return rec[*first][

思路：int integerBreak(int n) { int dp[n + 1]; memset(dp, 0, sizeof(dp)); //初始化 for (int i = 2; i <= n; i++) { int curMax = 0; for (int j = 1; j < i; j++) { //递归 curMax = fmax(curMax, fmax(j * (i - j), j * dp[.

/*本题询问的是，ss 是否是 tt 的子序列，因此只要能找到任意一种 ss 在 tt 中出现的方式，即可认为 ss 是 tt 的子序列。而当我们从前往后匹配，可以发现每次贪心地匹配靠前的字符是最优决策。这样，我们初始化两个指针 ii 和 jj，分别指向 ss 和 tt 的初始位置。每次贪心地匹配，匹配成功则 ii 和 jj 同时右移，匹配 ss 的下一个位置，匹配失败则 jj 右移，ii 不变，尝试用 tt 的下一个字符匹配 ss。最终如果 ii 移动到 ss 的末尾，就说明 ss 是 .

目录26.删除排序数组中的重复项27.移除元素53.最大子序和26.删除排序数组中的重复项int removeDuplicates(int* nums, int numsSize){ if(numsSize==0){ return 0; } int i = 0,j; for(j=1; j<numsSize; j++){ if(nums[j]!=nums[i]){ i++; nums

const int dirs[4][2] = {{-1, 0}, {1, 0}, {0, -1}, {0, 1}};int rows, columns; //定义最终返回的最长递增路劲数组的行、列int longestIncreasingPath(int** matrix, int matrixSize, int* matrixColSize) { //主 if (matrixSize == 0 || matrixColSize[0] == 0) { return 0; ..

bool check(int* nums, int numsSize, int m, int x) { long long sum = 0; //当前分割子数组的和 int cnt = 1; //已经分割出的子数组的数量（包括当前子数组） for (int i = 0; i < numsSize; i++) { if (sum + nums[i] > x) { cnt++; sum = nums[i];..

两数之和1.两数之和题目：给定一个整数数组 nums 和一个目标值 target，请你在该数组中找出和为目标值的那 两个 整数，并返回他们的数组下标。你可以假设每种输入只会对应一个答案。但是，数组中同一个元素不能使用两遍。示例:给定 nums = [2, 7, 11, 15], target = 9因为 nums[0] + nums[1] = 2 + 7 = 9所以返回 [0, 1]代码：/** * Note: The returned array must be malloced

题解C_1int* twoSum(int* numbers, int numbersSize, int target, int* returnSize){ int i, j, flg = 0; for (i = 0; i < numbersSize - 1; i++){ for (j = i + 1; j < numbersSize; j++){ if (numbers[i] + numbers[j] == target){ .

题解Javaclass Solution { public int[][] rec; public int[] val; public int maxCoins(int[] nums) { int n = nums.length; val = new int[n + 2]; for (int i = 1; i <= n; i++) { val[i] = nums[i - 1]; }.

思路如果堆中石头的数量 nn 不能被 44 整除，那么你总是可以赢得 Nim 游戏的胜利。推理让我们考虑一些小例子。显而易见的是，如果石头堆中只有一块、两块、或是三块石头，那么在你的回合，你就可以把全部石子拿走，从而在游戏中取胜。而如果就像题目描述那样，堆中恰好有四块石头，你就会失败。因为在这种情况下不管你取走多少石头，总会为你的对手留下几块，使得他可以在游戏中打败你。因此，要想获胜，在你的回合中，必须避免石头堆中的石子数为 4 的情况。同样地，如果有五块、六块、或是七块石头，你可以控制自己拿取的.

题解_Javaclass Solution { public boolean isInterleave(String s1, String s2, String s3) { //t: target int n = s1.length(), m = s2.length(), t = s3.length(); //长度之和都不等，肯定无法由s1和s2交替组成s3 if (n + m != t) { return false; } .

题解C/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */# define min(A,B) ((A)<(B)?(A):(B))int minDepth(struct TreeNode* root){ if(root==NULL){ .

题解C/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */struct TreeNode* invertTree(struct TreeNode* root){ // 边界检查 if (root == NULL) { ret.

题解_C/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; *///方法一：递归法//1,定位根节点//2,根节点左边作为左支递归处理//3,根节点右边作为右支递归处理struct TreeNode* sortedArrayToBST(int* num.

题解_C：/** * Definition for a Node. * struct Node { * int val; * int numChildren; * struct Node** children; * }; */int* maxDepth(struct Node* root) { if(!root){ return 0; } int max = 0; int i; for(i=0; i<.

先介绍一下二叉搜索树：二叉搜索树是一棵二叉树，每个节点都有以下特征：大于左子树上任意一个节点的值小于右字树上任意一个节点的值一个二叉搜索树的例子：题解_C语言_递归:/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */struct Tre.