├── README.md ├── Shell └── README.md ├── 数据库 └── README.md └── 算法 ├── 001_两数之和 ├── Solution01.c ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 002_两数相加 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 003_无重复字符的最长子串 ├── Solution01.c ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 004_寻找两个有序数组的中位数 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 005_最长回文子串 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 006_Z字形变换 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 007_整数翻转 ├── Solution1_CPP.cpp ├── make.cmd ├── result.txt └── test.exe ├── 009_回文数 ├── Solution1_CPP.cpp ├── make.cmd ├── result.txt └── test.exe ├── 013_罗马数字转整数 ├── Solution1_CPP.cpp └── make.cmd ├── 017_电话号码的字母组合 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 020_有效的括号 ├── Solution1.cpp ├── make.cmd ├── result.txt └── test.exe ├── 021_合并两个有序链表 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 022_括号生成 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 024_两两交换链表中的节点 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 026_从排序数组中删除重复项 ├── Solution01.c ├── Solution02.c ├── make.cmd ├── result.txt └── test.exe ├── 028_实现strStr() ├── Solution01.c └── 手稿.md ├── 034_在排序数组中查找元素的第一个和最后一个位置 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── Solution04.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 035_搜索插入位置 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 037_解数独 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 039_组合总和 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 040_组合总和 II ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 046_全排列 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 047_全排列Ⅱ ├── Solution01.cpp ├── Solution02.cpp ├── 个人笔记.c ├── 手稿.md ├── 手稿_V1.0.pdf └── 请教内容.txt ├── 048_旋转图像 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 051_N皇后 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 052_N皇后Ⅱ ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 053_最大子序和 ├── Solution01.cpp ├── Solution02.cpp └── 手稿.md ├── 054_螺旋矩阵 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 058_最后一个单词的长度 └── Solution01.c ├── 059_螺旋矩阵 II ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 060_第k个排列 ├── Solution01.cpp ├── Soulutin02.cpp └── 手稿.md ├── 066_加一 ├── Solution01.c ├── 手稿.md └── 手稿V1.0.pdf ├── 067_二进制求和 ├── Solution01.c └── make.cmd ├── 073_矩阵置零 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── Solution04.cpp ├── 手稿.md ├── 手稿_V1.0.pdf ├── 手稿_V1.1.pdf └── 手稿_V1.2.pdf ├── 077_组合 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 078_子集 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 079_单词搜索 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 083_删除排序链表中的重复元素 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 088_合并两个有序数组 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 089_格雷编码 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── Solution04.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 090_子集 II ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 092_验证二叉搜索树 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 093_复原IP地址 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 1002_查找常用字符 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1008_先序遍历构造二叉树 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1009_十进制整数的反码 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 100_相同的树 └── Solution01.c ├── 1013_将数组分成和相等的三个部分 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1018_可被5整除的二进制前缀 └── Solution01.c ├── 101_对称二叉树 ├── Solution01.c ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1021_删除最外层的括号 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 1022_从根到叶的二进制数之和 └── Solution01.c ├── 1025_除数博弈 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 1026_节点与其祖先之间的最大差值 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 102_二叉树的层次遍历 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1030_距离顺序排列矩阵单元格 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1046_最后一块石头的重量 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1047_删除字符串中的所有相邻重复项 └── Solution01.c ├── 104_二叉树的最大深度 ├── Solution01.cpp ├── Solution02.c └── 手稿.md ├── 1051_高度检查器 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1079_活字印刷 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 107_二叉树的层次遍历2 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1089_复写零 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 109_有序链表转换二叉搜索树 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1103_分糖果 II ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1108_IP地址无效化 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 110_平衡二叉树 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 111_二叉树的最小深度 └── Solution01.c ├── 1122_数组的相对排序 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 112_路径总和 └── Solution01.c ├── 1137_第N个泰波那契数 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 114_二叉树展开为链表 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1154_一年中的第几天 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 1160_拼写单词 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1161_最大层内元素和 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1185_一周中的第几天 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1189_“气球” 的最大数量 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 118_杨辉三角 ├── Solution01.cpp ├── Solution02.c ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 119_杨辉三角2 ├── Solution01.cpp ├── Solution02.c ├── Solution03.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 1200_最小绝对差 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1207_独一无二的出现次数 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1219_黄金矿工 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1221_分割平衡字符串 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 125_验证回文串 ├── Solution01.c └── Solution02.c ├── 1261_在受污染的二叉树中查找元素 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1281_整数的各位积和之差 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1282_用户分组 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1290_二进制链表转整数 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1295_统计位数为偶数的数字 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 1299_将每个元素替换为右侧最大元素 ├── Soulution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1302_层数最深叶子节点的和 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1304_和为零的N个唯一整数 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 1305_两棵二叉搜索树中的所有元素 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1313_解压缩编码列表 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1315_祖父节点值为偶数的节点和 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 131_分割回文串 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 1323_6和9组成的最大数字 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 136_只出现一次的数字 └── Solution01.c ├── 137_只出现一次的数字 II ├── Solution01.cpp └── 手稿.md ├── 144_二叉树的前序遍历 ├── Solution01.c └── Solution02.cpp ├── 145_二叉树的后序遍历 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 167_两数之和 II - 输入有序数组 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 168_Excel表列名称 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 169_求众数 ├── Solution01.c ├── Solution02.c ├── Solution03.c ├── Solution04.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 172_阶乘后的零 ├── Solution01.c ├── Solution02.c └── 手稿.md ├── 189_旋转数组 ├── Solution_01.c ├── Solution_02.c ├── make.cmd ├── result.txt └── test.exe ├── 190_颠倒二进制位 └── Solution01.c ├── 191_位1的个数 ├── Solution01.c ├── Solution02.c ├── Solution03.c ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 199_二叉树的右视图 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 203_移除链表元素 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 204_计算质数个数 ├── Solution01.c └── 状态_未完成.txt ├── 206_反转链表 ├── Solution_01.cpp ├── Solution_02.cpp ├── Solution_03.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 212_单词搜索 II ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 216_组合总和 III ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 217_存在重复元素 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 219_存在重复元素 II ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── Solution04.cpp ├── 手稿.md ├── 手稿_V1.0.pdf ├── 手稿_V1.1.pdf └── 手稿_V1.2.pdf ├── 222_完全二叉树的节点个数 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 226_翻转二叉树 ├── Solution01.c ├── Solution02.c └── 手稿.md ├── 230_二叉搜索树中第K小的元素 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 231_2的幂 └── Solution01.c ├── 235_二叉搜索树的最近公共祖先 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 237_删除链表中的节点 ├── Solution01.c ├── Solution02.c ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 242_有效的字母异位词 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 257_二叉树的所有路径 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 258_各位相加 └── Solution01_CPP.cpp ├── 260_只出现一次的数字III ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 263_丑数 └── Solution01.c ├── 268_缺失数字 └── Solution01.c ├── 278_第一个错误的版本 ├── Solution01.c ├── Solution02.c ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 287_寻找重复数 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── Solution04.cpp ├── Solution05.cpp └── 手稿.md ├── 289_生命游戏 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 292_Nim游戏 └── Solution01.c ├── 328_奇偶链表 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 342_4的幂 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 344_反转字符串 └── Solution01.c ├── 345_反转字符串中的元音字母 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 349_两个数组的交集 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 350_两个数组的交集 II ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 357_计算各个位数不同的数字个数 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 367_有效的完全平方数 └── Solution01.c ├── 374_猜数字大小 └── Solution01.c ├── 387_字符串中的第一个唯一字符 ├── Solution01.c ├── 手稿.md └── 手稿V1.0.pdf ├── 389_找不同 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 401_二进制手表 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 404_左叶子节点求和 └── Solution01.c ├── 414_第三大的数 └── Solution01.c ├── 415_字符串相加 ├── Solution01.c └── make.cmd ├── 423_从英文中重建数字 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 429_N叉树的层序遍历 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 434_字符串中的单词数 └── Solution01.c ├── 437_路径总和3 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 441_排列硬币 ├── Soluion01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 442_数组中重复的数据 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 448_找到所有数组中消失的数字 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 451_根据字符出现频率排序 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 461_汉明距离 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 476_数字的补数 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 477_汉明距离总和 ├── Solution01.c ├── Solution02.c ├── Solution03.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 485_最大连续1的个数 ├── Solution01.c ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 496_下一个更大元素1 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 500_键盘行 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 504_七进制数 └── Solution01.c ├── 5079_三个有序数组的交集 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 513_找树左下角的值 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 526_优美的排列 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 535_TinyUrl的加密和解密 ├── Solution01.cpp └── 手稿.md ├── 537_复数乘法 ├── Solution01.cpp ├── Solution02.c ├── Solution03.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 540_有序数组中的单一元素 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 557_反转字符串中的单词 └── Solution01.c ├── 559_N叉树的最大深度 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 561_数组拆分 I ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 566_重塑矩阵 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 572_另一个树的子树 └── Solution01.c ├── 589_N叉树的前序遍历 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 590_N叉树的后序遍历 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 617_合并二叉树 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 633_平方数之和 └── Solution01.c ├── 637_二叉树的层平均值 ├── solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 647_回文子串 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 654_最大二叉树 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 657_机器人能否返回原点 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 661_图片平滑器 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 665_非递减数列 ├── solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 690_员工的重要性 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 693_交替位二进制数 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 700_二叉搜索树中的搜索 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 701_二叉搜索树中的插入操作 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 703_数据流中的第K大元素 ├── Solution01.cpp └── 手稿.md ├── 709_转换成小写字母 ├── C_Solution_01.c ├── C_Solution_02.c └── C_Solution_03.c ├── 728_自除数 └── Solution01.c ├── 747_至少是其他数字两倍的最大数 ├── Readme.txt ├── Solution01.c └── Solution02.c ├── 771_宝石与石头 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 784_字母的大小写全排列 ├── Solution01.c ├── Solution02.c ├── Solution03.cpp ├── 手稿.md ├── 手稿_V1.1.pdf └── 手稿_V1.2.pdf ├── 788_旋转数字 ├── Solution01.cpp ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 797_所有可能的路径 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 804_唯一摩尔斯密码词 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 807_保持城市天际线 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 814_二叉树剪枝 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 821_字符的最短距离 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 832_翻转图像 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 836_矩形重叠 ├── Solution01.c └── Solution02.c ├── 844_比较含退格的字符串 ├── Solution01.cpp ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 852_山脉数组的峰顶索引 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 859_亲密字符串 └── Solution01.c ├── 861_翻转矩阵后的得分 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 867_转置矩阵 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 868_二进制间距 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 872_叶子相似的树 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 876_链表的中间结点 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 897_递增顺序查找树 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 905_按奇偶排序数组 └── Solation01.c ├── 917_仅仅反转字母 └── Solution01.c ├── 921_使括号有效的最少添加 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 922_按奇偶排序数组II └── Solution01.c ├── 938_二叉搜索树的范围和 ├── Solution01.c ├── Solution02.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 942_增减字符串匹配 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 961_重复 N 次的元素 ├── Solution01.c ├── Solution02.c └── make.cmd ├── 965_单值二叉树 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 973_最接近原点的 K 个点 ├── Solution01.cpp ├── Solution02.cpp ├── 手稿.md ├── 手稿_V1.0.pdf └── 手稿_V1.1.pdf ├── 976_三角形的最大周长 ├── Solution01.c ├── Solution02.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 977_有序数组的平方 └── Solution01.c ├── 980_不同路径 III ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── 989_数组形式的整数加法 ├── Solution01.c ├── 手稿.md └── 手稿_V1.0.pdf ├── 993_二叉树的堂兄弟节点 └── Solution01.c ├── 994_腐烂的橘子 ├── Solution01.cpp ├── 手稿.md └── 手稿_V1.0.pdf ├── LCP0001_猜数字 ├── Solution01.cpp └── 手稿.md ├── README.md └── 面试题10.01_合并排序的数组 ├── Solution01.cpp ├── Solution02.cpp ├── Solution03.cpp ├── 手稿.md └── 手稿_V1.0.pdf /README.md: -------------------------------------------------------------------------------- 1 | # LeetCodeStudy 2 | + 2020年工作重心转移，由2019年的一天刷一题，变为2020年的一周刷一题。 3 | + 2020.01.13 4 | 5 | *** 6 | 7 | + 在 [力扣中国](https://leetcode-cn.com) 上解题代码备份 8 | + 根据LeetCode上的三个分类,建立了Shell、数据库和算法共计三个文件夹,主要更新算法文件夹,Shell和数据库留坑不填; 9 | + 不得加入其它无关内容 10 | + 2019.05.05 11 | 12 | -------------------------------------------------------------------------------- /Shell/README.md: -------------------------------------------------------------------------------- 1 | # LeetCodeStudy - Shell 2 | + 在 https://leetcode-cn.com 上解题代码备份 3 | + Shell文件夹，本文件夹留坑不填. 4 | + 不得加入其它无关内容 5 | + 2019.05.05 6 | -------------------------------------------------------------------------------- /数据库/README.md: -------------------------------------------------------------------------------- 1 | # LeetCodeStudy - 数据库 2 | + 在 https://leetcode-cn.com 上解题代码备份 3 | + 数据库文件夹，本文件夹留坑不填. 4 | + 不得加入其它无关内容 5 | + 2019.05.05 6 | -------------------------------------------------------------------------------- /算法/001_两数之和/Solution01.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Note: The returned array must be malloced, assume caller calls free(). 3 | */ 4 | int* twoSum( int* nums , 5 | int numsSize , 6 | int target , 7 | int* returnSize 8 | ) 9 | { 10 | int i = 0 ; 11 | int j = 0 ; 12 | int* index = (int*)malloc(2*sizeof(int)) ; 13 | int valid = 0 ; 14 | 15 | 16 | for(i = 0; i < numsSize ;i++) 17 | { 18 | for(j=i+1;j twoSum(vector& nums, int target) 5 | { 6 | vector ret_val ; 7 | map mii ; 8 | int i = 0 ; 9 | 10 | for(i=0;i>result.txt 5 | pause -------------------------------------------------------------------------------- /算法/007_整数翻转/result.txt: -------------------------------------------------------------------------------- 1 | 0 2 | 0 3 | -11 4 | 1463847412 0 5 | 0 6 | -11 7 | 1463847412 8 | -------------------------------------------------------------------------------- /算法/007_整数翻转/test.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/007_整数翻转/test.exe -------------------------------------------------------------------------------- /算法/009_回文数/make.cmd: -------------------------------------------------------------------------------- 1 | del test.exe 2 | del result.txt 3 | gcc Solution1_CPP.cpp -o test.exe -lstdc++ 4 | test.exe >>result.txt 5 | pause -------------------------------------------------------------------------------- /算法/009_回文数/result.txt: -------------------------------------------------------------------------------- 1 | 0 2 | 1 3 | 0 4 | 1 5 | -------------------------------------------------------------------------------- /算法/009_回文数/test.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/009_回文数/test.exe -------------------------------------------------------------------------------- /算法/013_罗马数字转整数/make.cmd: -------------------------------------------------------------------------------- 1 | del test.exe 2 | del result.txt 3 | gcc Solution1_CPP.cpp -o test.exe -lstdc++ 4 | test.exe >>result.txt 5 | pause -------------------------------------------------------------------------------- /算法/017_电话号码的字母组合/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/017_电话号码的字母组合/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/020_有效的括号/make.cmd: -------------------------------------------------------------------------------- 1 | del result.txt 2 | del test.exe 3 | gcc solution1.cpp -o test.exe -lstdc++ 4 | test.exe >> result.txt 5 | pause -------------------------------------------------------------------------------- /算法/020_有效的括号/result.txt: -------------------------------------------------------------------------------- 1 | 1 2 | -------------------------------------------------------------------------------- /算法/020_有效的括号/test.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/020_有效的括号/test.exe -------------------------------------------------------------------------------- /算法/021_合并两个有序链表/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/021_合并两个有序链表/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/022_括号生成/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/022_括号生成/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/024_两两交换链表中的节点/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/024_两两交换链表中的节点/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/026_从排序数组中删除重复项/make.cmd: -------------------------------------------------------------------------------- 1 | del test.exe 2 | del result.txt 3 | gcc Solution02.c -o test.exe -lstdc++ 4 | test.exe >>result.txt 5 | pause -------------------------------------------------------------------------------- /算法/026_从排序数组中删除重复项/result.txt: -------------------------------------------------------------------------------- 1 | 112 2 | 113 3 | 114 4 | 114 5 | 115 6 | -------------------------------------------------------------------------------- /算法/026_从排序数组中删除重复项/test.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/026_从排序数组中删除重复项/test.exe -------------------------------------------------------------------------------- /算法/034_在排序数组中查找元素的第一个和最后一个位置/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector searchRange(vector& nums, int target) 5 | { 6 | vector vi(2,-1); 7 | 8 | if(nums.size() < 1) 9 | { 10 | return vi; 11 | } 12 | 13 | if(nums[0]== target) 14 | { 15 | vi[0] = 0; 16 | } 17 | 18 | if(nums[nums.size()-1]== target) 19 | { 20 | vi[1] = nums.size()-1; 21 | } 22 | 23 | for(int i = 1 ; i < nums.size();i++) 24 | { 25 | if(nums[i]==target && nums[i-1]!=target ) 26 | { 27 | vi[0] = i; 28 | } 29 | 30 | if(nums[i]!=target && nums[i-1]==target ) 31 | { 32 | vi[1] = i-1; 33 | break; 34 | } 35 | 36 | } 37 | return vi; 38 | } 39 | }; 40 | 41 | /* 42 | https://leetcode-cn.com/submissions/detail/38742435/ 43 | 执行结果： 44 | 通过 45 | 显示详情 46 | 执行用时 :20 ms, 在所有 cpp 提交中击败了10.54% 的用户 47 | 内存消耗 :10.1 MB, 在所有 cpp 提交中击败了93.37%的用户 48 | */ -------------------------------------------------------------------------------- /算法/034_在排序数组中查找元素的第一个和最后一个位置/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/034_在排序数组中查找元素的第一个和最后一个位置/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/035_搜索插入位置/Solution01.c: -------------------------------------------------------------------------------- 1 | int searchInsert(int* nums, int numsSize, int target) 2 | { 3 | int i = 0; 4 | 5 | if(target <= nums[0]) 6 | { 7 | return 0; 8 | } 9 | 10 | if(target > nums[numsSize-1]) 11 | { 12 | return numsSize; 13 | } 14 | 15 | for(i=1;i nums[numsSize-1]) 15 | { 16 | return numsSize; 17 | } 18 | 19 | while(left<=right) 20 | { 21 | mid = left + (right-left)/2; /*防止加法溢出*/ 22 | temp1 = nums[mid]; 23 | if( temp1 > target) 24 | { 25 | right = mid - 1; 26 | continue; 27 | } 28 | else if(temp1==target) 29 | { 30 | return mid; 31 | } 32 | else 33 | { 34 | if(nums[mid+1]>=target) 35 | { 36 | return mid + 1; 37 | } 38 | else 39 | { 40 | left = mid + 1; 41 | } 42 | } 43 | } 44 | return -1;/* Anti warnning ,若在这里返回,那输入一定有问题.*/ 45 | } 46 | 47 | /* 48 | 执行结果： 49 | 通过 50 | 显示详情 51 | 执行用时 :4 ms, 在所有 C 提交中击败了99.87% 的用户 52 | 内存消耗 :7.3 MB, 在所有 C 提交中击败了66.60%的用户 53 | */ 54 | -------------------------------------------------------------------------------- /算法/035_搜索插入位置/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/035_搜索插入位置/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/037_解数独/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/037_解数独/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/039_组合总和/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/039_组合总和/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/040_组合总和 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/040_组合总和 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/046_全排列/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/046_全排列/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/046_全排列/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/046_全排列/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/047_全排列Ⅱ/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/047_全排列Ⅱ/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/047_全排列Ⅱ/请教内容.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/047_全排列Ⅱ/请教内容.txt -------------------------------------------------------------------------------- /算法/048_旋转图像/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | void rotate(vector>& matrix) 5 | { 6 | int rows = matrix.size(); 7 | int cols = rows; 8 | int i = 0; 9 | int j = 0; 10 | 11 | /*1.按行中心对折*/ 12 | for(i = 0 ; i < rows/2 ; i++) 13 | { 14 | swap(matrix[i],matrix[rows-1-i]); 15 | } 16 | 17 | /*2.转置*/ 18 | for(i = 0 ; i < rows ; i++) 19 | { 20 | for(j=i+1;j& nums) 5 | { 6 | int ret_val = 0; 7 | int temp = 0; 8 | 9 | if(nums.size()<1) 10 | { 11 | return 0; 12 | } 13 | 14 | int right_max = nums.size()-1 ; 15 | int i = 0 ; 16 | 17 | ret_val = nums[0]; 18 | for(i = 0 ; i <= right_max ; i++) 19 | { 20 | if(temp > 0) 21 | { 22 | temp += nums[i]; 23 | } 24 | else 25 | { 26 | temp = nums[i]; 27 | 28 | } 29 | 30 | if(temp > ret_val) 31 | { 32 | ret_val = temp; 33 | } 34 | } 35 | return ret_val; 36 | 37 | } 38 | }; 39 | 40 | 41 | 42 | -------------------------------------------------------------------------------- /算法/053_最大子序和/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 4 | 5 | 示例: 6 | 7 | 输入: [-2,1,-3,4,-1,2,1,-5,4], 8 | 输出: 6 9 | 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 10 | 11 | 进阶: 12 | 13 | 如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。 14 | 15 | 来源：力扣（LeetCode） 16 | 链接：https://leetcode-cn.com/problems/maximum-subarray 17 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 18 | */ 19 | ``` 20 | 21 | *** 22 | 23 | 分析: 24 | 25 | + 探索方法一:可变窗口遍历法，时间复杂度为$O(n^2)$ 26 | 27 | + 探索方法二:线性遍历扫描法，时间复杂度为$O(n)$ 28 | 29 | + 30 | 31 | -------------------------------------------------------------------------------- /算法/054_螺旋矩阵/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/054_螺旋矩阵/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/058_最后一个单词的长度/Solution01.c: -------------------------------------------------------------------------------- 1 | /* 2 | 给定一个仅包含大小写字母和空格 ' ' 的字符串，返回其最后一个单词的长度。 3 | 如果不存在最后一个单词，请返回 0 。 4 | 说明：一个单词是指由字母组成，但不包含任何空格的字符串。 5 | 示例: 6 | 输入: "Hello World" 7 | 输出: 5 8 | */ 9 | 10 | /* 常规方法:先忽略末尾空格再计数到字符串头或字符串中的空格*/ 11 | int lengthOfLastWord(char* s) 12 | { 13 | int str_len = strlen(s) ; 14 | int ret_val = 0 ; 15 | int index = str_len-1 ; 16 | 17 | do 18 | { 19 | /*忽略字符串末尾的空格*/ 20 | while( ( index >= 0 ) 21 | &&( s[index] == ' ' ) 22 | ) 23 | { 24 | index--; 25 | } 26 | if( ( index < 0 ) 27 | ||( str_len == 0 ) 28 | ) 29 | { 30 | ret_val = 0; 31 | break; 32 | } 33 | 34 | while( ( index >= 0 ) 35 | &&( s[index] != ' ' ) 36 | ) 37 | { 38 | ret_val++; 39 | index--; 40 | } 41 | break; 42 | }while(0); 43 | 44 | return ret_val; 45 | } 46 | 47 | 48 | /* 49 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00%的用户 50 | 内存消耗 :7 MB, 在所有 C 提交中击败了81.05%的用户 51 | */ 52 | 53 | -------------------------------------------------------------------------------- /算法/059_螺旋矩阵 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/059_螺旋矩阵 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/060_第k个排列/Soulutin02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | private: 4 | int arr[9] = {1,2,6,24,120,720,5040,40320,362880} ; 5 | // 1 2 3 4 5 6 7 8 9 6 | 7 | void helper ( string& s, 8 | int n, 9 | int k 10 | ) 11 | { 12 | 13 | if( k < 1 || k > arr[n-1]) 14 | { 15 | return ; /* k值越界*/ 16 | } 17 | 18 | 19 | } 20 | 21 | 22 | public: 23 | string getPermutation( int n , 24 | int k 25 | ) 26 | { 27 | string s ; 28 | helper(s,n,k); 29 | return s.; 30 | } 31 | }; 32 | 33 | 34 | 35 | /* 36 | 90 / 200 个通过测试用例 37 | 状态：超出时间限制 38 | 39 | 提交时间：3 分钟之前 40 | 最后执行的输入： 9 41 | 199269 42 | 43 | */ -------------------------------------------------------------------------------- /算法/060_第k个排列/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | */ 4 | ``` 5 | 6 | *** 7 | 分析: 8 | + 回溯法一:果断超时了. 9 | + 回溯法二: -------------------------------------------------------------------------------- /算法/066_加一/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | * Note: The returned array must be malloced, assume caller calls free(). 4 | */ 5 | int* plusOne( int* digits,int digitsSize, int* returnSize) 6 | { 7 | 8 | int* ret_val = NULL ; 9 | int* ret_val2 = NULL ; 10 | int carry = 1 ; 11 | int temp = 0 ; 12 | int i = 0 ; 13 | 14 | ret_val = (int*)malloc(digitsSize*sizeof(int)); 15 | carry = 1; 16 | for(i = digitsSize-1;i>=0;i--) 17 | { 18 | temp = (digits[i] + carry ) ; 19 | ret_val[i] = temp % 10 ; 20 | carry = temp / 10 ; 21 | } 22 | if(carry == 1) 23 | { 24 | ret_val2 = (int*)malloc((digitsSize+1)*sizeof(int)); 25 | ret_val2[0] = carry; 26 | memcpy(&ret_val2[1],ret_val,digitsSize*sizeof(int)); 27 | free(ret_val); 28 | ret_val = NULL; 29 | *returnSize = digitsSize + 1; 30 | return ret_val2; 31 | } 32 | else 33 | { 34 | *returnSize = digitsSize; 35 | return ret_val; 36 | } 37 | } 38 | 39 | /* 40 | 执行结果： 41 | 通过 42 | 显示详情 43 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 44 | 内存消耗 :7.3 MB, 在所有 C 提交中击败了5.51%的用户 45 | */ -------------------------------------------------------------------------------- /算法/066_加一/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | 给定一个由整数组成的非空数组所表示的非负整数，在该数的基础上加一。 3 | 4 | 最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。 5 | 6 | 你可以假设除了整数 0 之外，这个整数不会以零开头。 7 | 8 | 示例 1: 9 | 10 | 输入: [1,2,3] 11 | 输出: [1,2,4] 12 | 解释: 输入数组表示数字 123。 13 | 14 | 示例 2: 15 | 16 | 输入: [4,3,2,1] 17 | 输出: [4,3,2,2] 18 | 解释: 输入数组表示数字 4321。 19 | 20 | 来源：力扣（LeetCode） 21 | 链接：https://leetcode-cn.com/problems/plus-one 22 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 23 | ``` 24 | 25 | 分析: 26 | + 此题较为简单,注意处理__进位__和__溢出__即可. 27 | 28 |
29 | AlimyBreak 30 |
31 | 32 |
33 | 2019.07.16 34 |
35 | -------------------------------------------------------------------------------- /算法/066_加一/手稿V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/066_加一/手稿V1.0.pdf -------------------------------------------------------------------------------- /算法/067_二进制求和/make.cmd: -------------------------------------------------------------------------------- 1 | gcc Solution01.c -o test.exe -lstdc++ 2 | pause -------------------------------------------------------------------------------- /算法/073_矩阵置零/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/073_矩阵置零/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/073_矩阵置零/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/073_矩阵置零/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/073_矩阵置零/手稿_V1.2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/073_矩阵置零/手稿_V1.2.pdf -------------------------------------------------------------------------------- /算法/077_组合/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/077_组合/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/078_子集/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector> subsets(vector& nums) 5 | { 6 | vector> ret_val ; 7 | vector temp ; 8 | unsigned long int i = 0 ; 9 | unsigned char j = 0 ; 10 | unsigned long int size = nums.size() ; 11 | unsigned long int size_pow = pow(2, size) ; 12 | 13 | for (i = 0; i < size_pow; i++) 14 | { 15 | temp.clear(); 16 | for (j = 0; j < size; j++) 17 | { 18 | if (i & (0x01 << j)) 19 | { 20 | temp.push_back(nums[j]); 21 | } 22 | } 23 | ret_val.push_back(temp); 24 | } 25 | return ret_val; 26 | } 27 | }; 28 | 29 | /* 30 | 执行结果： 31 | 通过 32 | 显示详情 33 | 执行用时 :8 ms, 在所有 C++ 提交中击败了91.24% 的用户 34 | 内存消耗 :9 MB, 在所有 C++ 提交中击败了84.04%的用户 35 | */ 36 | -------------------------------------------------------------------------------- /算法/078_子集/Solution02.cpp: -------------------------------------------------------------------------------- 1 | // https://leetcode-cn.com/problems/subsets/submissions/ 2 | // https://www.bilibili.com/video/av76286065 3 | 4 | class Solution 5 | { 6 | private: 7 | void helper( vector>& vvi, 8 | vector& cur, 9 | vector& nums, 10 | int index 11 | ) 12 | { 13 | if(index == nums.size()) 14 | { 15 | vvi.push_back(cur); 16 | return; 17 | } 18 | 19 | cur.push_back(nums[index]); 20 | helper(vvi,cur,nums,index+1); 21 | cur.pop_back(); 22 | helper(vvi,cur,nums,index+1); 23 | } 24 | 25 | public: 26 | vector> subsets(vector& nums) 27 | { 28 | vector> vvi; 29 | vector cur; 30 | 31 | if(nums.size() < 1) 32 | { 33 | return vvi; 34 | } 35 | helper(vvi,cur,nums,0); 36 | return vvi; 37 | } 38 | }; 39 | 40 | 41 | 42 | /* 43 | 执行结果： 44 | 通过 45 | 显示详情 46 | 执行用时 :4 ms, 在所有 cpp 提交中击败了99.78% 的用户 47 | 内存消耗 :12.7 MB, 在所有 cpp 提交中击败了11.02%的用户 48 | */ -------------------------------------------------------------------------------- /算法/078_子集/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/078_子集/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/078_子集/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/078_子集/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/079_单词搜索/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/079_单词搜索/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/083_删除排序链表中的重复元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/083_删除排序链表中的重复元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/088_合并两个有序数组/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/088_合并两个有序数组/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/089_格雷编码/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | public: 5 | vector grayCode(int n) 6 | { 7 | 8 | int i = 0 ; 9 | int sum_count = pow(2,n) ; 10 | int cur_count = 0 ; 11 | 12 | if(n < 0) 13 | { 14 | return vector(); 15 | } 16 | 17 | vector vi(sum_count,0); 18 | for(i = 0 ; i < sum_count;i++) 19 | { 20 | vi[i] = i ^ (i>>1); 21 | } 22 | 23 | 24 | return vi; 25 | } 26 | }; 27 | 28 | /* 29 | 执行结果： 30 | 通过 31 | 显示详情 32 | 执行用时 :4 ms, 在所有 cpp 提交中击败了97.72% 的用户 33 | 内存消耗 :8.8 MB, 在所有 cpp 提交中击败了13.41%的用户 34 | */ -------------------------------------------------------------------------------- /算法/089_格雷编码/Solution03.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector grayCode(int n) 5 | { 6 | if(n == 0) 7 | { 8 | return {0}; 9 | } 10 | vector vi = grayCode(n-1) ; 11 | int i = 0 ; 12 | /*n层共有 2^n 个格雷码, 前(n-1)层共有 2^(n-1)个格雷码*/ 13 | for( i = pow(2,n-1)-1; i >= 0 ; i--) 14 | { 15 | vi.push_back(vi[i] | (0x01 << (n-1))); 16 | } 17 | return vi; 18 | } 19 | }; 20 | /* 21 | 执行结果： 22 | 通过 23 | 显示详情 24 | 执行用时 :12 ms, 在所有 cpp 提交中击败了18.56% 的用户 25 | 内存消耗 :8.7 MB, 在所有 cpp 提交中击败了20.23%的用户 26 | */ -------------------------------------------------------------------------------- /算法/089_格雷编码/Solution04.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | private: 5 | 6 | void helper( vector& vi , 7 | int n 8 | 9 | ) 10 | { 11 | if(n==0) 12 | { 13 | vi.push_back(0); 14 | return; 15 | } 16 | helper(vi,n-1); 17 | 18 | /*n层共有 2^n 个格雷码, 前(n-1)层共有 2^(n-1)个格雷码*/ 19 | for(int i = pow(2,n-1)-1; i >= 0 ; i--) 20 | { 21 | vi.push_back(vi[i] | (0x01 << (n-1))); 22 | } 23 | } 24 | 25 | 26 | public: 27 | vector grayCode(int n) 28 | { 29 | 30 | 31 | vector vi; 32 | 33 | if(n > 0) 34 | { 35 | helper(vi,n); 36 | } 37 | return vi; 38 | } 39 | }; 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :8 ms, 在所有 cpp 提交中击败了65.15% 的用户 45 | 内存消耗 :8.8 MB, 在所有 cpp 提交中击败了10.45%的用户 46 | */ -------------------------------------------------------------------------------- /算法/089_格雷编码/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/089_格雷编码/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/089_格雷编码/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/089_格雷编码/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/090_子集 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/090_子集 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/092_验证二叉搜索树/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution 11 | { 12 | private: 13 | bool ret_val; 14 | 15 | void __midOrder(TreeNode* node,stack& si) 16 | { 17 | if( (node==NULL) 18 | ||(ret_val == false) 19 | ) 20 | { 21 | return; 22 | } 23 | 24 | __midOrder(node->left,si); 25 | if((si.size()<1) || (si.top() < node->val)) 26 | { 27 | si.push(node->val); 28 | } 29 | else 30 | { 31 | ret_val = false; 32 | return; 33 | } 34 | __midOrder(node->right,si); 35 | } 36 | 37 | public: 38 | bool isValidBST(TreeNode* root) 39 | { 40 | stack sil; 41 | ret_val = true; 42 | __midOrder(root,sil); 43 | return ret_val; 44 | } 45 | }; 46 | 47 | /* 48 | 执行结果： 49 | 通过 50 | 显示详情 51 | 执行用时 :32 ms, 在所有 C++ 提交中击败了19.37% 的用户 52 | 内存消耗 :21.1 MB, 在所有 C++ 提交中击败了7.93%的用户 53 | */ -------------------------------------------------------------------------------- /算法/092_验证二叉搜索树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/092_验证二叉搜索树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/093_复原IP地址/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/093_复原IP地址/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/093_复原IP地址/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/093_复原IP地址/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/1002_查找常用字符/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1002_查找常用字符/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1008_先序遍历构造二叉树/Solution01.cpp: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | /** 6 | * Definition for a binary tree node. 7 | * struct TreeNode { 8 | * int val; 9 | * struct TreeNode *left; 10 | * struct TreeNode *right; 11 | * }; 12 | */ 13 | 14 | void add_node(struct TreeNode** node , int val) 15 | { 16 | if(*node == NULL) 17 | { 18 | *node = (struct TreeNode*)malloc(sizeof(struct TreeNode)); 19 | (*node)->val = val ; 20 | (*node)->left = NULL ; 21 | (*node)->right = NULL ; 22 | return ; 23 | } 24 | 25 | if( val < (*node)->val ) 26 | { 27 | add_node( &((*node)->left),val); 28 | } 29 | else 30 | { 31 | add_node( &((*node)->right),val); 32 | } 33 | } 34 | 35 | struct TreeNode* bstFromPreorder( int* preorder , 36 | int preorderSize 37 | ) 38 | { 39 | struct TreeNode* root = NULL ; 40 | int i = 0 ; 41 | for(i = 0 ; i < preorderSize ; i++) 42 | { 43 | add_node(&root,preorder[i]); 44 | } 45 | return root; 46 | } 47 | 48 | /* 49 | 执行结果： 50 | 通过 51 | 显示详情 52 | 执行用时 :4 ms, 在所有 c 提交中击败了95.97% 的用户 53 | 内存消耗 :9.4 MB, 在所有 c 提交中击败了9.09%的用户 54 | */ -------------------------------------------------------------------------------- /算法/1008_先序遍历构造二叉树/Solution02.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution 11 | { 12 | 13 | void add_node(TreeNode*& node, int val) 14 | { 15 | if(node == NULL) 16 | { 17 | node = new TreeNode(val); 18 | return; 19 | } 20 | 21 | if( val < node->val) 22 | { 23 | add_node(node->left,val); 24 | } 25 | else 26 | { 27 | add_node(node->right,val); 28 | } 29 | } 30 | 31 | public: 32 | TreeNode* bstFromPreorder(vector& preorder) 33 | { 34 | TreeNode* root = NULL ; 35 | int i = 0 ; 36 | 37 | for(i = 0 ; i < preorder.size();i++) 38 | { 39 | add_node(root,preorder[i]); 40 | } 41 | return root; 42 | } 43 | }; 44 | 45 | 46 | /* 47 | 执行结果： 48 | 通过 49 | 显示详情 50 | 执行用时 :8 ms, 在所有 cpp 提交中击败了74.75% 的用户 51 | 内存消耗 :10.8 MB, 在所有 cpp 提交中击败了70.49%的用户 52 | */ -------------------------------------------------------------------------------- /算法/1008_先序遍历构造二叉树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1008_先序遍历构造二叉树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1009_十进制整数的反码/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1009_十进制整数的反码/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1013_将数组分成和相等的三个部分/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1013_将数组分成和相等的三个部分/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/101_对称二叉树/Solution01.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | 10 | bool __ismirror( struct TreeNode* p , 11 | struct TreeNode* q 12 | ) 13 | { 14 | if( ( p == NULL ) 15 | &&( q == NULL ) 16 | ) 17 | { 18 | return true; 19 | } 20 | 21 | if( ( p == NULL ) 22 | ||( q == NULL ) 23 | ) 24 | { 25 | return false; 26 | } 27 | 28 | if(p->val == q->val) 29 | { 30 | return __ismirror(p->left,q->right) && __ismirror(p->right,q->left); 31 | } 32 | return false; 33 | } 34 | 35 | bool isSymmetric(struct TreeNode* root) 36 | { 37 | return __ismirror(root,root); 38 | } 39 | 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时:8 ms, 在所有 C 提交中击败了69.91%的用户 45 | 内存消耗 :7.9 MB, 在所有 C 提交中击败了100.00%的用户 46 | */ 47 | 48 | -------------------------------------------------------------------------------- /算法/101_对称二叉树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/101_对称二叉树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1021_删除最外层的括号/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1021_删除最外层的括号/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1025_除数博弈/Solution01.c: -------------------------------------------------------------------------------- 1 | bool divisorGame(int N) 2 | { 3 | return (N>0)&&(!(N&0x01)); 4 | } 5 | 6 | /* 7 | 执行结果： 8 | 通过 9 | 显示详情 10 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 11 | 内存消耗 :6.7 MB, 在所有 C 提交中击败了100.00%的用户 12 | */ -------------------------------------------------------------------------------- /算法/1025_除数博弈/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | 爱丽丝和鲍勃一起玩游戏，他们轮流行动。爱丽丝先手开局。 4 | 最初，黑板上有一个数字 N 。在每个玩家的回合，玩家需要执行以下操作： 5 | 选出任一 x，满足 0 < x < N 且 N % x == 0 。 6 | 用 N - x 替换黑板上的数字 N 。 7 | 如果玩家无法执行这些操作，就会输掉游戏。 8 | 只有在爱丽丝在游戏中取得胜利时才返回 True，否则返回 false。假设两个玩家都以最佳状态参与游戏。 9 | 示例 1： 10 | 输入：2 11 | 输出：true 12 | 解释：爱丽丝选择 1，鲍勃无法进行操作。 13 | 示例 2： 14 | 输入：3 15 | 输出：false 16 | 解释：爱丽丝选择 1，鲍勃也选择 1，然后爱丽丝无法进行操作。 17 | 提示： 18 | 1 <= N <= 1000 19 | 来源：力扣（LeetCode） 20 | 链接：https://leetcode-cn.com/problems/divisor-game 21 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 22 | */ 23 | ``` 24 | 分析: 25 | + 根据游戏的规则进行推进,N会慢慢减小,极限情况就是$N=2$或$N=1$,只要先手保证在自己拿的时候是偶数即可. 26 | + 若当前$N$为偶数先手拿走$x=1$即可,若先手$N$为奇数,不管怎么拿$N-x$一定为偶数,后手每次拿$x=1$即可. 27 | + 所以"最佳状态"就是保证每次让自己遇到偶数,让对手遇到奇数. 28 | + 对于先手来说:只要判断传入的$N$是是否是偶数即可,是偶数有必胜法,是奇数则必输(遇到最佳状态的Bob). 29 | 30 | *** 31 | 方法一:C_常规检测$N$的奇偶性 32 | ```C 33 | bool divisorGame(int N) 34 | { 35 | return (N>0)&&(!(N&0x01)); 36 | } 37 | 38 | /* 39 | 执行结果： 40 | 通过 41 | 显示详情 42 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 43 | 内存消耗 :6.7 MB, 在所有 C 提交中击败了100.00%的用户 44 | */ 45 | ``` 46 | 47 | 48 | 49 | *** 50 |
51 | AlimyBreak 52 |
53 |
54 | 2019.09.07 55 |
56 | -------------------------------------------------------------------------------- /算法/1025_除数博弈/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1025_除数博弈/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1026_节点与其祖先之间的最大差值/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1026_节点与其祖先之间的最大差值/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/102_二叉树的层次遍历/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | private: 4 | void __preOrder(TreeNode* node , int depth, vector>& ret_val) 5 | { 6 | if(node==NULL) 7 | { 8 | return ; 9 | } 10 | 11 | /* 根左右*/ 12 | if(depth>=ret_val.size()) 13 | { 14 | vector temp; 15 | temp.push_back(node->val); 16 | ret_val.push_back(temp); 17 | } 18 | else 19 | { 20 | ret_val[depth].push_back(node->val); 21 | } 22 | 23 | __preOrder(node->left,depth+1,ret_val); 24 | __preOrder(node->right,depth+1,ret_val); 25 | } 26 | 27 | public: 28 | vector> levelOrder(TreeNode* root) 29 | { 30 | vector> ret_val; 31 | __preOrder(root,0,ret_val); 32 | return ret_val; 33 | } 34 | }; 35 | 36 | /* 37 | 执行结果： 38 | 通过 39 | 显示详情 40 | 执行用时 :20 ms, 在所有 C++ 提交中击败了16.73%的用户 41 | 内存消耗 :15.7 MB, 在所有 C++ 提交中击败了5.05%的用户 42 | */ 43 | 44 | -------------------------------------------------------------------------------- /算法/102_二叉树的层次遍历/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/102_二叉树的层次遍历/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1030_距离顺序排列矩阵单元格/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1030_距离顺序排列矩阵单元格/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1046_最后一块石头的重量/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int lastStoneWeight(vector& stones) 5 | { 6 | if(stones.size()==1) 7 | { 8 | return stones[0]; 9 | } 10 | else if(stones.size()<=0) 11 | { 12 | return 0; 13 | } 14 | else 15 | { 16 | while (1) 17 | { 18 | sort(stones.begin(),stones.end(),greater()); 19 | if(stones[1]==0) 20 | { 21 | return stones[0]; 22 | } 23 | else 24 | { 25 | stones[0] = stones[0]-stones[1]; 26 | stones[1] = 0; 27 | } 28 | } 29 | } 30 | } 31 | }; 32 | 33 | /* 34 | ????? 35 | ?? 36 | ???? 37 | ???? :4 ms, ??? C++ ??????84.90% ??? 38 | ???? :8.3 MB, ??? C++ ??????100.00%??? 39 | */ -------------------------------------------------------------------------------- /算法/1046_最后一块石头的重量/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | public: 5 | int lastStoneWeight(vector& stones) 6 | { 7 | priority_queue pqi; 8 | int maxdata1 = 0; 9 | int maxdata2 = 0; 10 | int i = 0; 11 | 12 | for(i = 0;i 1) 18 | { 19 | maxdata1 = pqi.top(); 20 | pqi.pop(); 21 | maxdata2 = pqi.top(); 22 | pqi.pop(); 23 | if(maxdata1!=maxdata2) 24 | { 25 | pqi.push(maxdata1-maxdata2); 26 | } 27 | } 28 | 29 | if(pqi.size() ==0) 30 | { 31 | return 0; 32 | } 33 | else 34 | { 35 | return pqi[0]; 36 | } 37 | } 38 | }; 39 | 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :4 ms, 在所有 C++ 提交中击败了84.90% 的用户 45 | 内存消耗 :8.3 MB, 在所有 C++ 提交中击败了100.00%的用户 46 | */ -------------------------------------------------------------------------------- /算法/1046_最后一块石头的重量/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1046_最后一块石头的重量/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/104_二叉树的最大深度/Solution02.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | int __maxDepth(struct TreeNode* node,int depth) 10 | { 11 | int left_depth = 0; 12 | int right_depth = 0; 13 | if(node==NULL) 14 | { 15 | return depth; 16 | } 17 | else 18 | { 19 | depth++; 20 | left_depth = __maxDepth(node->left,depth); 21 | right_depth = __maxDepth(node->right,depth); 22 | return left_depth>right_depth?left_depth:right_depth; 23 | } 24 | } 25 | 26 | int maxDepth(struct TreeNode* root) 27 | { 28 | return __maxDepth(root,0); 29 | } 30 | 31 | /* 32 | 执行结果：通过 33 | 显示详情 34 | 执行用时 :16 ms, 在所有 C 提交中击败了50.16%的用户 35 | 内存消耗 :9.2 MB, 在所有 C 提交中击败了99.58%的用户 36 | */ 37 | -------------------------------------------------------------------------------- /算法/1051_高度检查器/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int heightChecker(vector& heights) 5 | { 6 | vector temp(heights); 7 | int ret_val = 0; 8 | sort(temp.begin(),temp.end()); 9 | 10 | for(int i = 0; i < heights.size() ; i++) 11 | { 12 | if(temp[i]!=heights[i]) 13 | { 14 | ret_val ++; 15 | } 16 | } 17 | return ret_val; 18 | } 19 | }; 20 | 21 | 22 | /* 23 | 执行结果： 24 | 通过 25 | 显示详情 26 | 执行用时 :8 ms, 在所有 C++ 提交中击败了47.05% 的用户 27 | 内存消耗 :8.7 MB, 在所有 C++ 提交中击败了100.00%的用户 28 | */ -------------------------------------------------------------------------------- /算法/1051_高度检查器/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1051_高度检查器/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1079_活字印刷/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1079_活字印刷/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/107_二叉树的层次遍历2/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/107_二叉树的层次遍历2/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1089_复写零/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | /* [left,right] */ 5 | private: 6 | void move(vector& arr , int left,int right) 7 | { 8 | int i = 0; 9 | for(i=right; i > left ;i--) 10 | { 11 | arr[i] = arr[i-1]; 12 | } 13 | } 14 | public: 15 | void duplicateZeros(vector& arr) 16 | { 17 | int size = arr.size(); 18 | for(int i = 0 ; i < size;) 19 | { 20 | if(arr[i] == 0) 21 | { 22 | if(i+1 < size) 23 | { 24 | move(arr, i+1, size-1); 25 | arr[i+1] = 0; 26 | } 27 | i += 2; 28 | } 29 | else 30 | { 31 | i += 1; 32 | } 33 | } 34 | return ; 35 | } 36 | }; 37 | 38 | /* 39 | 执行结果： 40 | 通过 41 | 显示详情 42 | 执行用时 :76 ms, 在所有 cpp 提交中击败了25.08% 的用户 43 | 内存消耗 :9.2 MB, 在所有 cpp 提交中击败了100.00%的用户 44 | */ -------------------------------------------------------------------------------- /算法/1089_复写零/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1089_复写零/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/109_有序链表转换二叉搜索树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/109_有序链表转换二叉搜索树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1103_分糖果 II/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector distributeCandies(int candies, int num_people) 5 | { 6 | vector vi_ret(num_people,0); 7 | int count = 0; 8 | 9 | while(candies>0) 10 | { 11 | if(candies > count) 12 | { 13 | vi_ret[count%num_people] += (count+1); 14 | count++; 15 | candies = candies - count; 16 | } 17 | else 18 | { 19 | vi_ret[count%num_people] += candies; 20 | candies -= candies; 21 | break; 22 | } 23 | } 24 | 25 | return vi_ret; 26 | 27 | } 28 | }; 29 | 30 | /* 31 | 27 / 27 个通过测试用例 32 | 状态：通过 33 | 执行用时：0 ms 34 | 内存消耗：8.7 MB 35 | 提交时间：5 分钟之前 36 | */ -------------------------------------------------------------------------------- /算法/1103_分糖果 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1103_分糖果 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1108_IP地址无效化/Solution01.c: -------------------------------------------------------------------------------- 1 | char* defangIPaddr(char* address) 2 | { 3 | int str_len = 0 ; 4 | int dot_count = 0 ; 5 | int i = 0 ; 6 | int j = 0 ; 7 | char* ret_val = NULL ; 8 | 9 | while(address[i]) 10 | { 11 | str_len++; 12 | if(address[i]=='.') 13 | { 14 | dot_count++; 15 | } 16 | i++; 17 | } 18 | 19 | ret_val = (char*)malloc(str_len+2*dot_count+1); 20 | ret_val[str_len+2*dot_count] = 0; 21 | i = 0; 22 | for(j=0;j=3) 21 | { 22 | temp = t[0] + t[1] + t[2]; 23 | t[0] = t[1]; 24 | t[1] = t[2]; 25 | t[2] = temp; 26 | n --; 27 | } 28 | return t[2]; 29 | } 30 | } 31 | }; 32 | 33 | /* 34 | 执行结果：通过 35 | 显示详情 36 | 执行用时 :4 ms, 在所有 C++ 提交中击败了100.00%的用户 37 | 内存消耗 :8.1 MB, 在所有 C++ 提交中击败了100.00%的用户 38 | */ -------------------------------------------------------------------------------- /算法/1137_第N个泰波那契数/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int tribonacci(int n) 5 | { 6 | if(n<=0) 7 | { 8 | return 0; 9 | } 10 | if(n==1) 11 | { 12 | return 1; 13 | } 14 | if(n==2) 15 | { 16 | return 1; 17 | } 18 | return tribonacci(n-1) + tribonacci(n-2) + tribonacci(n-3); 19 | } 20 | }; 21 | 22 | /* 23 | 执行结果： 24 | 超出时间限制 25 | 显示详情 26 | 最后执行的输入： 27 | 33 28 | */ 29 | 30 | -------------------------------------------------------------------------------- /算法/1137_第N个泰波那契数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1137_第N个泰波那契数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/114_二叉树展开为链表/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/114_二叉树展开为链表/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1154_一年中的第几天/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | int str2int(char* str,int length) 3 | { 4 | int ret_val = 0; 5 | 6 | if(length==2) 7 | { 8 | ret_val = (str[0]-0x30)*10+str[1]-0x30; 9 | } 10 | else 11 | { 12 | ret_val = (str[0]-0x30)*1000+(str[1]-0x30)*100+(str[2]-0x30)*10+str[3]-0x30; 13 | } 14 | return ret_val; 15 | } 16 | 17 | int isLeapYear(int year) 18 | { 19 | int ret_val = 0; 20 | 21 | if((year%400==0)||((year%100!=0)&&(year%4==0))) 22 | { 23 | ret_val = 1; 24 | } 25 | return ret_val; 26 | } 27 | 28 | int dayOfYear(char * date) 29 | { 30 | 31 | int year = str2int(&date[0],4); 32 | int mouth = str2int(&date[5],2)-1; 33 | int day = str2int(&date[8],2); 34 | int arr[2][12] = { 35 | {0,31,59,90,120,151,181,212,243,273,304,334}, 36 | {0,31,60,91,121,152,182,213,244,274,305,335} 37 | }; 38 | 39 | 40 | return (arr[isLeapYear(year)][mouth] + day); 41 | } 42 | 43 | 44 | /* 45 | 执行结果： 46 | 通过 47 | 显示详情 48 | 执行用时 :4 ms, 在所有 C 提交中击败了52.38% 的用户 49 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了100.00%的用户 50 | */ -------------------------------------------------------------------------------- /算法/1154_一年中的第几天/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1154_一年中的第几天/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1160_拼写单词/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1160_拼写单词/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1161_最大层内元素和/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1161_最大层内元素和/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1185_一周中的第几天/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1185_一周中的第几天/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1189_“气球” 的最大数量/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1189_“气球” 的最大数量/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/118_杨辉三角/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/118_杨辉三角/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/119_杨辉三角2/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | public: 5 | vector getRow(int rowIndex) 6 | { 7 | int i = 0 ; 8 | vector ret_val ; 9 | unsigned long temp = 1 ; 10 | 11 | ret_val.push_back(1); 12 | for(i = 1; i <= rowIndex ; i++) 13 | { 14 | temp = temp * (rowIndex-i+1); 15 | temp = temp / i ; 16 | ret_val.push_back(temp); 17 | } 18 | return ret_val; 19 | } 20 | }; 21 | 22 | 23 | /* 24 | 执行结果： 25 | 通过 26 | 显示详情 27 | 执行用时 :0 ms, 在所有 C++ 提交中击败了100.00% 的用户 28 | 内存消耗 :8 MB, 在所有 C++ 提交中击败了99.84%的用户 29 | */ -------------------------------------------------------------------------------- /算法/119_杨辉三角2/Solution03.c: -------------------------------------------------------------------------------- 1 | /* 层次迭代法*/ 2 | /** 3 | * Note: The returned array must be malloced, assume caller calls free(). 4 | */ 5 | int* getRow( int rowIndex , 6 | int* returnSize 7 | ) 8 | { 9 | int* ret_val = NULL ; 10 | int i = 0 ; 11 | int j = 0 ; 12 | unsigned long temp = 1 ; 13 | 14 | *returnSize = ++rowIndex; 15 | ret_val = (int*)malloc(sizeof(int)*(rowIndex)); 16 | memset(ret_val,0,sizeof(int)*(rowIndex)); 17 | ret_val[rowIndex-1] = temp ; 18 | ret_val[0] = 1; 19 | for(i=1;i0;j--) 22 | { 23 | ret_val[j] = ret_val[j-1] + ret_val[j]; 24 | } 25 | } 26 | return ret_val; 27 | } 28 | 29 | /* 30 | 执行结果： 31 | 通过 32 | 显示详情 33 | 执行用时 :4 ms, 在所有 C 提交中击败了78.57% 的用户 34 | 内存消耗 :7.1 MB, 在所有 C 提交中击败了6.10%的用户 35 | */ 36 | 37 | -------------------------------------------------------------------------------- /算法/119_杨辉三角2/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/119_杨辉三角2/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1200_最小绝对差/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector> minimumAbsDifference(vector& arr) 5 | { 6 | 7 | 8 | vector> vvi ; 9 | int min_abs_diff = 2147483647 ; 10 | int i = 0 ; 11 | 12 | sort(arr.begin(),arr.end()); 13 | for( i = 1; i < arr.size() ; i++) 14 | { 15 | if(arr[i]-arr[i-1] < min_abs_diff) 16 | { 17 | min_abs_diff = abs(arr[i]-arr[i-1]); 18 | } 19 | } 20 | 21 | for( i = 1 ; i < arr.size() ; i++) 22 | { 23 | if(arr[i]-arr[i-1] == min_abs_diff) 24 | { 25 | vector vi; 26 | vi.push_back(arr[i-1]); 27 | vi.push_back(arr[i]); 28 | vvi.push_back(vi); 29 | } 30 | } 31 | 32 | return vvi; 33 | } 34 | }; 35 | 36 | /* 37 | 执行结果： 38 | 通过 39 | 显示详情 40 | 执行用时 :172 ms, 在所有 cpp 提交中击败了19.70% 的用户 41 | 内存消耗 :17.9 MB, 在所有 cpp 提交中击败了100.00%的用户 42 | */ -------------------------------------------------------------------------------- /算法/1200_最小绝对差/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1200_最小绝对差/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1207_独一无二的出现次数/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | bool uniqueOccurrences(vector& arr) 5 | { 6 | map mii ; 7 | set si ; 8 | int i = 0 ; 9 | 10 | 11 | for(i=0;i::iterator iter; 25 | iter = mii.begin(); 26 | while(iter != mii.end()) 27 | { 28 | si.insert(iter->second); 29 | iter++; 30 | } 31 | return ( mii.size() == si.size() ); 32 | } 33 | }; 34 | 35 | /* 36 | 执行结果： 37 | 通过 38 | 显示详情 39 | 执行用时 :4 ms, 在所有 cpp 提交中击败了88.86%的用户 40 | 内存消耗 :8.8 MB, 在所有 cpp 提交中击败了100.00%的用户 41 | */ -------------------------------------------------------------------------------- /算法/1207_独一无二的出现次数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1207_独一无二的出现次数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1219_黄金矿工/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1219_黄金矿工/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1221_分割平衡字符串/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int balancedStringSplit(string s) 5 | { 6 | int ret_val = 0; 7 | int i = 0; 8 | int count = 0' 9 | for(i=0;i= '0') && (ch <= '9')) ? 1 : 0; 6 | } 7 | 8 | int isChar(char ch) 9 | { 10 | return (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z'))) ? 1 : 0; 11 | } 12 | 13 | bool isPalindrome(char * s) 14 | { 15 | 16 | bool ret_val = true ; /* init */ 17 | int valid_len = 0 ; 18 | int i = 0 ; 19 | 20 | i = 0; 21 | valid_len = 0; 22 | while(s[i] != '\0') 23 | { 24 | if( isNum ( s[i] ) 25 | || isChar( s[i] ) 26 | ) 27 | { 28 | s[valid_len] = s[i] | 32; 29 | valid_len ++; 30 | } 31 | i++; 32 | } 33 | 34 | i = 0; 35 | while( i < valid_len-1 ) 36 | { 37 | if(s[i] != s[valid_len-1]) 38 | { 39 | ret_val = false; 40 | break; 41 | } 42 | i++; 43 | valid_len--; 44 | } 45 | return ret_val; 46 | } 47 | 48 | /* 49 | 执行用时 :4 ms, 在所有C提交中击败了96.32%的用户 50 | 内存消耗 :7.5 MB, 在所有C提交中击败了30.92%的用户 51 | */ -------------------------------------------------------------------------------- /算法/1261_在受污染的二叉树中查找元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1261_在受污染的二叉树中查找元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1281_整数的各位积和之差/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int subtractProductAndSum(int n) 5 | { 6 | if(n < 1) 7 | { 8 | return 0; 9 | } 10 | 11 | int sum = 0; 12 | int product = 1; 13 | int temp = 0; 14 | while(n!=0) 15 | { 16 | temp = n % 10 ; 17 | sum += temp ; 18 | product *= temp ; 19 | n /= 10 ; 20 | } 21 | return (product-sum); 22 | } 23 | }; 24 | 25 | /* 26 | 执行结果： 27 | 通过 28 | 显示详情 29 | 执行用时 :4 ms, 在所有 cpp 提交中击败了100.00% 的用户 30 | 内存消耗 :8.1 MB, 在所有 cpp 提交中击败了100.00%的用户 31 | */ -------------------------------------------------------------------------------- /算法/1281_整数的各位积和之差/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1281_整数的各位积和之差/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1282_用户分组/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1282_用户分组/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1290_二进制链表转整数/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution 10 | { 11 | public: 12 | int getDecimalValue(ListNode* head) 13 | { 14 | int temp = 0; 15 | while(head) 16 | { 17 | temp = temp * 2 + head->val; 18 | head = head->next; 19 | } 20 | return temp; 21 | } 22 | }; 23 | 24 | /* 25 | 执行结果： 26 | 通过 27 | 显示详情 28 | 执行用时 :8 ms, 在所有 cpp 提交中击败了73.12% 的用户 29 | 内存消耗 :8.4 MB, 在所有 cpp 提交中击败了100.00%的用户 30 | */ -------------------------------------------------------------------------------- /算法/1290_二进制链表转整数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1290_二进制链表转整数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1295_统计位数为偶数的数字/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int findNumbers(vector& nums) 5 | { 6 | int ret_val = 0; 7 | for(int i = 0 ; i < nums.size();i++) 8 | { 9 | if(nums[i]!=0) 10 | { 11 | string s = to_string(nums[i]); 12 | int length = s.size(); 13 | if(length % 2 == 0) 14 | { 15 | ret_val++; 16 | } 17 | } 18 | } 19 | return ret_val; 20 | } 21 | }; 22 | 23 | /* 24 | 执行结果： 25 | 通过 26 | 显示详情 27 | 执行用时 :12 ms, 在所有 cpp 提交中击败了100.00% 的用户 28 | 内存消耗 :9 MB, 在所有 cpp 提交中击败了100.00%的用户 29 | */ -------------------------------------------------------------------------------- /算法/1295_统计位数为偶数的数字/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int findNumbers(vector& nums) 5 | { 6 | int ret_val = 0; 7 | for(int i = 0 ; i < nums.size();i++) 8 | { 9 | int temp = nums[i]; 10 | 11 | if( (temp >= 10 && temp <= 99 ) 12 | ||(temp >= 1000 && temp <= 9999 ) 13 | ||(temp >= 100000 && temp <= 999999 ) 14 | ) 15 | { 16 | ret_val++; 17 | } 18 | 19 | } 20 | return ret_val; 21 | } 22 | }; 23 | 24 | /* 25 | 执行结果： 26 | 通过 27 | 显示详情 28 | 执行用时 :8 ms, 在所有 cpp 提交中击败了100.00% 的用户 29 | 内存消耗 :8.7 MB, 在所有 cpp 提交中击败了100.00%的用户 30 | */ -------------------------------------------------------------------------------- /算法/1295_统计位数为偶数的数字/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1295_统计位数为偶数的数字/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1295_统计位数为偶数的数字/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1295_统计位数为偶数的数字/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/1299_将每个元素替换为右侧最大元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1299_将每个元素替换为右侧最大元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1302_层数最深叶子节点的和/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1302_层数最深叶子节点的和/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1304_和为零的N个唯一整数/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector sumZero(int n) 5 | { 6 | vector ret_val ; 7 | if(n >= 1) 8 | { 9 | /*奇数*/ 10 | if(n % 2) 11 | { 12 | ret_val.push_back(0); 13 | } 14 | 15 | for(int i = 1 ; i <= n / 2 ; i++) 16 | { 17 | ret_val.push_back(-i); 18 | ret_val.push_back(i); 19 | } 20 | } 21 | return ret_val; 22 | } 23 | }; 24 | 25 | 26 | /* 27 | 执行结果： 28 | 通过 29 | 显示详情 30 | 执行用时 :0 ms, 在所有 C++ 提交中击败了100.00% 的用户 31 | 内存消耗 :9.1 MB, 在所有 C++ 提交中击败了100.00%的用户 32 | */ -------------------------------------------------------------------------------- /算法/1304_和为零的N个唯一整数/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector sumZero(int n) 5 | { 6 | vector ret_val ; 7 | int temp = 0; 8 | int i = 0; 9 | if(n > 1) 10 | { 11 | for( i = 1; i < n ; i++) 12 | { 13 | temp += i; 14 | ret_val.push_back(i); 15 | } 16 | 17 | ret_val.push_back(-temp); 18 | 19 | } 20 | else if(n == 1) 21 | { 22 | ret_val.push_back(0); 23 | } 24 | return ret_val; 25 | } 26 | }; 27 | 28 | 29 | /* 30 | 执行结果： 31 | 通过 32 | 显示详情 33 | 执行用时 :4 ms, 在所有 C++ 提交中击败了99.21% 的用户 34 | 内存消耗 :9.3 MB, 在所有 C++ 提交中击败了100.00%的用户 35 | */ -------------------------------------------------------------------------------- /算法/1304_和为零的N个唯一整数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1304_和为零的N个唯一整数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1304_和为零的N个唯一整数/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1304_和为零的N个唯一整数/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/1305_两棵二叉搜索树中的所有元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1305_两棵二叉搜索树中的所有元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1313_解压缩编码列表/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector decompressRLElist(vector& nums) 5 | { 6 | int num = nums.size()/2; 7 | int i = 0; 8 | int j = 0; 9 | vector ret_val; 10 | 11 | for(i = 0 ; i < num; i++) 12 | { 13 | for(j = 0 ; j < nums[2*i]; j++) 14 | { 15 | ret_val.push_back(nums[2*i+1]); 16 | } 17 | } 18 | return ret_val; 19 | } 20 | }; 21 | 22 | /* 23 | 执行结果： 24 | 通过 25 | 显示详情 26 | 执行用时 :16 ms, 在所有 C++ 提交中击败了100.00% 的用户 27 | 内存消耗 :11.3 MB, 在所有 C++ 提交中击败了100.00%的用户 28 | */ -------------------------------------------------------------------------------- /算法/1313_解压缩编码列表/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1313_解压缩编码列表/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1315_祖父节点值为偶数的节点和/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1315_祖父节点值为偶数的节点和/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/131_分割回文串/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/131_分割回文串/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/1323_6和9组成的最大数字/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int maximum69Number(int num) 5 | { 6 | char arr[4] = {0,0,0,0}; 7 | 8 | arr[0] = (num/1000) ; // 千 9 | arr[1] = (num/100)%10 ; // 百 10 | arr[2] = (num/10)%10 ; // 十 11 | arr[3] = (num%10) ; // 个 12 | 13 | for(int i = 0 ; i < 4;i++) 14 | { 15 | if(arr[i]==6) 16 | { 17 | arr[i]=9; 18 | break; 19 | } 20 | } 21 | 22 | int ret_val = 0; 23 | for(int i = 0 ; i < 4 ; i++) 24 | { 25 | ret_val = ret_val * 10 + arr[i]; 26 | } 27 | return ret_val; 28 | 29 | 30 | } 31 | }; 32 | 33 | 34 | /* 35 | 执行结果： 36 | 通过 37 | 显示详情 38 | 执行用时 :4 ms, 在所有 C++ 提交中击败了63.54% 的用户 39 | 内存消耗 :8 MB, 在所有 C++ 提交中击败了100.00%的用户 40 | */ -------------------------------------------------------------------------------- /算法/1323_6和9组成的最大数字/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int maximum69Number (int num) 5 | { 6 | switch(num) 7 | { 8 | case 6: 9 | case 9: return 9; 10 | 11 | case 66: return 96; 12 | case 69: 13 | case 96: 14 | case 99: return 99; 15 | 16 | case 666: return 966; 17 | case 669: return 969; 18 | case 696: 19 | case 966: return 996; 20 | case 699: 21 | case 969: 22 | case 996: 23 | case 999: return 999; 24 | 25 | case 6666: return 9666; 26 | case 6669: return 9669; 27 | case 6696: return 9696; 28 | case 6699: return 9699; 29 | case 6966: 30 | case 9666: return 9966; 31 | case 6969: 32 | case 9669: return 9969; 33 | case 6996: 34 | case 9696: 35 | case 9966: return 9996; 36 | case 6999: 37 | case 9699: 38 | case 9969: 39 | case 9996: 40 | case 9999: return 9999; 41 | } 42 | return 0; 43 | } 44 | }; 45 | 46 | /* 47 | 执行结果： 48 | 通过 49 | 显示详情 50 | 执行用时 :4 ms, 在所有 C++ 提交中击败了63.54% 的用户 51 | 内存消耗 :8 MB, 在所有 C++ 提交中击败了100.00%的用户 52 | */ -------------------------------------------------------------------------------- /算法/1323_6和9组成的最大数字/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/1323_6和9组成的最大数字/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/136_只出现一次的数字/Solution01.c: -------------------------------------------------------------------------------- 1 | /* 2 | 给定一个非空整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。 3 | 4 | 说明： 5 | 6 | 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？ 7 | 8 | 示例 1: 9 | 10 | 输入: [2,2,1] 11 | 输出: 1 12 | 示例 2: 13 | 输入: [4,1,2,1,2] 14 | 输出: 4 15 | */ 16 | 17 | 18 | int singleNumber(int* nums, int numsSize){ 19 | 20 | int ret_val = 0; 21 | int i = 0; 22 | 23 | for(i = 0; i & nums) 6 | { 7 | int length = nums.size() ; 8 | int result = 0 ; 9 | int mask = 0 ; 10 | int count = 0 ; 11 | int i = 0 ; 12 | int j = 0 ; 13 | for( i = 0; i<32; i++) 14 | { 15 | count = 0; 16 | mask = 1<< i; 17 | for(j = 0; j ret_val; 15 | void __dfsPostOrder(TreeNode* node) 16 | { 17 | if(node==NULL) 18 | { 19 | return ; 20 | } 21 | __dfsPostOrder(node->left); 22 | __dfsPostOrder(node->right); 23 | ret_val.push_back(node->val); 24 | } 25 | 26 | public: 27 | vector postorderTraversal(TreeNode* root) 28 | { 29 | ret_val.clear(); 30 | __dfsPostOrder(root); 31 | return ret_val; 32 | } 33 | }; 34 | 35 | /* 36 | 执行结果： 37 | 通过 38 | 显示详情 39 | 执行用时 :4 ms, 在所有 C++ 提交中击败了83.30% 的用户 40 | 内存消耗 :9.2 MB, 在所有 C++ 提交中击败了43.66%的用户 41 | */ -------------------------------------------------------------------------------- /算法/145_二叉树的后序遍历/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/145_二叉树的后序遍历/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/167_两数之和 II - 输入有序数组/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector twoSum(vector& numbers, int target) 5 | { 6 | vector ret_val; 7 | int left = 1 ; 8 | int right = numbers.size() ; 9 | int mid = 0 ; 10 | while(left < right) 11 | { 12 | if(numbers[left-1] + numbers[right-1] == target) 13 | { 14 | ret_val.push_back(left); 15 | ret_val.push_back(right); 16 | break; 17 | } 18 | else if(numbers[left-1] + numbers[right-1] < target) 19 | { 20 | left++; 21 | } 22 | else 23 | { 24 | right--; 25 | } 26 | } 27 | return ret_val; 28 | } 29 | }; 30 | 31 | /* 32 | 执行结果： 33 | 通过 34 | 显示详情 35 | 执行用时 :4 ms, 在所有 cpp 提交中击败了97.11% 的用户 36 | 内存消耗 :9.4 MB, 在所有 cpp 提交中击败了79.15%的用户 37 | */ -------------------------------------------------------------------------------- /算法/167_两数之和 II - 输入有序数组/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector twoSum(vector& numbers, int target) 5 | { 6 | vector ret_val ; 7 | map mii ; 8 | int i = 0 ; 9 | 10 | for(i = 0 ; i < numbers.size() ; i++) 11 | { 12 | if(mii.count(numbers[i])) 13 | { 14 | ret_val.push_back(mii[numbers[i]]+1); 15 | ret_val.push_back(i+1); 16 | break; 17 | } 18 | else 19 | { 20 | mii[target-numbers[i]] = i; 21 | } 22 | 23 | } 24 | return ret_val; 25 | } 26 | }; 27 | 28 | /* 29 | 执行结果： 30 | 通过 31 | 显示详情 32 | 执行用时 :4 ms, 在所有 cpp 提交中击败了97.11% 的用户 33 | 内存消耗 :9.6 MB, 在所有 cpp 提交中击败了12.46%的用户 34 | */ 35 | -------------------------------------------------------------------------------- /算法/167_两数之和 II - 输入有序数组/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/167_两数之和 II - 输入有序数组/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/168_Excel表列名称/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | 给定一个正整数，返回它在 Excel 表中相对应的列名称。 4 | 例如， 5 | 1 -> A 6 | 2 -> B 7 | 3 -> C 8 | ... 9 | 26 -> Z 10 | 27 -> AA 11 | 28 -> AB 12 | ... 13 | 示例 1: 14 | 15 | 输入: 1 16 | 输出: "A" 17 | 18 | 示例 2: 19 | 20 | 输入: 28 21 | 输出: "AB" 22 | 23 | 示例 3: 24 | 25 | 输入: 701 26 | 输出: "ZY" 27 | 28 | 来源：力扣（LeetCode） 29 | 链接：https://leetcode-cn.com/problems/excel-sheet-column-title 30 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 31 | */ 32 | ``` 33 | 34 | 35 | 36 | *** 37 | 38 | 分析： 39 | 40 | + 此题类似进制转换，只不过这里的“26进制”数的位权范围为$[1,26]$,而不是$[0,25]$，肯定涉及连续取余和连续除法。 41 | + 由于$a_k$的计算只能从低位开始，我们计算完以后肯定涉及字符串的翻转. 42 | 43 | $$ 44 | n=\sum_{k=0}^{n}a_{k}26^{k} 45 | $$ 46 | 47 | $$ 48 | a_k\in[1,26] 49 | $$ 50 | 51 | + $a_k$的计算逻辑 52 | + 初始化：结果字符串存放位置申请并清零(10个字节足够用了)，结果字符串长度计数count=0 53 | + 当$n>0$ 54 | + $a_k = n\%26$； 55 | + 通过字符数组和$a_k$索引的对应的字符存储到结果字符串的count位置,```count++```方便下一次存储. 56 | + 当$a_k==0$,$n=(n-26)/26$,否则$n=(n-a_k)/26$. 57 | + 进入下一次循环判断. 58 | + 计算完毕，进行字符串翻转。 59 | 60 | *** 61 | 62 | 注意：在C语言中，$1/2 == 0$， $(3-1)/2 == 3/2 = 1$. 63 | 64 | -------------------------------------------------------------------------------- /算法/168_Excel表列名称/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/168_Excel表列名称/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/169_求众数/Solution02.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | int majorityElement(int* nums, int numsSize) 5 | { 6 | 7 | int i = 0 ; 8 | int j = 0 ; 9 | int ret_val = rand() ; 10 | int vote = 0 ; 11 | 12 | for(i = numsSize-1 ; i >=0 ; i--) 13 | { 14 | if(ret_val == nums[i]) 15 | { 16 | continue; 17 | } 18 | ret_val = nums[i]; 19 | vote = 0; 20 | for(j=i;j>=0;j--) 21 | { 22 | if(nums[j]==ret_val) 23 | { 24 | vote++; 25 | } 26 | else 27 | { 28 | vote--; 29 | } 30 | } 31 | if(vote>=0) 32 | { 33 | break; 34 | } 35 | } 36 | return ret_val; 37 | } 38 | 39 | 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :28 ms, 在所有 C 提交中击败了85.92% 的用户 45 | 内存消耗 :8.9 MB, 在所有 C 提交中击败了52.54%的用户 46 | */ -------------------------------------------------------------------------------- /算法/169_求众数/Solution04.c: -------------------------------------------------------------------------------- 1 | void swap(int*a , int* b) 2 | { 3 | int c; 4 | c = *a; 5 | *a = *b; 6 | *b = c; 7 | } 8 | 9 | void __quicksort3(int* arr,int l,int r) 10 | { 11 | 12 | int v = arr[l] ; 13 | int lt = l ; 14 | int gt = r+1 ; 15 | int i = l+1 ; 16 | 17 | if(l>=r) 18 | { 19 | return ; 20 | } 21 | 22 | while(iv) 31 | { 32 | swap(&arr[i],&arr[gt-1]); 33 | gt--; 34 | } 35 | else 36 | { 37 | i++; 38 | } 39 | } 40 | 41 | swap(&arr[l],&arr[lt]); 42 | __quicksort3(arr,l,lt-1); 43 | __quicksort3(arr,gt,r); 44 | 45 | 46 | } 47 | 48 | 49 | 50 | int majorityElement(int* nums, int numsSize) 51 | { 52 | 53 | 54 | int ret_val = 0; 55 | 56 | __quicksort3(nums,0,numsSize-1); 57 | 58 | ret_val = nums[numsSize/2]; 59 | 60 | return ret_val; 61 | } 62 | 63 | 64 | /* 65 | 执行结果： 66 | 通过 67 | 显示详情 68 | 执行用时 :28 ms, 在所有 C 提交中击败了85.92% 的用户 69 | 内存消耗 :9 MB, 在所有 C 提交中击败了26.37%的用户 70 | */ -------------------------------------------------------------------------------- /算法/169_求众数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/169_求众数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/172_阶乘后的零/Solution01.c: -------------------------------------------------------------------------------- 1 | int numOfFactor5(int x) 2 | { 3 | int num = 0; 4 | while(x%5==0) 5 | { 6 | num++; 7 | x /= 5 ; 8 | } 9 | return num; 10 | } 11 | 12 | int trailingZeroes(int n) 13 | { 14 | int ret_num = 0; 15 | int i = 5; 16 | do 17 | { 18 | if(n<=0) 19 | { 20 | break; 21 | } 22 | 23 | while(i<=n) 24 | { 25 | ret_num += numOfFactor5(i); 26 | i += 5; 27 | } 28 | }while(0); 29 | return ret_num; 30 | } 31 | 32 | /* 33 | 第一次提交 34 | 500 / 502 个通过测试用例 35 | 状态：超出时间限制 36 | 提交时间：1 分钟之前 37 | 最后执行的输入： 38 | 1808548329 39 | 2147483647 40 | */ 41 | 42 | -------------------------------------------------------------------------------- /算法/172_阶乘后的零/Solution02.c: -------------------------------------------------------------------------------- 1 | int trailingZeroes(int n) 2 | { 3 | int ret_num = 0; 4 | do 5 | { 6 | while(n>4) 7 | { 8 | ret_num += n / 5; 9 | n /=5 10 | } 11 | }while(0); 12 | return ret_num; 13 | } 14 | 15 | /* 16 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 17 | 内存消耗 :6.9 MB, 在所有 C 提交中击败了64.08%的用户 18 | */ 19 | 20 | -------------------------------------------------------------------------------- /算法/189_旋转数组/make.cmd: -------------------------------------------------------------------------------- 1 | gcc solution_02.c -o test.exe -lstdc++ 2 | test.exe >> result.txt 3 | pause -------------------------------------------------------------------------------- /算法/189_旋转数组/result.txt: -------------------------------------------------------------------------------- 1 | 5 2 | 6 3 | 7 4 | 1 5 | 2 6 | 3 7 | 4 8 | -------------------------------------------------------------------------------- /算法/189_旋转数组/test.exe: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/189_旋转数组/test.exe -------------------------------------------------------------------------------- /算法/191_位1的个数/Solution01.c: -------------------------------------------------------------------------------- 1 | int hammingWeight(uint32_t n) 2 | { 3 | int count = 0; 4 | int i = 0; 5 | const uint32_t arr[32] = 6 | { 7 | 0x00000001,0x00000002,0x00000004,0x00000008, 8 | 0x00000010,0x00000020,0x00000040,0x00000080, 9 | 0x00000100,0x00000200,0x00000400,0x00000800, 10 | 0x00001000,0x00002000,0x00004000,0x00008000, 11 | 0x00010000,0x00020000,0x00040000,0x00080000, 12 | 0x00100000,0x00200000,0x00400000,0x00800000, 13 | 0x01000000,0x02000000,0x04000000,0x08000000, 14 | 0x10000000,0x20000000,0x40000000,0x80000000, 15 | }; 16 | 17 | for(i=0;i<32;i++) 18 | { 19 | if(n&arr[i]) 20 | { 21 | count++; 22 | } 23 | } 24 | 25 | return count; 26 | 27 | } 28 | 29 | /* 30 | 执行结果： 31 | 通过 32 | 显示详情 33 | 执行用时 :4 ms, 在所有 C 提交中击败了86.99% 的用户 34 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了6.02%的用户 35 | */ -------------------------------------------------------------------------------- /算法/191_位1的个数/Solution02.c: -------------------------------------------------------------------------------- 1 | int hammingWeight(uint32_t n) 2 | { 3 | int count = 0; 4 | while(n) 5 | { 6 | count++; 7 | n = n&(n-1); 8 | } 9 | 10 | return count; 11 | 12 | } 13 | 14 | /* 15 | 执行结果： 16 | 通过 17 | 显示详情 18 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 19 | 内存消耗 :6.9 MB, 在所有 C 提交中击败了6.02%的用户 20 | */ -------------------------------------------------------------------------------- /算法/191_位1的个数/Solution03.c: -------------------------------------------------------------------------------- 1 | int hammingWeight(uint32_t n) 2 | { 3 | int count = 0; 4 | 5 | while(n!=0xffffffff) 6 | { 7 | count++; 8 | n = n |(n+1); 9 | } 10 | 11 | return 32-count; 12 | 13 | } 14 | 15 | /* 16 | 执行结果： 17 | 通过 18 | 显示详情 19 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 20 | 内存消耗 :6.7 MB, 在所有 C 提交中击败了6.02%的用户 21 | */ -------------------------------------------------------------------------------- /算法/191_位1的个数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/191_位1的个数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/191_位1的个数/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/191_位1的个数/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/199_二叉树的右视图/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/199_二叉树的右视图/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/203_移除链表元素/Solution01.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | 9 | 10 | struct ListNode* removeElements(struct ListNode* head, int val) 11 | { 12 | struct ListNode* cur = NULL; 13 | struct ListNode* front = NULL; 14 | 15 | 16 | /*首先删除链表首val节点,保证head节点的值不是val*/ 17 | while( (head!=NULL) 18 | &&(head->val==val) 19 | ) 20 | { 21 | cur = head; 22 | head = head-> next; 23 | free(cur); 24 | } 25 | 26 | if(head!=NULL) 27 | { 28 | 29 | front = head; 30 | cur = front->next; 31 | while(cur!=NULL) 32 | { 33 | if(cur->val == val) 34 | { 35 | front->next = cur->next; 36 | free(cur); 37 | cur = front->next; 38 | } 39 | else 40 | { 41 | front = cur; 42 | cur = front->next; 43 | } 44 | } 45 | } 46 | return head; 47 | } 48 | 49 | 50 | /* 51 | 执行结果： 52 | 通过 53 | 显示详情 54 | 执行用时 :16 ms, 在所有 C 提交中击败了95.57% 的用户 55 | 内存消耗 :9.4 MB, 在所有 C 提交中击败了87.50%的用户 56 | */ -------------------------------------------------------------------------------- /算法/203_移除链表元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/203_移除链表元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/204_计算质数个数/状态_未完成.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/204_计算质数个数/状态_未完成.txt -------------------------------------------------------------------------------- /算法/206_反转链表/Solution_01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode* reverseList(ListNode* head) 12 | { 13 | stack si ; 14 | ListNode* temp = head ; 15 | int val_temp = 0 ; 16 | 17 | while(temp!=NULL) 18 | { 19 | si.push(temp->val); 20 | temp = temp->next; 21 | } 22 | temp = head; 23 | while(temp!=NULL) 24 | { 25 | temp->val = si.top(); 26 | si.pop(); 27 | temp = temp->next; 28 | } 29 | return head; 30 | } 31 | }; 32 | 33 | 34 | /* 35 | 执行结果： 36 | 通过 37 | 显示详情 38 | 执行用时 :16 ms, 在所有 C++ 提交中击败了59.98% 的用户 39 | 内存消耗 :9.2 MB, 在所有 C++ 提交中击败了20.28%的用户 40 | */ -------------------------------------------------------------------------------- /算法/206_反转链表/Solution_02.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution 10 | { 11 | public: 12 | ListNode* reverseList(ListNode* head) 13 | { 14 | stack sl ; 15 | ListNode* temp = head ; 16 | 17 | while(temp!=NULL) 18 | { 19 | sl.push(temp); 20 | temp = temp->next; 21 | } 22 | if(sl.empty()!=true) 23 | { 24 | head = sl.top() ; 25 | temp = head ; 26 | sl.pop() ; 27 | while(sl.empty()!=true) 28 | { 29 | temp->next = sl.top(); 30 | sl.pop(); 31 | temp = temp -> next; 32 | } 33 | temp->next = NULL; 34 | 35 | } 36 | return head; 37 | } 38 | }; 39 | 40 | 41 | /* 42 | 执行结果： 43 | 通过 44 | 显示详情 45 | 执行用时 :12 ms, 在所有 C++ 提交中击败了87.55% 的用户 46 | 内存消耗 :9.2 MB, 在所有 C++ 提交中击败了14.09%的用户 47 | */ -------------------------------------------------------------------------------- /算法/206_反转链表/Solution_03.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | 9 | struct ListNode* reverseList(struct ListNode* head) 10 | { 11 | struct ListNode* head_temp = NULL; 12 | struct ListNode* tail_temp = NULL; 13 | struct ListNode* temp = NULL; 14 | 15 | if( ( head == NULL ) 16 | ||( head->next == NULL ) 17 | ) 18 | { 19 | return head; 20 | } 21 | else 22 | { 23 | head_temp = head ; 24 | tail_temp = head ; 25 | temp = tail_temp->next ; 26 | while(1) 27 | { 28 | if(temp==NULL) 29 | { 30 | break; 31 | } 32 | else 33 | { 34 | tail_temp -> next = tail_temp -> next -> next; 35 | temp->next = head_temp; 36 | head_temp = temp; 37 | temp = tail_temp -> next; 38 | } 39 | } 40 | } 41 | return head_temp; 42 | } 43 | 44 | /* 45 | 执行结果： 46 | 通过 47 | 显示详情 48 | 执行用时 :4 ms, 在所有 C 提交中击败了93.16% 的用户 49 | 内存消耗 :7.6 MB, 在所有 C 提交中击败了23.61%的用户 50 | */ 51 | -------------------------------------------------------------------------------- /算法/206_反转链表/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/206_反转链表/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/212_单词搜索 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/212_单词搜索 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/216_组合总和 III/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/216_组合总和 III/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/217_存在重复元素/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | bool containsDuplicate(vector& nums) 5 | { 6 | map mii; 7 | int i = 0; 8 | for(i = 0 ; i < nums.size() ; i++) 9 | { 10 | mii[nums[i]] = 0; 11 | } 12 | return mii.size() == nums.size(); 13 | } 14 | }; 15 | 16 | 17 | /* 18 | 执行结果： 19 | 通过 20 | 显示详情 21 | 执行用时 :40 ms, 在所有 cpp 提交中击败了77.81% 的用户 22 | 内存消耗 :18.1 MB, 在所有 cpp 提交中击败了5.09%的用户 23 | */ -------------------------------------------------------------------------------- /算法/217_存在重复元素/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | bool containsDuplicate(vector& nums) 5 | { 6 | sort(nums.begin(),nums.end()); 7 | for(int i = 1; i < nums.size() ;i++) 8 | { 9 | if(nums[i] == nums[i-1]) 10 | { 11 | return true; 12 | } 13 | } 14 | return false; 15 | } 16 | }; 17 | 18 | 19 | /* 20 | 执行结果： 21 | 通过 22 | 显示详情 23 | 执行用时 :24 ms, 在所有 cpp 提交中击败了98.87% 的用户 24 | 内存消耗 :11.2 MB, 在所有 cpp 提交中击败了80.28%的用户 25 | */ -------------------------------------------------------------------------------- /算法/217_存在重复元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/217_存在重复元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/219_存在重复元素 II/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | private: 5 | /* (left,right]*/ 6 | bool haveSame(vector& nums,int left , int right) 7 | { 8 | int i = 0 ; 9 | for(i = left+1;i<=right;i++) 10 | { 11 | if(nums[left]==nums[i]) 12 | { 13 | return true; 14 | } 15 | } 16 | return false; 17 | } 18 | 19 | public: 20 | bool containsNearbyDuplicate(vector& nums, int k) 21 | { 22 | int right = 0 ; 23 | int i = 0 ; 24 | int len = nums.size() ; 25 | for(i = 0;i& nums, int k) 6 | { 7 | if(nums.size()< 2) 8 | { 9 | return false; 10 | } 11 | else 12 | { 13 | map> mivi; 14 | for(int i = 0 ; i < nums.size();i++) 15 | { 16 | if(mivi.count(nums[i])) 17 | { 18 | mivi[nums[i]].push_back(i); 19 | if(mivi[nums[i]][mivi[nums[i]].size()-1]- mivi[nums[i]][mivi[nums[i]].size()-2] <=k) 20 | { 21 | return true; 22 | } 23 | } 24 | else 25 | { 26 | vector vi; 27 | vi.push_back(i); 28 | mivi[nums[i]] = vi; 29 | } 30 | } 31 | } 32 | return false; 33 | 34 | } 35 | }; 36 | 37 | /* 38 | 执行结果： 39 | 通过 40 | 显示详情 41 | 执行用时 :64 ms, 在所有 cpp 提交中击败了25.25% 的用户 42 | 内存消耗 :22.4 MB, 在所有 cpp 提交中击败了5.03%的用户 43 | */ -------------------------------------------------------------------------------- /算法/219_存在重复元素 II/Solution03.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | public: 5 | bool containsNearbyDuplicate(vector& nums, int k) 6 | { 7 | if(nums.size()< 2) 8 | { 9 | return false; 10 | } 11 | else 12 | { 13 | map mii; 14 | for(int i = 0 ; i < nums.size();i++) 15 | { 16 | if(mii.count(nums[i])) 17 | { 18 | if(i - mii[nums[i]] <=k) 19 | { 20 | return true; 21 | } 22 | else 23 | { 24 | mii[nums[i]] = i; 25 | } 26 | } 27 | else 28 | { 29 | mii[nums[i]] = i; 30 | } 31 | } 32 | } 33 | return false; 34 | 35 | } 36 | }; 37 | 38 | /* 39 | 执行结果： 40 | 通过 41 | 显示详情 42 | 执行用时 :56 ms, 在所有 cpp 提交中击败了39.80% 的用户 43 | 内存消耗 :15.3 MB, 在所有 cpp 提交中击败了28.08%的用户 44 | */ -------------------------------------------------------------------------------- /算法/219_存在重复元素 II/Solution04.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 参考了某个题解, 但我忘记了具体是哪个题解. 3 | class Solution 4 | { 5 | public boolean containsNearbyDuplicate(int[] nums, int k) { 6 | HashSet set = new HashSet<>(); 7 | for(int i = 0; i < nums.length; i++) { 8 | if(set.contains(nums[i])) { 9 | return true; 10 | } 11 | set.add(nums[i]); 12 | if(set.size() > k) { 13 | set.remove(nums[i - k]); 14 | } 15 | } 16 | return false; 17 | } 18 | } 19 | */ 20 | 21 | class Solution 22 | { 23 | public: 24 | bool containsNearbyDuplicate(vector& nums, int k) 25 | { 26 | set s; 27 | for(int i = 0 ; i < nums.size();i++) 28 | { 29 | if(s.count(nums[i])) 30 | { 31 | return true; 32 | 33 | } 34 | s.insert(nums[i]); 35 | if(s.size()>k) 36 | { 37 | s.erase(nums[i-k]); 38 | } 39 | } 40 | return false; 41 | } 42 | }; 43 | 44 | /* 45 | 执行结果： 46 | 通过 47 | 显示详情 48 | 执行用时 :48 ms, 在所有 cpp 提交中击败了52.62% 的用户 49 | 内存消耗 :15.3 MB, 在所有 cpp 提交中击败了38.48%的用户 50 | */ -------------------------------------------------------------------------------- /算法/219_存在重复元素 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/219_存在重复元素 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/219_存在重复元素 II/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/219_存在重复元素 II/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/219_存在重复元素 II/手稿_V1.2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/219_存在重复元素 II/手稿_V1.2.pdf -------------------------------------------------------------------------------- /算法/222_完全二叉树的节点个数/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | /** 11 | * Definition for a binary tree node. 12 | * struct TreeNode { 13 | * int val; 14 | * TreeNode *left; 15 | * TreeNode *right; 16 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 17 | * }; 18 | */ 19 | class Solution 20 | { 21 | private: 22 | int __nodeNum(TreeNode* node) 23 | { 24 | if(node == NULL) 25 | { 26 | return 0; 27 | } 28 | return 1 + __nodeNum(node->left) + __nodeNum(node->right); 29 | } 30 | 31 | public: 32 | int countNodes(TreeNode* root) 33 | { 34 | if(root!=NULL) 35 | { 36 | return 1 + __nodeNum(root->left) + __nodeNum(root->right); 37 | } 38 | return 0; 39 | } 40 | }; 41 | 42 | /* 43 | 执行结果： 44 | 通过 45 | 显示详情 46 | 执行用时 :48 ms, 在所有 C++ 提交中击败了74.73% 的用户 47 | 内存消耗 :28.6 MB, 在所有 C++ 提交中击败了86.43%的用户 48 | */ -------------------------------------------------------------------------------- /算法/222_完全二叉树的节点个数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/222_完全二叉树的节点个数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/230_二叉搜索树中第K小的元素/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | 11 | class Solution 12 | { 13 | private: 14 | int i = 0; 15 | int kk = 0; 16 | int ret_val = 0; 17 | void __midOrderDfs(TreeNode* node) 18 | { 19 | if(node==NULL) 20 | { 21 | return ; 22 | } 23 | __midOrderDfs(node->left); 24 | 25 | if(++i == kk) 26 | { 27 | ret_val = node->val; 28 | return; 29 | } 30 | 31 | __midOrderDfs(node->right); 32 | } 33 | 34 | 35 | public: 36 | int kthSmallest(TreeNode* root, int k) 37 | { 38 | ret_val = 0; 39 | i = 0; 40 | kk = k; 41 | __midOrderDfs(root); 42 | return ret_val; 43 | } 44 | }; 45 | 46 | /* 47 | 执行结果： 48 | 通过 49 | 显示详情 50 | 执行用时 :16 ms, 在所有 C++ 提交中击败了99.56% 的用户 51 | 内存消耗 :21.2 MB, 在所有 C++ 提交中击败了98.83%的用户 52 | */ -------------------------------------------------------------------------------- /算法/230_二叉搜索树中第K小的元素/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/230_二叉搜索树中第K小的元素/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/231_2的幂/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | 给定一个整数，编写一个函数来判断它是否是 2 的幂次方。 4 | 5 | 示例 1: 6 | 输入: 1 7 | 输出: true 8 | 解释: 2^{0} = 1 9 | 10 | 示例 2: 11 | 输入: 16 12 | 输出: true 13 | 解释: 2^{4} = 16 14 | 15 | 16 | 示例 3: 17 | 输入: 218 18 | 输出: false 19 | 20 | */ 21 | 22 | 23 | /*方法1:笨办法计算二进制数中1的个数,不为1个不是*/ 24 | bool isPowerOfTwo(int n) 25 | { 26 | int num_1 = 0; 27 | int i = 0; 28 | if(n <= 0) 29 | { 30 | return false; 31 | } 32 | else 33 | { 34 | for(i = 0 ; i < 31 ; i++) 35 | { 36 | if((n>>i)&0x01) 37 | { 38 | num_1++; 39 | } 40 | 41 | if(num_1>1) 42 | { 43 | break; 44 | } 45 | } 46 | return (num_1 == 1); 47 | } 48 | } 49 | 50 | 51 | 52 | /*方法2:利用借位性质,去掉一个1后数据是不是0*/ 53 | bool isPowerOfTwo(int n) 54 | { 55 | if(n <= 0) 56 | { 57 | return false; 58 | } 59 | else 60 | { 61 | 62 | return (n&(n-1)) == 0; 63 | 64 | } 65 | } 66 | 67 | 68 | /* 69 | 方法1: 70 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00%的用户 71 | 内存消耗 :6.9 MB, 在所有 C 提交中击败了5.02%的用户 72 | */ 73 | 74 | /* 75 | 方法2: 76 | 执行用时:8 ms, 在所有 C 提交中击败了75.77%的用户 77 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了11.42%的用户 78 | */ -------------------------------------------------------------------------------- /算法/235_二叉搜索树的最近公共祖先/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/235_二叉搜索树的最近公共祖先/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/237_删除链表中的节点/Solution01.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | void deleteNode(struct ListNode* node) 9 | { 10 | struct ListNode* front = node ; 11 | struct ListNode* cur = node->next ; 12 | 13 | while(cur->next) 14 | { 15 | front->val = cur->val ; 16 | front = cur ; 17 | cur = cur->next ; 18 | } 19 | 20 | front->val = cur->val ; 21 | free(front->next) ; 22 | front->next = NULL ; 23 | 24 | return ; 25 | } 26 | 27 | /* 28 | 执行结果： 29 | 通过 30 | 显示详情 31 | 执行用时 :8 ms, 在所有 C 提交中击败了87.65% 的用户 32 | 内存消耗 :7.7 MB, 在所有 C 提交中击败了5.09%的用户 33 | */ 34 | 35 | -------------------------------------------------------------------------------- /算法/237_删除链表中的节点/Solution02.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * struct ListNode *next; 6 | * }; 7 | */ 8 | void deleteNode(struct ListNode* node) 9 | { 10 | struct ListNode* temp = NULL ; 11 | 12 | temp = node->next; 13 | node->val = temp->val; 14 | node->next = temp->next; 15 | free(temp); 16 | return ; 17 | } 18 | 19 | /* 20 | 执行结果： 21 | 通过 22 | 显示详情 23 | 执行用时 :4 ms, 在所有 C 提交中击败了99.09% 的用户 24 | 内存消耗 :7.7 MB, 在所有 C 提交中击败了5.09%的用户 25 | */ 26 | 27 | -------------------------------------------------------------------------------- /算法/237_删除链表中的节点/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/237_删除链表中的节点/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/237_删除链表中的节点/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/237_删除链表中的节点/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/242_有效的字母异位词/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | bool isAnagram(string s, string t) 5 | { 6 | int count_s[26] = {0,} ; 7 | int count_t[26] = {0,} ; 8 | int i = 0 ; 9 | 10 | if(s.size()!=t.size()) 11 | { 12 | return false; 13 | } 14 | for(i = 0;i < s.size();i++) 15 | { 16 | count_s[s[i]-'a']++; 17 | } 18 | for(i = 0;i < t.size();i++) 19 | { 20 | count_t[t[i]-'a']++; 21 | } 22 | for(i=0;i<26;i++) 23 | { 24 | if(count_s[i]!=count_t[i]) 25 | { 26 | return false; 27 | } 28 | } 29 | return true; 30 | } 31 | }; 32 | 33 | 34 | /* 35 | 执行结果： 36 | 通过 37 | 显示详情 38 | 执行用时 :12 ms, 在所有 cpp 提交中击败了83.76% 的用户 39 | 内存消耗 :9.6 MB, 在所有 cpp 提交中击败了6.07%的用户 40 | */ -------------------------------------------------------------------------------- /算法/242_有效的字母异位词/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | bool isAnagram(string s, string t) 5 | { 6 | int count[26] = {0,} ; 7 | int i = 0 ; 8 | 9 | for(i = 0;i < s.size();i++) 10 | { 11 | count[s[i]-'a']++; 12 | } 13 | for(i = 0;i < t.size();i++) 14 | { 15 | count[t[i]-'a']--; 16 | } 17 | for(i=0;i<26;i++) 18 | { 19 | if(count[i]!=0x00) 20 | { 21 | return false; 22 | } 23 | } 24 | return true; 25 | } 26 | }; 27 | 28 | 29 | 30 | /* 31 | 执行结果： 32 | 通过 33 | 显示详情 34 | 执行用时 :12 ms, 在所有 cpp 提交中击败了83.76% 的用户 35 | 内存消耗 :9.4 MB, 在所有 cpp 提交中击败了12.73%的用户 36 | */ -------------------------------------------------------------------------------- /算法/242_有效的字母异位词/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/242_有效的字母异位词/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/257_二叉树的所有路径/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/257_二叉树的所有路径/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/258_各位相加/Solution01_CPP.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 给定一个非负整数 num，反复将各个位上的数字相加，直到结果为一位数。 3 | 示例: 4 | 输入: 38 5 | 输出: 2 6 | 解释: 各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于 2 是一位数，所以返回 2。 7 | 进阶: 8 | 你可以不使用循环或者递归，且在 O(1) 时间复杂度内解决这个问题吗？ 9 | */ 10 | class Solution { 11 | public: 12 | int addDigits(int num) { 13 | if(num==0) 14 | { 15 | return 0; 16 | } 17 | else if(num%9==0) 18 | { 19 | return 9; 20 | } 21 | else 22 | { 23 | return num%9; 24 | } 25 | } 26 | }; -------------------------------------------------------------------------------- /算法/260_只出现一次的数字III/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector singleNumber(vector& nums) 5 | { 6 | vector ret_val ; 7 | map mii ; 8 | int i ; 9 | map::iterator iter ; 10 | 11 | for( i = 0; i < nums.size() ; i++) 12 | { 13 | if(mii.count(nums[i])==1) 14 | { 15 | mii[nums[i]] = 2; 16 | } 17 | else 18 | { 19 | mii[nums[i]] = 1; 20 | } 21 | } 22 | 23 | iter = mii.begin(); 24 | while(iter!=mii.end()) 25 | { 26 | if(iter->second == 1) 27 | { 28 | ret_val.push_back(iter->first); 29 | } 30 | iter++; 31 | } 32 | return ret_val; 33 | } 34 | }; 35 | 36 | /* 37 | 执行结果： 38 | 通过 39 | 显示详情 40 | 执行用时 :24 ms, 在所有 C++ 提交中击败了35.58% 的用户 41 | 内存消耗 :10.9 MB, 在所有 C++ 提交中击败了5.50%的用户 42 | */ -------------------------------------------------------------------------------- /算法/260_只出现一次的数字III/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/260_只出现一次的数字III/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/263_丑数/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | 编写一个程序判断给定的数是否为丑数。 4 | 丑数就是只包含质因数 2, 3, 5 的正整数。 5 | 示例 1: 6 | 输入: 6 7 | 输出: true 8 | 解释: 6 = 2 × 3 9 | 示例 2: 10 | 输入: 8 11 | 输出: true 12 | 解释: 8 = 2 × 2 × 2 13 | 示例 3: 14 | 输入: 14 15 | 输出: false 16 | 解释: 14 不是丑数，因为它包含了另外一个质因数 7。 17 | 说明: 18 | 1 是丑数。 19 | 输入不会超过 32 位有符号整数的范围: [−2^31, 2^31 − 1]。 20 | */ 21 | 22 | /*基本思路:利用求余运算探测,若有质因数2 3 5 就以除法的方式去掉*/ 23 | bool isUgly(int num) 24 | { 25 | bool ret_val = true; 26 | 27 | do 28 | { 29 | if(num < 1) 30 | { 31 | ret_val = false; 32 | break; 33 | } 34 | 35 | while( ( num !=1 ) 36 | &&( num%2 ==0 ) 37 | ) 38 | { 39 | num /= 2; 40 | } 41 | 42 | while( ( num !=1 ) 43 | &&( num%3 ==0 ) 44 | ) 45 | { 46 | num /= 3; 47 | } 48 | 49 | 50 | while( ( num !=1 ) 51 | &&( num%5 ==0 ) 52 | ) 53 | { 54 | num /= 5; 55 | } 56 | 57 | ret_val = (num == 1); 58 | break; 59 | }while(0); 60 | return ret_val; 61 | } 62 | 63 | /* 64 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00%的用户 65 | 内存消耗 :6.6 MB, 在所有 C 提交中击败了54.44%的用户 66 | */ 67 | -------------------------------------------------------------------------------- /算法/268_缺失数字/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | /* 3 | 给定一个包含 0, 1, 2, ..., n 中 n 个数的序列，找出 0 .. n 中没有出现在序列中的那个数。 4 | 示例 1: 5 | 输入: [3,0,1] 6 | 输出: 2 7 | 示例 2: 8 | 输入: [9,6,4,2,3,5,7,0,1] 9 | 输出: 8 10 | */ 11 | 12 | 13 | int missingNumber(int* nums, int numsSize) 14 | { 15 | int ret_val = 0; 16 | for(int i = 0; i < numsSize ; i++) 17 | { 18 | ret_val ^= nums[i]; 19 | ret_val ^= i; 20 | } 21 | 22 | ret_val ^= numsSize; 23 | return ret_val; 24 | } 25 | /* 26 | 122 / 122 个通过测试用例 27 | 状态：通过 28 | 执行用时：20 ms 29 | 提交时间：0 分钟之前 30 | 执行用时 : 20 ms, 在Missing Number的C提交中击败了62.69% 的用户 31 | 内存消耗 : 7.9 MB, 在Missing Number的C提交中击败了8.37% 的用户 32 | */ 33 | 34 | int missingNumber(int* nums, int numsSize){ 35 | 36 | unsigned long int sum = numsSize*(numsSize+1)/2; 37 | for(int i = 0; i < numsSize ; i++) 38 | { 39 | sum -= nums[i]; 40 | } 41 | return sum; 42 | } 43 | 44 | /* 45 | 122 / 122 个通过测试用例 46 | 状态：通过 47 | 执行用时：32 ms 48 | 提交时间：0 分钟之前 49 | 执行用时 : 32 ms, 在Missing Number的C提交中击败了33.55% 的用户 50 | 内存消耗 : 7.6 MB, 在Missing Number的C提交中击败了33.02% 的用户 51 | */ 52 | 53 | 54 | 55 | -------------------------------------------------------------------------------- /算法/278_第一个错误的版本/Solution02.c: -------------------------------------------------------------------------------- 1 | 2 | // Forward declaration of isBadVersion API. 3 | bool isBadVersion(int version); 4 | 5 | int firstBadVersion(int n) { 6 | 7 | int left = 0; 8 | int right = n-1; 9 | int mid = 0; 10 | int ret_val = -1; 11 | bool flag_1 = false; 12 | bool flag_2 = false; 13 | 14 | 15 | if(n==1) 16 | { 17 | return 1; 18 | } 19 | 20 | if(n<1) /*不符合题设定义*/ 21 | { 22 | return -1; 23 | } 24 | 25 | while(left<=right) 26 | { 27 | mid = left+(right-left)/2; 28 | if(isBadVersion(mid)==false) 29 | { 30 | if(isBadVersion(mid+1)==true) 31 | { 32 | ret_val = mid+1; 33 | break; 34 | } 35 | else 36 | { 37 | left = mid + 1; 38 | } 39 | 40 | } 41 | else 42 | { 43 | right = mid - 1; 44 | } 45 | } 46 | return ret_val; 47 | } 48 | 49 | /* 50 | 执行结果： 51 | 通过 52 | 显示详情 53 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 54 | 内存消耗 :6.6 MB, 在所有 C 提交中击败了58.55%的用户 55 | */ -------------------------------------------------------------------------------- /算法/278_第一个错误的版本/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/278_第一个错误的版本/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/278_第一个错误的版本/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/278_第一个错误的版本/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/287_寻找重复数/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int findDuplicate(vector& nums) 5 | { 6 | int temp1 = 0x00 ; 7 | int temp2 = 0x00 ; 8 | int temp3 = 0x00 ; 9 | 10 | int i = 0 ; 11 | int n = nums.size() ; 12 | 13 | for(i = 1; i <= n ; i ++) 14 | { 15 | temp1 ^= i; 16 | } 17 | 18 | for(i = 0; i < n ; i++) 19 | { 20 | temp2 ^= nums[i]; 21 | temp3 = temp3 + nums[i] -(i + 1); 22 | } 23 | 24 | /* 25 | X 是多的 26 | Y 是少的 27 | temp1 = X^Y; 28 | temp3 = X-Y; 29 | 30 | 可惜异或并不满足分配率,无法继续进行下去 31 | 若temp3 > 0: 32 | X = Y+temp3 33 | temp1 = Y^(Y+temp3); 34 | temp1 = Y^temp3 35 | Y = temp1^temp3 36 | 37 | 38 | */ 39 | } 40 | }; -------------------------------------------------------------------------------- /算法/287_寻找重复数/Solution03.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 收录一个Joke代码 3 | @湛蓝水晶 https://leetcode-cn.com/problems/find-the-duplicate-number/comments/39533 4 | 蒙特卡罗方法 5 | */ 6 | int findDuplicate(int* nums, int numsSize) 7 | { 8 | srand(time(0)); 9 | int a, b; 10 | while(true) 11 | { 12 | a = rand()%numsSize; 13 | b = rand()%numsSize; 14 | if(a == b) 15 | { 16 | continue; 17 | } 18 | if(nums[a]==nums[b]) 19 | { 20 | return nums[a]; 21 | } 22 | } 23 | return -1; 24 | 25 | } 26 | /* 27 | 执行结果： 28 | 通过 29 | 显示详情 30 | 执行用时 :1156 ms, 在所有 c 提交中击败了5.10% 的用户 31 | 内存消耗 :8.2 MB, 在所有 c 提交中击败了9.86%的用户 32 | 种子取得不好的时候还会: 33 | 超出时间限制 34 | */ 35 | 36 | -------------------------------------------------------------------------------- /算法/287_寻找重复数/Solution04.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | /* java ---> C++,todo*/ 4 | public int findDuplicate(int[] nums) 5 | { 6 | /** 7 | 快慢指针思想, fast 和 slow 是指针, nums[slow] 表示取指针对应的元素 8 | 注意 nums 数组中的数字都是在 1 到 n 之间的(在数组中进行游走不会越界), 9 | 因为有重复数字的出现, 所以这个游走必然是成环的, 环的入口就是重复的元素, 10 | 即按照寻找链表环入口的思路来做 11 | **/ 12 | int fast = 0; 13 | int slow = 0; 14 | while(true) 15 | { 16 | fast = nums[nums[fast]]; 17 | slow = nums[slow]; 18 | if(slow == fast) 19 | { 20 | fast = 0; 21 | while(nums[slow] != nums[fast]) 22 | { 23 | fast = nums[fast]; 24 | slow = nums[slow]; 25 | } 26 | return nums[slow]; 27 | } 28 | } 29 | } 30 | } 31 | /* 32 | 执行结果： 33 | 通过 34 | 显示详情 35 | 执行用时 :1156 ms, 在所有 c 提交中击败了5.10% 的用户 36 | 内存消耗 :8.2 MB, 在所有 c 提交中击败了9.86%的用户 37 | 种子取得不好的时候还会: 38 | 超出时间限制 39 | */ 40 | 41 | -------------------------------------------------------------------------------- /算法/287_寻找重复数/Solution05.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | 5 | int findDuplicate(vector& nums) 6 | { 7 | int n = nums.size() - 1; 8 | int left = 1 ; 9 | int right = n ; 10 | int mid = 0 ; 11 | int count = 0 ; 12 | 13 | while(left < right) 14 | { 15 | mid = left + (right - left) / 2; 16 | 17 | for(i = 0;i <= n;i++) 18 | { 19 | if(nums[i] < mid) 20 | { 21 | count++; 22 | } 23 | } 24 | 25 | if(count > mid ) 26 | { 27 | right = mid; 28 | } 29 | else 30 | { 31 | left = mid + 1; 32 | } 33 | 34 | } 35 | 36 | return left; 37 | 38 | } 39 | }; 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :1156 ms, 在所有 c 提交中击败了5.10% 的用户 45 | 内存消耗 :8.2 MB, 在所有 c 提交中击败了9.86%的用户 46 | 种子取得不好的时候还会: 47 | 超出时间限制 48 | */ 49 | 50 | -------------------------------------------------------------------------------- /算法/289_生命游戏/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/289_生命游戏/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/292_Nim游戏/Solution01.c: -------------------------------------------------------------------------------- 1 | /* 2 | 你和你的朋友，两个人一起玩 Nim 游戏：桌子上有一堆石头，每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。 3 | 你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。 4 | 示例: 5 | 输入: 4 6 | 输出: false 7 | 解释: 如果堆中有 4 块石头，那么你永远不会赢得比赛； 8 | 因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。 9 | */ 10 | 11 | 12 | 13 | bool canWinNim(int n){ 14 | 15 | if(n <= 0) 16 | { 17 | return (n > 0); 18 | } 19 | n = n % 4; 20 | return (n != 0); 21 | 22 | } 23 | 24 | 25 | 26 | 27 | /* 28 | 60 / 60 个通过测试用例 29 | 状态：通过 30 | 执行用时：0 ms 31 | 32 | 提交时间：13 分钟之前 33 | 34 | */ -------------------------------------------------------------------------------- /算法/328_奇偶链表/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/328_奇偶链表/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/342_4的幂/Solution01.c: -------------------------------------------------------------------------------- 1 | bool isPowerOfFour(int num) 2 | { 3 | int count = 0 ; 4 | int temp = num ; 5 | 6 | if(num <=0) 7 | { 8 | return false; 9 | } 10 | 11 | temp = temp & (temp -1); 12 | 13 | if( ( temp == 0 ) 14 | &&( num & 0x55555555 ) 15 | ) 16 | { 17 | return true; 18 | } 19 | return false; 20 | } 21 | 22 | /* 23 | 执行结果： 24 | 通过 25 | 显示详情 26 | 执行用时 :4 ms, 在所有 C 提交中击败了84.62% 的用户 27 | 内存消耗 :6.9 MB, 在所有 C 提交中击败了5.95%的用户 28 | */ -------------------------------------------------------------------------------- /算法/342_4的幂/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | 给定一个整数 (32 位有符号整数)，请编写一个函数来判断它是否是 4 的幂次方。 3 | 4 | 示例 1: 5 | 6 | 输入: 16 7 | 输出: true 8 | 示例 2: 9 | 10 | 输入: 5 11 | 输出: false 12 | 进阶： 13 | 你能不使用循环或者递归来完成本题吗？ 14 | 15 | 来源：力扣（LeetCode） 16 | 链接：https://leetcode-cn.com/problems/power-of-four 17 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 18 | ``` 19 | 分析: 20 | + 4的幂次方,一定是2的幂次方,在二进制位中一定只有一个1,且1出现一定在奇数位置上. 21 | 22 | *** 23 | 方法一:C_Solution 24 | ```C 25 | bool isPowerOfFour(int num) 26 | { 27 | int count = 0 ; 28 | int temp = num ; 29 | 30 | if(num <=0) 31 | { 32 | return false; 33 | } 34 | 35 | temp = temp & (temp -1); 36 | 37 | if( ( temp == 0 ) 38 | &&( num & 0x55555555 ) 39 | ) 40 | { 41 | return true; 42 | } 43 | return false; 44 | } 45 | 46 | /* 47 | 执行结果： 48 | 通过 49 | 显示详情 50 | 执行用时 :4 ms, 在所有 C 提交中击败了84.62% 的用户 51 | 内存消耗 :6.9 MB, 在所有 C 提交中击败了5.95%的用户 52 | */ 53 | ``` 54 | 55 | *** 56 | 57 |
58 | AlimyBreak 59 |
60 |
61 | 2019.08.04 62 |
-------------------------------------------------------------------------------- /算法/342_4的幂/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/342_4的幂/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/344_反转字符串/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | /* 4 | 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 char[] 的形式给出。 5 | 不要给另外的数组分配额外的空间，你必须原地修改输入数组、使用 O(1) 的额外空间解决这一问题。 6 | 你可以假设数组中的所有字符都是 ASCII 码表中的可打印字符。 7 | 示例 1： 8 | 输入：["h","e","l","l","o"] 9 | 输出：["o","l","l","e","h"] 10 | 示例 2： 11 | 输入：["H","a","n","n","a","h"] 12 | 输出：["h","a","n","n","a","H"] 13 | */ 14 | 15 | 16 | void reverse_char_array(char* s,int left ,int right) 17 | { 18 | int swap_times = (right - left + 1)/2; 19 | char temp = 0; 20 | int i = 0; 21 | for( i = 0; i < swap_times ; i++) 22 | { 23 | temp = s[left+i]; 24 | s[left+i] = s[right-i]; 25 | s[right-i] = temp; 26 | } 27 | } 28 | 29 | void reverseString(char* s, int sSize) 30 | { 31 | reverse_char_array(s,0,sSize-1); 32 | } 33 | 34 | /* 35 | 感动: 36 | 执行用时 : 64 ms, 在Reverse String的C提交中击败了98.94% 的用户 37 | 内存消耗 : 13.5 MB, 在Reverse String的C提交中击败了75.79% 的用户 38 | 478 / 478 个通过测试用例 39 | 状态：通过 40 | 执行用时：68 ms 41 | 提交时间：5 分钟之前 42 | */ -------------------------------------------------------------------------------- /算法/345_反转字符串中的元音字母/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | bool isVowel(char c) 3 | { 4 | bool ret_val = false; 5 | ret_val = (c == 'a') || ( c == 'o') || (c == 'e') || ( c == 'i') || (c == 'u') || (c == 'A') || ( c == 'O') || (c == 'E') || ( c == 'I') || (c == 'U') ; 6 | return ret_val; 7 | } 8 | 9 | 10 | char* reverseVowels(char* s) 11 | { 12 | int len = strlen(s) ; 13 | char temp = 0 ;/*用于数据交换*/ 14 | int left = 0 ; 15 | int right = len-1 ; 16 | 17 | while(left intersection(vector& nums1, vector& nums2) 5 | { 6 | vector ret_val ; 7 | map mii1 ; 8 | map mii2 ; 9 | map::iterator iter; 10 | int i ; 11 | for(i = 0; i < nums1.size();i++) 12 | { 13 | mii1[nums1[i]] = 1; 14 | } 15 | for(i = 0; i < nums2.size();i++) 16 | { 17 | mii2[nums2[i]] = 1; 18 | } 19 | 20 | iter = mii2.begin(); 21 | while(iter!=mii2.end()) 22 | { 23 | if(mii1.count(iter->first)==1) 24 | { 25 | ret_val.push_back(iter->first); 26 | } 27 | iter++; 28 | } 29 | return ret_val; 30 | } 31 | }; 32 | 33 | /* 34 | 执行结果： 35 | 通过 36 | 显示详情 37 | 执行用时 :12 ms, 在所有 C++ 提交中击败了80.21% 的用户 38 | 内存消耗 :9.8 MB, 在所有 C++ 提交中击败了6.36%的用户 39 | */ -------------------------------------------------------------------------------- /算法/349_两个数组的交集/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/349_两个数组的交集/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/350_两个数组的交集 II/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/350_两个数组的交集 II/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/357_计算各个位数不同的数字个数/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | public: 5 | int countNumbersWithUniqueDigits(int n) 6 | { 7 | int ret_val = 0; 8 | int temp = 0; 9 | int arr[10] = {9,9,8,7,6,5,4,3,2,1}; 10 | int i = 0; 11 | int j = 0; 12 | 13 | if(n < 0) 14 | { 15 | return ret_val; 16 | } 17 | 18 | if(n > 10) 19 | { 20 | n = 10; 21 | } 22 | 23 | ret_val = 1; 24 | 25 | for( i = 1; i <= n ; i++) 26 | { 27 | temp = 1; 28 | for(j = 0 ; j < i ; j++) 29 | { 30 | temp *= arr[j]; 31 | } 32 | 33 | ret_val += temp; 34 | } 35 | 36 | 37 | return ret_val; 38 | } 39 | }; 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :0 ms, 在所有 cpp 提交中击败了100.00% 的用户 45 | 内存消耗 :8.1 MB, 在所有 cpp 提交中击败了72.30%的用户 46 | */ 47 | -------------------------------------------------------------------------------- /算法/357_计算各个位数不同的数字个数/Solution03.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | public: 5 | int countNumbersWithUniqueDigits(int n) 6 | { 7 | int ret_val = 0; 8 | int arr[11] = {1,10,91,739,5275,32491,168571,712891,2345851,5611771,8877691}; 9 | if(n>=0) 10 | { 11 | if(n>=10) 12 | { 13 | n = 10; 14 | } 15 | ret_val = arr[n]; 16 | } 17 | 18 | 19 | return ret_val; 20 | } 21 | }; 22 | 23 | /* 24 | 执行结果： 25 | 通过 26 | 显示详情 27 | 执行用时 :0 ms, 在所有 cpp 提交中击败了100.00% 的用户 28 | 内存消耗 :8 MB, 在所有 cpp 提交中击败了89.86%的用户 29 | */ -------------------------------------------------------------------------------- /算法/357_计算各个位数不同的数字个数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/357_计算各个位数不同的数字个数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/367_有效的完全平方数/Solution01.c: -------------------------------------------------------------------------------- 1 | /* 2 | 给定一个正整数 num，编写一个函数，如果 num 是一个完全平方数，则返回 True，否则返回 False。 3 | 说明：不要使用任何内置的库函数，如sqrt()。 4 | 示例 1： 5 | 输入：16 6 | 输出：True 7 | 示例 2： 8 | 输入：14 9 | 输出：False 10 | */ 11 | 12 | 13 | /* 14 | 基本原理：奇数数列的累加和就是完全平方数. 15 | */ 16 | bool isPerfectSquare(int num) 17 | { 18 | bool ret_val = false ; 19 | int i = 1 ; 20 | do 21 | { 22 | if(num <=0) 23 | { 24 | break; 25 | } 26 | 27 | while(num>0) 28 | { 29 | num = num - i; 30 | if(num==0) 31 | { 32 | ret_val = true; 33 | break; 34 | } 35 | i = i + 2; 36 | } 37 | break; 38 | }while(0); 39 | return ret_val; 40 | } 41 | 42 | /* 43 | 执行用时 :4 ms, 在所有 C 提交中击败了94.56%的用户 44 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了5.71%的用户 45 | */ 46 | -------------------------------------------------------------------------------- /算法/387_字符串中的第一个唯一字符/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | int firstUniqChar(char * s){ 4 | 5 | int char_num[26] = {0,}; 6 | int i = 0; 7 | int ret_val = -1; 8 | 9 | memset(char_num,0,sizeof(int)*26); 10 | 11 | /*第一次遍历,$O(N)$*/ 12 | while(s[i]) 13 | { 14 | ++char_num[s[i]-'a']; 15 | ++i; 16 | } 17 | 18 | /*第二次遍历$O(N)$*/ 19 | i = 0; 20 | while(s[i]) 21 | { 22 | if(char_num[s[i]-'a']==1) 23 | { 24 | ret_val = i; 25 | break; 26 | } 27 | ++i; 28 | } 29 | return ret_val; 30 | } 31 | 32 | 33 | /* 34 | 执行结果：通过 35 | 显示详情 36 | 执行用时 :16 ms, 在所有 C 提交中击败了84.11%的用户 37 | 内存消耗 :8.1 MB, 在所有 C 提交中击败了94.98%的用户 38 | */ 39 | 40 | -------------------------------------------------------------------------------- /算法/387_字符串中的第一个唯一字符/手稿V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/387_字符串中的第一个唯一字符/手稿V1.0.pdf -------------------------------------------------------------------------------- /算法/389_找不同/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | char findTheDifference(char * s, char * t) 4 | { 5 | char ret_val = 0x00 ; 6 | int i = 0 ; 7 | 8 | while(s[i]) 9 | { 10 | ret_val ^= s[i]; 11 | i++; 12 | } 13 | 14 | i = 0; 15 | while(t[i]) 16 | { 17 | ret_val ^= t[i]; 18 | i++; 19 | } 20 | 21 | return ret_val; 22 | } 23 | 24 | /* 25 | 执行结果： 26 | 通过 27 | 显示详情 28 | 执行用时 :4 ms, 在所有 C 提交中击败了82.67% 的用户 29 | 内存消耗 :7 MB, 在所有 C 提交中击败了71.05%的用户 30 | */ -------------------------------------------------------------------------------- /算法/389_找不同/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | 给定两个字符串 s 和 t，它们只包含小写字母。 4 | 字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。 5 | 请找出在 t 中被添加的字母。 6 | 示例: 7 | 输入： 8 | s = "abcd" 9 | t = "abcde" 10 | 输出： 11 | e 12 | 解释： 13 | 'e' 是那个被添加的字母。 14 | 来源：力扣（LeetCode） 15 | 链接：https://leetcode-cn.com/problems/find-the-difference 16 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 17 | */ 18 | ``` 19 | 20 | *** 21 | 22 | 分析： 23 | 24 | + 异或特性一下解决。 25 | 26 | *** 27 | 28 | 方法一:C_异或 29 | 30 | ```C 31 | char findTheDifference(char * s, char * t) 32 | { 33 | char ret_val = 0x00 ; 34 | int i = 0 ; 35 | 36 | while(s[i]) 37 | { 38 | ret_val ^= s[i]; 39 | i++; 40 | } 41 | 42 | i = 0; 43 | while(t[i]) 44 | { 45 | ret_val ^= t[i]; 46 | i++; 47 | } 48 | 49 | return ret_val; 50 | } 51 | 52 | /* 53 | 执行结果： 54 | 通过 55 | 显示详情 56 | 执行用时 :4 ms, 在所有 C 提交中击败了82.67% 的用户 57 | 内存消耗 :7 MB, 在所有 C 提交中击败了71.05%的用户 58 | */ 59 | ``` 60 | 61 | *** 62 | 63 |
64 | AlimyBreak 65 |
66 | 67 |
68 | 2019.08.10 69 |
70 | 71 | -------------------------------------------------------------------------------- /算法/389_找不同/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/389_找不同/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/401_二进制手表/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/401_二进制手表/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/404_左叶子节点求和/Solution01.c: -------------------------------------------------------------------------------- 1 | /* 2 | 计算给定二叉树的所有左叶子之和。 3 | 示例: 4 | 3 5 | / \ 6 | 9 20 7 | / \ 8 | 15 7 9 | 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24 10 | */ 11 | 12 | 13 | /** 14 | * Definition for a binary tree node. 15 | * struct TreeNode { 16 | * int val; 17 | * struct TreeNode *left; 18 | * struct TreeNode *right; 19 | * }; 20 | */ 21 | 22 | /* 23 | flag = 0 ;起始根节点 24 | flag = 1 ;是其父节点的左孩子 25 | flag = 2 ;是其父节点的有孩子 26 | */ 27 | 28 | int left_sum = 0; 29 | void PreOrder(struct TreeNode* treenode,int flag ) 30 | { 31 | if(treenode == NULL) 32 | { 33 | return ; 34 | } 35 | 36 | if(( treenode->left == NULL)&&(treenode->right == NULL)&&(flag == 1)) 37 | { 38 | left_sum += treenode->val; 39 | return ; 40 | } 41 | PreOrder(treenode->left,1); 42 | PreOrder(treenode->right,2); 43 | return ; 44 | } 45 | 46 | int sumOfLeftLeaves(struct TreeNode* root) 47 | { 48 | left_sum = 0; 49 | PreOrder(root,0); 50 | return left_sum; 51 | } 52 | 53 | /* 54 | 令人感动. 55 | 102 / 102 个通过测试用例 状态：通过 56 | 执行用时:8 ms,提交时间：2 分钟之前 57 | 执行用时:8 ms, 在所有C提交中击败了92.13% 的用户 58 | 内存消耗:7.6 MB, 在所有C提交中击败了100.00%的用户 59 | */ 60 | -------------------------------------------------------------------------------- /算法/415_字符串相加/make.cmd: -------------------------------------------------------------------------------- 1 | gcc Solution01.c -o test.exe -lstdc++ -------------------------------------------------------------------------------- /算法/423_从英文中重建数字/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/423_从英文中重建数字/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/429_N叉树的层序遍历/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/429_N叉树的层序遍历/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/437_路径总和3/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/437_路径总和3/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/441_排列硬币/Soluion01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int arrangeCoins(int n) 5 | { 6 | int level = 1; 7 | 8 | while(n >= level) 9 | { 10 | n -= level; 11 | level++; 12 | } 13 | return level-1; 14 | } 15 | }; 16 | 17 | 18 | /* 19 | 执行结果： 20 | 通过 21 | 显示详情 22 | 执行用时 :16 ms, 在所有 cpp 提交中击败了47.14% 的用户 23 | 内存消耗 :8.1 MB, 在所有 cpp 提交中击败了90.74%的用户 24 | */ -------------------------------------------------------------------------------- /算法/441_排列硬币/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int arrangeCoins(int n) 5 | { 6 | return (int)((sqrt(1 + ((long long)n <<3)) - 1) / 2); 7 | } 8 | }; 9 | 10 | 11 | /* 12 | 执行结果： 13 | 通过 14 | 显示详情 15 | 执行用时 :8 ms, 在所有 cpp 提交中击败了79.15% 的用户 16 | 内存消耗 :8.1 MB, 在所有 cpp 提交中击败了86.30%的用户 17 | */ -------------------------------------------------------------------------------- /算法/441_排列硬币/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/441_排列硬币/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/442_数组中重复的数据/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector findDuplicates(vector& nums) 5 | { 6 | map mii; 7 | int i = 0; 8 | vector ret_val ; 9 | 10 | for(i=0;i findDuplicates(vector& nums) 5 | { 6 | int i = 0; 7 | vector ret_val ; 8 | 9 | for(i=0;i findDisappearedNumbers(vector& nums) 5 | { 6 | map mii; 7 | vector ret; 8 | int i = 0; 9 | for(i=0;i findDisappearedNumbers(vector& nums) 5 | { 6 | vector ret; 7 | int i = 0; 8 | for(i=0;i0) 11 | { 12 | nums[abs(nums[i])-1] *= -1; 13 | } 14 | } 15 | 16 | for(i=0;i 0) 19 | { 20 | ret.push_back(i+1); 21 | } 22 | } 23 | return ret; 24 | } 25 | }; 26 | /* 27 | 执行结果： 28 | 通过 29 | 显示详情 30 | 执行用时 :120 ms, 在所有 cpp 提交中击败了90.19% 的用户 31 | 内存消耗 :14.8 MB, 在所有 cpp 提交中击败了88.05%的用户 32 | */ -------------------------------------------------------------------------------- /算法/448_找到所有数组中消失的数字/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/448_找到所有数组中消失的数字/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/451_根据字符出现频率排序/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/451_根据字符出现频率排序/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/461_汉明距离/Solution01.c: -------------------------------------------------------------------------------- 1 | int hammingDistance(int x, int y) 2 | { 3 | unsigned int z = 0; 4 | 5 | int count = 0; 6 | 7 | z = (unsigned int)(x)^(unsigned int)(y); 8 | while(z!=0xffffffff) 9 | { 10 | count++; 11 | z = z|(z+1); 12 | } 13 | return (32-count); 14 | } 15 | 16 | /* 17 | 执行结果： 18 | 通过 19 | 显示详情 20 | 执行用时 :4 ms, 在所有 C 提交中击败了82.65% 的用户 21 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了65.13%的用户 22 | */ -------------------------------------------------------------------------------- /算法/461_汉明距离/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | 两个整数之间的汉明距离指的是这两个数字对应二进制位不同的位置的数目。 4 | 5 | 给出两个整数 x 和 y，计算它们之间的汉明距离。 6 | 7 | 注意： 8 | 0 ≤ x, y < 231. 9 | 10 | 示例: 11 | 12 | 输入: x = 1, y = 4 13 | 14 | 输出: 2 15 | 16 | 解释: 17 | 1 (0 0 0 1) 18 | 4 (0 1 0 0) 19 | ↑ ↑ 20 | 21 | 上面的箭头指出了对应二进制位不同的位置。 22 | 23 | 来源：力扣（LeetCode） 24 | 链接：https://leetcode-cn.com/problems/hamming-distance 25 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 26 | */ 27 | ``` 28 | 29 | *** 30 | 31 | 分析： 32 | 33 | + 显然将这两个整数取异或以后再统计结果数据中二进制位为1的个数即可，与 191题 https://github.com/AlimyBreak/LeetCodeStudy/tree/master/%E7%AE%97%E6%B3%95/191_%E4%BD%8D1%E7%9A%84%E4%B8%AA%E6%95%B0 思路基本一致. 34 | 35 | *** 36 | 方法一：C_Solution 37 | ```C 38 | int hammingDistance(int x, int y) 39 | { 40 | unsigned int z = 0; 41 | 42 | int count = 0; 43 | 44 | z = (unsigned int)(x)^(unsigned int)(y); 45 | while(z!=0xffffffff) 46 | { 47 | count++; 48 | z = z|(z+1); 49 | } 50 | return (32-count); 51 | } 52 | /* 53 | 执行结果： 54 | 通过 55 | 显示详情 56 | 执行用时 :4 ms, 在所有 C 提交中击败了82.65% 的用户 57 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了65.13%的用户 58 | */ 59 | ``` 60 | *** 61 | 62 |
63 | AlimyBreak 64 |
65 | 66 |
67 | 2019.07.23 68 |
69 | 70 | 71 | 72 | 73 | 74 | -------------------------------------------------------------------------------- /算法/461_汉明距离/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/461_汉明距离/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/476_数字的补数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/476_数字的补数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/477_汉明距离总和/Solution02.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | int totalHammingDistance(int* nums, int numsSize) 4 | { 5 | int ret_val = 0 ; 6 | int bit1_nums = {0,} ; 7 | int i = 0 ; 8 | int j = 0 ; 9 | int bit_arr[32] = { 10 | 0x00000001,0x00000002,0x00000004,0x00000008, 11 | 0x00000010,0x00000020,0x00000040,0x00000080, 12 | 0x00000100,0x00000200,0x00000400,0x00000800, 13 | 0x00001000,0x00002000,0x00004000,0x00008000, 14 | 0x00010000,0x00020000,0x00040000,0x00080000, 15 | 0x00100000,0x00200000,0x00400000,0x00800000, 16 | 0x01000000,0x02000000,0x04000000,0x08000000, 17 | 0x10000000,0x20000000,0x40000000,0x80000000, 18 | }; 19 | 20 | 21 | for(i = 0; i < 32 ; i++) 22 | { 23 | bit1_nums = 0; 24 | for(j=0;j=(ind_tail-ind_front)) ? ret_val : (ind_tail-ind_front); 25 | ind_tail++; 26 | ind_front=ind_tail; 27 | } 28 | } 29 | } 30 | ret_val = (ret_val>=(ind_tail-ind_front)) ? ret_val : (ind_tail-ind_front); 31 | return ret_val; 32 | } 33 | 34 | /* 35 | 执行结果： 36 | 通过 37 | 显示详情 38 | 执行用时 :56 ms, 在所有 C 提交中击败了95.08% 的用户 39 | 内存消耗 :8.7 MB, 在所有 C 提交中击败了48.76%的用户 40 | */ -------------------------------------------------------------------------------- /算法/485_最大连续1的个数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/485_最大连续1的个数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/485_最大连续1的个数/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/485_最大连续1的个数/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/496_下一个更大元素1/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | 5 | public: 6 | vector nextGreaterElement(vector& nums1, vector& nums2) 7 | { 8 | 9 | vector ret_val ; 10 | int temp = 0 ; 11 | int i = 0 ; 12 | int j = 0 ; 13 | map mii ; /*字典也可以*/ 14 | 15 | for (i = 0; i < nums2.size(); i++) 16 | { 17 | mii[nums2[i]] = i; 18 | } 19 | 20 | for(i=0;i nums1[i]) 26 | { 27 | temp = nums2[j]; 28 | break; 29 | } 30 | } 31 | ret_val.push_back(temp); 32 | } 33 | return ret_val; 34 | } 35 | }; 36 | 37 | 38 | 39 | /* 40 | 执行结果： 41 | 通过 42 | 显示详情 43 | 执行用时 :16 ms, 在所有 C++ 提交中击败了81.93% 的用户 44 | 内存消耗 :9.3 MB, 在所有 C++ 提交中击败了53.31%的用户 45 | */ -------------------------------------------------------------------------------- /算法/496_下一个更大元素1/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/496_下一个更大元素1/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/500_键盘行/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/500_键盘行/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/5079_三个有序数组的交集/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector arraysIntersection( vector& arr1, 5 | vector& arr2, 6 | vector& arr3 7 | ) 8 | { 9 | 10 | vector ret_val ; 11 | int i = 0 ; 12 | map mii2; 13 | map mii3; 14 | 15 | for( i = 0 ; i < arr2.size();i++) 16 | { 17 | mii2[arr2[i]] = 1; 18 | } 19 | for( i = 0 ; i < arr3.size();i++) 20 | { 21 | mii3[arr3[i]] = 1; 22 | } 23 | 24 | for(i = 0 ; i < arr1.size(); i++) 25 | { 26 | if( ( mii2.count(arr1[i]) > 0 ) 27 | && ( mii3.count(arr1[i]) > 0 ) 28 | ) 29 | { 30 | ret_val.push_back(arr1[i]); 31 | } 32 | } 33 | return ret_val; 34 | } 35 | }; 36 | 37 | /* 38 | 执行结果： 39 | 通过 40 | 显示详情 41 | 执行用时 :28 ms, 在所有 C++ 提交中击败了100.00% 的用户 42 | 内存消耗 :11.8 MB, 在所有 C++ 提交中击败了100.00%的用户 43 | */ -------------------------------------------------------------------------------- /算法/5079_三个有序数组的交集/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/5079_三个有序数组的交集/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/513_找树左下角的值/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/513_找树左下角的值/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/526_优美的排列/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/526_优美的排列/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/535_TinyUrl的加密和解密/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | TinyURL是一种URL简化服务， 比如：当你输入一个URL https://leetcode.com/problems/design-tinyurl 时，它将返回一个简化的URL http://tinyurl.com/4e9iAk. 4 | 5 | 要求：设计一个 TinyURL 的加密 encode 和解密 decode 的方法。你的加密和解密算法如何设计和运作是没有限制的，你只需要保证一个URL可以被加密成一个TinyURL，并且这个TinyURL可以用解密方法恢复成原本的URL。 6 | 7 | 来源：力扣（LeetCode） 8 | 链接：https://leetcode-cn.com/problems/encode-and-decode-tinyurl 9 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处. 10 | */ 11 | ``` 12 | 13 | -------------------------------------------------------------------------------- /算法/537_复数乘法/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | string complexNumberMultiply(string a, string b) 5 | { 6 | int a1; 7 | int b1; 8 | int a2; 9 | int b2; 10 | sscanf(a.c_str(),"%d+%di",&a1,&b1); 11 | sscanf(b.c_str(),"%d+%di",&a2,&b2); 12 | return string( to_string(a1*a2-b1*b2) + "+" + to_string(a1*b2+a2*b1) + "i"); 13 | 14 | } 15 | }; 16 | 17 | 18 | /* 19 | 执行结果： 20 | 通过 21 | 显示详情 22 | 执行用时 :8 ms, 在所有 C++ 提交中击败了25.00% 的用户 23 | 内存消耗 :8.5 MB, 在所有 C++ 提交中击败了53.09%的用户 24 | */ -------------------------------------------------------------------------------- /算法/537_复数乘法/Solution02.c: -------------------------------------------------------------------------------- 1 | char * complexNumberMultiply(char * a, char * b) 2 | { 3 | char* ret_val = (char*)malloc(20*sizeof(char)) ; 4 | int a1 = 0 ; 5 | int b1 = 0 ; 6 | int a2 = 0 ; 7 | int b2 = 0 ; 8 | int a3 = 0 ; 9 | int b3 = 0 ; 10 | 11 | sscanf(a,"%d+%di",&a1,&b1); 12 | sscanf(b,"%d+%di",&a2,&b2); 13 | a3 = a1*a2-b1*b2; 14 | b3 = a1*b2+a2*b1; 15 | memset(ret_val,0,20*sizeof(char)); 16 | sprintf(ret_val,"%d+%di",a3,b3); 17 | return ret_val; 18 | } 19 | 20 | /* 21 | 执行结果： 22 | 通过 23 | 显示详情 24 | 执行用时 :8 ms, 在所有 C 提交中击败了5.77% 的用户 25 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了77.78%的用户 26 | */ -------------------------------------------------------------------------------- /算法/537_复数乘法/Solution03.c: -------------------------------------------------------------------------------- 1 | 2 | char ret_val[20]; 3 | char* complexNumberMultiply(char * a, char * b) 4 | { 5 | int a1 = 0; 6 | int b1 = 0; 7 | int a2 = 0; 8 | int b2 = 0; 9 | int a3 = 0; 10 | int b3 = 0; 11 | 12 | sscanf(a,"%d+%di",&a1,&b1); 13 | sscanf(b,"%d+%di",&a2,&b2); 14 | a3 = a1*a2-b1*b2; 15 | b3 = a1*b2+a2*b1; 16 | memset(ret_val,0,20*sizeof(char)); 17 | sprintf(ret_val,"%d+%di",a3,b3); 18 | return ret_val; 19 | } 20 | 21 | /* 22 | 执行结果： 23 | 通过 24 | 显示详情 25 | 执行用时 :0 ms, 在所有 C 提交中击败了100.00% 的用户 26 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了77.78%的用户 27 | */ 28 | -------------------------------------------------------------------------------- /算法/537_复数乘法/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/537_复数乘法/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/540_有序数组中的单一元素/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int singleNonDuplicate(vector& nums) 5 | { 6 | /* 7 | 时间复杂度 O(n) 8 | 空间复杂度 O(1) 9 | 10 | */ 11 | int ret_val = 0x00; 12 | int i = 0; 13 | for(i = 0 ; i < nums.size() ; i++) 14 | { 15 | ret_val ^= nums[i]; 16 | } 17 | return ret_val; 18 | } 19 | }; 20 | 21 | /* 22 | 执行结果： 23 | 通过 24 | 显示详情 25 | 执行用时 :12 ms, 在所有 cpp 提交中击败了76.04% 的用户 26 | 内存消耗 :9.5 MB, 在所有 cpp 提交中击败了9.73%的用户 27 | */ -------------------------------------------------------------------------------- /算法/540_有序数组中的单一元素/Solution02.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int singleNonDuplicate(vector& nums) 5 | { 6 | /* 7 | 时间复杂度 O(n) 8 | 空间复杂度 O(1) 9 | */ 10 | int ret_val = 0x00 ; 11 | int i = 0 ; 12 | int left = 0 ; 13 | 14 | for(i=0;i& nums) 5 | { 6 | int i = 0; 7 | int size = nums.size(); 8 | int temp = 0; 9 | sort(nums.begin(), nums.end()); 10 | for(i=0;i& nums) 34 | { 35 | int i = 0; 36 | int size = nums.size(); 37 | int temp = 0; 38 | sort(nums.begin(), nums.end()); 39 | for(i=0;i 60 | AlimyBreak 61 | 62 |
63 | 2019.09.10 64 |
-------------------------------------------------------------------------------- /算法/561_数组拆分 I/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/561_数组拆分 I/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/566_重塑矩阵/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector> matrixReshape(vector>& nums, int r, int c) 5 | { 6 | int rr = nums.size() ; 7 | int cc = nums[0].size() ; 8 | int i = 0 ; 9 | vector> vvi ; 10 | 11 | 12 | if(rr*cc - r*c) 13 | { 14 | return nums; 15 | } 16 | else 17 | { 18 | for( i = 0 ; i < r ;i++) 19 | { 20 | vector vi(c,0); 21 | vvi.push_back(vi); 22 | } 23 | 24 | for( i = 0 ; i < rr*cc ; i++) 25 | { 26 | vvi[i/c][i%c] = nums[i/cc][i%cc]; 27 | } 28 | return vvi; 29 | } 30 | } 31 | }; 32 | 33 | /* 34 | 执行结果： 35 | 通过 36 | 显示详情 37 | 执行用时 :36 ms, 在所有 cpp 提交中击败了97.96% 的用户 38 | 内存消耗 :12.6 MB, 在所有 cpp 提交中击败了14.29%的用户 39 | */ -------------------------------------------------------------------------------- /算法/566_重塑矩阵/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/566_重塑矩阵/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/589_N叉树的前序遍历/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | // Definition for a Node. 3 | class Node { 4 | public: 5 | int val; 6 | vector children; 7 | 8 | Node() {} 9 | 10 | Node(int _val, vector _children) { 11 | val = _val; 12 | children = _children; 13 | } 14 | }; 15 | */ 16 | class Solution 17 | { 18 | private: 19 | vector ret_val; 20 | 21 | 22 | void __PreOrder(Node* node) 23 | { 24 | int size = 0; 25 | int i = 0; 26 | if(node==NULL) 27 | { 28 | return; 29 | } 30 | else 31 | { 32 | ret_val.push_back(node->val); 33 | size = node->children.size(); 34 | for(i=0;ichildren[i]); 37 | } 38 | } 39 | } 40 | public: 41 | vector preorder(Node* root) 42 | { 43 | ret_val.clear(); 44 | __PreOrder(root); 45 | return ret_val; 46 | } 47 | }; 48 | 49 | 50 | /* 51 | 执行结果： 52 | 通过 53 | 显示详情 54 | 执行用时 :368 ms, 在所有 C++ 提交中击败了18.87% 的用户 55 | 内存消耗 :32.7 MB, 在所有 C++ 提交中击败了84.08%的用户 56 | */ -------------------------------------------------------------------------------- /算法/589_N叉树的前序遍历/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/589_N叉树的前序遍历/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/590_N叉树的后序遍历/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | // Definition for a Node. 3 | class Node { 4 | public: 5 | int val; 6 | vector children; 7 | 8 | Node() {} 9 | 10 | Node(int _val, vector _children) { 11 | val = _val; 12 | children = _children; 13 | } 14 | }; 15 | */ 16 | class Solution 17 | { 18 | private: 19 | vector ret_val; 20 | 21 | void __PostOrder(Node* node) 22 | { 23 | int size = 0; 24 | int i = 0; 25 | if(node==NULL) 26 | { 27 | return; 28 | } 29 | else 30 | { 31 | size = node->children.size(); 32 | for(i=0;ichildren[i]); 35 | } 36 | ret_val.push_back(node->val); 37 | } 38 | } 39 | 40 | public: 41 | vector postorder(Node* root) 42 | { 43 | ret_val.clear(); 44 | __PostOrder(root); 45 | return ret_val; 46 | } 47 | }; 48 | 49 | 50 | /* 51 | 执行结果： 52 | 通过 53 | 显示详情 54 | 执行用时 :216 ms, 在所有 C++ 提交中击败了84.34% 的用户 55 | 内存消耗 :32.7 MB, 在所有 C++ 提交中击败了78.75%的用户 56 | */ -------------------------------------------------------------------------------- /算法/590_N叉树的后序遍历/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/590_N叉树的后序遍历/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/617_合并二叉树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/617_合并二叉树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/637_二叉树的层平均值/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/637_二叉树的层平均值/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/647_回文子串/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/647_回文子串/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/654_最大二叉树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/654_最大二叉树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/657_机器人能否返回原点/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | bool judgeCircle(char * moves) 3 | { 4 | int i = 0; 5 | int count_lr = 0; 6 | int count_ud = 0; 7 | while (moves[i]) 8 | { 9 | switch (moves[i]) 10 | { 11 | case 'R': 12 | count_lr++; 13 | break; 14 | 15 | case 'L': 16 | count_lr--; 17 | break; 18 | 19 | case 'U': 20 | count_ud++; 21 | break; 22 | 23 | case 'D': 24 | count_ud--; 25 | break; 26 | default: 27 | break; 28 | } 29 | i++; 30 | } 31 | return ((count_lr==0)&&(count_ud == 0)); 32 | } 33 | 34 | /* 35 | 执行结果： 36 | 通过 37 | 显示详情 38 | 执行用时 :8 ms, 在所有 C 提交中击败了90.37% 的用户 39 | 内存消耗 :7.2 MB, 在所有 C 提交中击败了74.34%的用户 40 | */ 41 | 42 | -------------------------------------------------------------------------------- /算法/657_机器人能否返回原点/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/657_机器人能否返回原点/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/661_图片平滑器/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/661_图片平滑器/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/661_图片平滑器/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/661_图片平滑器/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/665_非递减数列/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/665_非递减数列/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/690_员工的重要性/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/690_员工的重要性/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/693_交替位二进制数/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | bool hasAlternatingBits(int n) 4 | { 5 | unsigned int temp = (n^(n>>1)); 6 | if(temp !=2147483647 ) 7 | { 8 | return (temp&(temp+1))==0; 9 | } 10 | else 11 | { 12 | // 对应特殊值(n==1431655765) 13 | return true; 14 | } 15 | } 16 | 17 | /* 18 | 执行结果： 19 | 通过 20 | 显示详情 21 | 执行用时 :4 ms, 在所有 C 提交中击败了69.14% 的用户 22 | 内存消耗 :6.7 MB, 在所有 C 提交中击败了81.13%的用户 23 | */ -------------------------------------------------------------------------------- /算法/693_交替位二进制数/Solution02.c: -------------------------------------------------------------------------------- 1 | 2 | bool hasAlternatingBits(int n) 3 | { 4 | switch(n) 5 | { 6 | case 0x00000001: 7 | case 0x00000005: 8 | case 0x00000015: 9 | case 0x00000055: 10 | case 0x00000155: 11 | case 0x00000555: 12 | case 0x00001555: 13 | case 0x00005555: 14 | case 0x00015555: 15 | case 0x00055555: 16 | case 0x00155555: 17 | case 0x00555555: 18 | case 0x01555555: 19 | case 0x05555555: 20 | case 0x15555555: 21 | case 0x55555555: 22 | case 0x00000002: 23 | case 0x0000000a: 24 | case 0x0000002a: 25 | case 0x000000aa: 26 | case 0x000002aa: 27 | case 0x00000aaa: 28 | case 0x00002aaa: 29 | case 0x0000aaaa: 30 | case 0x0002aaaa: 31 | case 0x000aaaaa: 32 | case 0x002aaaaa: 33 | case 0x00aaaaaa: 34 | case 0x02aaaaaa: 35 | case 0x0aaaaaaa: 36 | case 0x2aaaaaaa: 37 | case 0xaaaaaaaa: 38 | return true; 39 | break; 40 | default: 41 | return false; 42 | } 43 | } 44 | 45 | /* 46 | 执行结果： 47 | 通过 48 | 显示详情 49 | 执行用时 :4 ms, 在所有 C 提交中击败了69.14% 的用户 50 | 内存消耗 :6.6 MB, 在所有 C 提交中击败了92.45%的用户 51 | */ 52 | -------------------------------------------------------------------------------- /算法/693_交替位二进制数/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/693_交替位二进制数/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/700_二叉搜索树中的搜索/Solution01.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * struct TreeNode *left; 6 | * struct TreeNode *right; 7 | * }; 8 | */ 9 | 10 | 11 | 12 | struct TreeNode* ret_val = NULL; 13 | 14 | 15 | void __searchBSTNode(struct TreeNode* node, int val) 16 | { 17 | if(node==NULL) 18 | { 19 | return; 20 | } 21 | 22 | if (node->val == val) 23 | { 24 | ret_val = node; 25 | return; 26 | } 27 | else if (node->val < val) 28 | { 29 | __searchBSTNode(node->right,val); 30 | } 31 | else 32 | { 33 | __searchBSTNode(node->left,val); 34 | } 35 | 36 | 37 | } 38 | 39 | struct TreeNode* searchBST(struct TreeNode* root, int val) 40 | { 41 | ret_val = NULL; 42 | __searchBSTNode(root,val); 43 | return ret_val; 44 | } 45 | 46 | /* 47 | 执行结果： 48 | 通过 49 | 显示详情 50 | 执行用时 :64 ms, 在所有 C 提交中击败了9.70% 的用户 51 | 内存消耗 :16.4 MB, 在所有 C 提交中击败了100.00%的用户 52 | */ -------------------------------------------------------------------------------- /算法/700_二叉搜索树中的搜索/Solution02.c: -------------------------------------------------------------------------------- 1 | struct TreeNode* searchBST(struct TreeNode* root, int val) 2 | { 3 | 4 | struct TreeNode* temp = root; 5 | while (1) 6 | { 7 | if(temp==NULL) 8 | { 9 | break; 10 | } 11 | 12 | if(temp->val< val) 13 | { 14 | temp = temp -> right; 15 | } 16 | else if(temp->val > val) 17 | { 18 | temp = temp -> left; 19 | } 20 | else 21 | { 22 | return temp; 23 | } 24 | } 25 | return NULL; 26 | } 27 | 28 | /* 29 | 执行结果： 30 | 通过 31 | 显示详情 32 | 执行用时 :56 ms, 在所有 C 提交中击败了14.93% 的用户 33 | 内存消耗 :16.4 MB, 在所有 C 提交中击败了100.00%的用户 34 | */ 35 | 36 | 37 | 38 | struct TreeNode* searchBST(struct TreeNode* root, int val) 39 | { 40 | while (1) 41 | { 42 | if(root==NULL) 43 | { 44 | break; 45 | } 46 | if(root->val< val) 47 | { 48 | root = root -> right; 49 | } 50 | else if(root->val > val) 51 | { 52 | root = root -> left; 53 | } 54 | else 55 | { 56 | return root; 57 | } 58 | } 59 | return NULL; 60 | } 61 | 62 | /* 63 | 执行结果： 64 | 通过 65 | 显示详情 66 | 执行用时 :36 ms, 在所有 C 提交中击败了68.66% 的用户 67 | 内存消耗 :16.6 MB, 在所有 C 提交中击败了100.00%的用户 68 | */ -------------------------------------------------------------------------------- /算法/700_二叉搜索树中的搜索/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/700_二叉搜索树中的搜索/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/701_二叉搜索树中的插入操作/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution 11 | { 12 | private: 13 | TreeNode* __insertNode(TreeNode* node , int val) 14 | { 15 | if(node==NULL) 16 | { 17 | return new TreeNode(val); 18 | } 19 | if(node->val > val) 20 | { 21 | node->left = __insertNode(node->left,val); 22 | } 23 | else 24 | { 25 | node->right = __insertNode(node->right,val); 26 | } 27 | return node; 28 | } 29 | public: 30 | TreeNode* insertIntoBST(TreeNode* root, int val) 31 | { 32 | return __insertNode(root,val); 33 | } 34 | }; 35 | 36 | 37 | /* 38 | 执行结果： 39 | 通过 40 | 显示详情 41 | 执行用时 :164 ms, 在所有 C++ 提交中击败了40.41% 的用户 42 | 内存消耗 :32.8 MB, 在所有 C++ 提交中击败了74.65%的用户 43 | */ 44 | 45 | 46 | -------------------------------------------------------------------------------- /算法/701_二叉搜索树中的插入操作/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/701_二叉搜索树中的插入操作/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/709_转换成小写字母/C_Solution_02.c: -------------------------------------------------------------------------------- 1 | char* toLowerCase(char* str) { 2 | int i = 0; 3 | while(str[i]) 4 | { 5 | if( (str[i] >='A') 6 | &&(str[i] <='Z') 7 | ) 8 | { 9 | str[i] ^= ('a'-'A'); 10 | } 11 | i++; 12 | } 13 | return str; 14 | } -------------------------------------------------------------------------------- /算法/709_转换成小写字母/C_Solution_03.c: -------------------------------------------------------------------------------- 1 | char* toLowerCase(char* str) { 2 | int i = 0; 3 | while(str[i]) 4 | { 5 | if( (str[i] >='A') 6 | &&(str[i] <='Z') 7 | ) 8 | { 9 | str[i] |= ('a'-'A'); 10 | } 11 | i++; 12 | } 13 | return str; 14 | } -------------------------------------------------------------------------------- /算法/747_至少是其他数字两倍的最大数/Readme.txt: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/747_至少是其他数字两倍的最大数/Readme.txt -------------------------------------------------------------------------------- /算法/771_宝石与石头/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | int countChar(char*S , char ch) 3 | { 4 | int ret_val = 0; 5 | int i = 0; 6 | while(S[i]) 7 | { 8 | if(S[i]==ch) 9 | { 10 | ret_val++; 11 | } 12 | i++; 13 | } 14 | 15 | return ret_val; 16 | } 17 | 18 | 19 | int numJewelsInStones( char* J , 20 | char* S 21 | ) 22 | { 23 | int ret_val = 0; 24 | int i = 0; 25 | while (J[i]) 26 | { 27 | ret_val += countChar(S,J[i]); 28 | i++; 29 | } 30 | return ret_val; 31 | } 32 | 33 | 34 | /* 35 | 执行结果： 36 | 通过 37 | 显示详情 38 | 执行用时 :8 ms, 在所有 C 提交中击败了21.55% 的用户 39 | 内存消耗 :6.6 MB, 在所有 C 提交中击败了91.34%的用户 40 | */ -------------------------------------------------------------------------------- /算法/771_宝石与石头/Solution02.c: -------------------------------------------------------------------------------- 1 | int numJewelsInStones(char* J, char * S) 2 | { 3 | short int count_ch[128] = {0,}; 4 | int i = 0; 5 | int ret_val = 0; 6 | //memset(count_ch,0,sizeof(count_ch)); 7 | while (S[i]) 8 | { 9 | count_ch[S[i]] ++; 10 | i++; 11 | } 12 | i = 0; 13 | while (J[i]) 14 | { 15 | ret_val += count_ch[J[i]]; 16 | i++; 17 | } 18 | return ret_val; 19 | } 20 | 21 | /* 22 | 执行结果： 23 | 通过 24 | 显示详情 25 | 执行用时 :4 ms, 在所有 C 提交中击败了71.55% 的用户 26 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了80.74%的用户 27 | */ -------------------------------------------------------------------------------- /算法/771_宝石与石头/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/771_宝石与石头/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/784_字母的大小写全排列/Solution03.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | 4 | private: 5 | void helper( vector& vs , 6 | string& cur_s , 7 | int left , 8 | int change_times 9 | ) 10 | { 11 | vs.push_back(cur_s); 12 | for(int i = left ; i < cur_s.size() ; i++) 13 | { 14 | /*有字母*/ 15 | if( (cur_s[i]<='z' && cur_s[i] >= 'a') 16 | ||(cur_s[i]<='Z' && cur_s[i] >= 'A') 17 | ) 18 | { 19 | cur_s[i] ^= (int)('z' - 'Z'); 20 | helper(vs,cur_s,i+1,change_times+1); 21 | } 22 | } 23 | } 24 | 25 | public: 26 | vector letterCasePermutation(string S) 27 | { 28 | vector vs; 29 | 30 | helper(vs,S,0,0); 31 | return vs; 32 | } 33 | }; 34 | 35 | /* 36 | 执行结果： 37 | 通过 38 | 显示详情 39 | 执行用时 :8 ms, 在所有 cpp 提交中击败了97.20% 的用户 40 | 内存消耗 :11.7 MB, 在所有 cpp 提交中击败了97.98%的用户 41 | */ -------------------------------------------------------------------------------- /算法/784_字母的大小写全排列/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/784_字母的大小写全排列/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/784_字母的大小写全排列/手稿_V1.2.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/784_字母的大小写全排列/手稿_V1.2.pdf -------------------------------------------------------------------------------- /算法/788_旋转数字/Solution02.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | bool __isGoodNum(int n) 4 | { 5 | int num_2 = 0; /*2 5 6 9 个数*/ 6 | while(n) 7 | { 8 | switch(n%10) 9 | { 10 | case 2: 11 | case 5: 12 | case 6: 13 | case 9: 14 | num_2++; 15 | break; 16 | 17 | case 0: 18 | case 1: 19 | case 8: 20 | break; 21 | 22 | default: 23 | return false; 24 | } 25 | n /= 10; 26 | } 27 | 28 | return (num_2>0); 29 | } 30 | 31 | 32 | int rotatedDigits(int N) 33 | { 34 | int ret_val = 0; 35 | for(int i = 2; i <= N ; i ++) 36 | { 37 | if(__isGoodNum(i)) 38 | { 39 | ret_val ++; 40 | } 41 | } 42 | return ret_val; 43 | } 44 | 45 | 46 | 47 | 48 | /* 49 | 执行结果： 50 | 通过 51 | 显示详情 52 | 执行用时 :4 ms, 在所有 C 提交中击败了86.00% 的用户 53 | 内存消耗 :6.8 MB, 在所有 C 提交中击败了45.71%的用户 54 | */ -------------------------------------------------------------------------------- /算法/788_旋转数字/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/788_旋转数字/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/797_所有可能的路径/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/797_所有可能的路径/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/804_唯一摩尔斯密码词/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/804_唯一摩尔斯密码词/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/807_保持城市天际线/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/807_保持城市天际线/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/814_二叉树剪枝/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution 11 | { 12 | private: 13 | TreeNode* __dfs(TreeNode* node) 14 | { 15 | if(node==NULL) 16 | { 17 | return NULL; 18 | } 19 | node->left = __dfs(node->left); 20 | node->right = __dfs(node->right); 21 | if( ( node->left == NULL ) 22 | &&( node->right == NULL ) 23 | &&( node->val == 0 ) 24 | ) 25 | { 26 | return NULL; 27 | } 28 | return node; 29 | } 30 | 31 | public: 32 | TreeNode* pruneTree(TreeNode* root) 33 | { 34 | root = __dfs(root); 35 | return root; 36 | } 37 | }; 38 | 39 | 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :4 ms, 在所有 C++ 提交中击败了88.46% 的用户 45 | 内存消耗 :9.7 MB, 在所有 C++ 提交中击败了82.14%的用户 46 | */ -------------------------------------------------------------------------------- /算法/814_二叉树剪枝/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/814_二叉树剪枝/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/821_字符的最短距离/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/821_字符的最短距离/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/821_字符的最短距离/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/821_字符的最短距离/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/832_翻转图像/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | vector> flipAndInvertImage(vector>& A) 5 | { 6 | vector> ret_val ; 7 | vector temp ; 8 | int i = 0 ; 9 | int j = 0 ; 10 | for(i=0;iA[mid-1]) 13 | && (A[mid+1]>A[mid]) 14 | ) 15 | { 16 | left = mid + 1; 17 | } 18 | else if( (A[mid]> transpose(vector>& A) 5 | { 6 | vector> ret_val ; 7 | vector temp ; 8 | int i = 0 ; 9 | int j = 0 ; 10 | int rows = A.size() ; 11 | int cols = 0 ; 12 | if(rows>0) 13 | { 14 | cols = A[0].size(); 15 | for(i = 0; i < cols;i++) 16 | { 17 | temp.clear(); 18 | for(j = 0; j < rows ; j++) 19 | { 20 | temp.push_back(A[j][i]); 21 | } 22 | ret_val.push_back(temp); 23 | } 24 | } 25 | return ret_val; 26 | } 27 | }; 28 | 29 | /* 30 | 执行结果： 31 | 通过 32 | 显示详情 33 | 执行用时 :36 ms, 在所有 C++ 提交中击败了75.50% 的用户 34 | 内存消耗 :11.5 MB, 在所有 C++ 提交中击败了76.63%的用户 35 | */ -------------------------------------------------------------------------------- /算法/867_转置矩阵/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/867_转置矩阵/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/868_二进制间距/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/868_二进制间距/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/872_叶子相似的树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/872_叶子相似的树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/876_链表的中间结点/Solution01.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution 10 | { 11 | public: 12 | ListNode* middleNode(ListNode* head) 13 | { 14 | ListNode* temp = head; 15 | int count = 0; 16 | 17 | while(temp) 18 | { 19 | count++; 20 | temp = temp->next; 21 | } 22 | 23 | temp = head; 24 | count = count / 2; 25 | while(count--) 26 | { 27 | temp = temp -> next; 28 | } 29 | return temp ; 30 | } 31 | }; 32 | 33 | /* 34 | 执行结果： 35 | 通过 36 | 显示详情 37 | 执行用时 :4 ms, 在所有 cpp 提交中击败了72.23%的用户 38 | 内存消耗 :8.5 MB, 在所有 cpp 提交中击败了34.56%的用户 39 | */ -------------------------------------------------------------------------------- /算法/876_链表的中间结点/Solution02.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution 10 | { 11 | public: 12 | ListNode* middleNode(ListNode* head) 13 | { 14 | ListNode temp(0); 15 | temp.next = head; 16 | ListNode* slower = &temp; 17 | ListNode* faster = &temp; 18 | 19 | 20 | while(faster->next && faster->next->next) 21 | { 22 | slower = slower->next; 23 | faster = faster->next->next; 24 | } 25 | 26 | 27 | return slower->next; 28 | 29 | } 30 | }; 31 | 32 | /* 33 | 执行结果： 34 | 通过 35 | 显示详情 36 | 执行用时 :4 ms, 在所有 cpp 提交中击败了72.23%的用户 37 | 内存消耗 :8.5 MB, 在所有 cpp 提交中击败了24.13%的用户 38 | */ -------------------------------------------------------------------------------- /算法/876_链表的中间结点/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/876_链表的中间结点/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/897_递增顺序查找树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/897_递增顺序查找树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/921_使括号有效的最少添加/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int minAddToMakeValid(string S) 5 | { 6 | int left = 0; 7 | int right = 0; 8 | 9 | for(int i = 0 ; i < S.size() ; i++) 10 | { 11 | if(S[i] == '(') 12 | { 13 | left++; 14 | } 15 | else 16 | { 17 | right++; 18 | if(left>0) 19 | { 20 | left--; 21 | right--; 22 | } 23 | } 24 | 25 | 26 | } 27 | 28 | return left+right; 29 | 30 | } 31 | }; 32 | 33 | /* 34 | 执行结果： 35 | 通过 36 | 显示详情 37 | 执行用时 :0 ms, 在所有 cpp 提交中击败了100.00% 的用户 38 | 内存消耗 :8.5 MB, 在所有 cpp 提交中击败了85.63%的用户 39 | */ -------------------------------------------------------------------------------- /算法/921_使括号有效的最少添加/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/921_使括号有效的最少添加/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/938_二叉搜索树的范围和/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | /** 3 | * Definition for a binary tree node. 4 | * struct TreeNode { 5 | * int val; 6 | * struct TreeNode *left; 7 | * struct TreeNode *right; 8 | * }; 9 | */ 10 | 11 | int ret_val = 0; 12 | 13 | 14 | void __preOrderTravel(struct TreeNode* node , int L , int R) 15 | { 16 | if(node==NULL) 17 | { 18 | return ; 19 | } 20 | if(node->val < L) 21 | { 22 | __preOrderTravel(node->right,L,R); 23 | } 24 | else if(node->val > R) 25 | { 26 | __preOrderTravel(node->left,L,R); 27 | } 28 | else 29 | { 30 | ret_val += node->val; 31 | __preOrderTravel(node->left,L,R); 32 | __preOrderTravel(node->right,L,R); 33 | } 34 | 35 | return ; 36 | } 37 | 38 | 39 | int rangeSumBST(struct TreeNode* root, int L, int R) 40 | { 41 | ret_val = 0; 42 | __preOrderTravel(root,L,R); 43 | return ret_val; 44 | 45 | } 46 | 47 | /* 48 | 执行结果： 49 | 通过 50 | 显示详情 51 | 执行用时 :128 ms, 在所有 C 提交中击败了54.15% 的用户 52 | 内存消耗 :43.8 MB, 在所有 C 提交中击败了100.00%的用户 53 | */ -------------------------------------------------------------------------------- /算法/938_二叉搜索树的范围和/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/938_二叉搜索树的范围和/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/942_增减字符串匹配/Solution01.c: -------------------------------------------------------------------------------- 1 | 2 | 3 | /** 4 | * Note: The returned array must be malloced, assume caller calls free(). 5 | */ 6 | int* diStringMatch(char * S, int* returnSize) 7 | { 8 | int str_len = strlen(S); 9 | int* ret_val = (int*)malloc((str_len+1)*sizeof(int)); 10 | int i = 0; 11 | int num_i = 0; 12 | int num_d = 0; 13 | 14 | ret_val[0] = 0; 15 | for (i = 0; i < str_len; i++) 16 | { 17 | switch (S[i]) 18 | { 19 | case 'I': 20 | ret_val[i+1] = ++num_i; 21 | break; 22 | case 'D': 23 | ret_val[i+1] = --num_d; 24 | break; 25 | default: 26 | break; 27 | } 28 | } 29 | str_len++; 30 | if(num_d<0) 31 | { 32 | num_d = -num_d; 33 | for (i = 0; i < str_len; i++) 34 | { 35 | ret_val[i] += num_d; 36 | } 37 | } 38 | 39 | *returnSize = str_len; 40 | return ret_val; 41 | } 42 | 43 | /* 44 | 执行结果： 45 | 通过 46 | 显示详情 47 | 执行用时 :104 ms, 在所有 C 提交中击败了9.57% 的用户 48 | 内存消耗 :12.8 MB, 在所有 C 提交中击败了89.01%的用户 49 | */ -------------------------------------------------------------------------------- /算法/942_增减字符串匹配/Solution02.c: -------------------------------------------------------------------------------- 1 | /** 2 | * Note: The returned array must be malloced, assume caller calls free(). 3 | */ 4 | int* diStringMatch(char * S, int* returnSize) 5 | { 6 | int str_len = strlen(S); 7 | int* ret_val = (int*)malloc((str_len+1)*sizeof(int)); 8 | int i = 0; 9 | int num_i = 0; 10 | int num_d = str_len; 11 | 12 | *returnSize = str_len+1; 13 | for(i = 0; i < str_len; i++) 14 | { 15 | //switch (S[i]) 16 | //{ 17 | // case 'I': 18 | // ret_val[i] = num_i++; 19 | // break; 20 | // case 'D': 21 | // ret_val[i] = num_d--; 22 | // break; 23 | // default: 24 | // break; 25 | //} 26 | if (S[i]=='I') 27 | { 28 | ret_val[i] = num_i++; 29 | } 30 | else 31 | { 32 | ret_val[i] = num_d--; 33 | } 34 | } 35 | ret_val[str_len] = num_i;/*此时num_i 和 num_d 应该相等*/ 36 | 37 | return ret_val; 38 | } 39 | 40 | /* 41 | 执行结果(switch)： 42 | 通过 43 | 显示详情 44 | 执行用时 :88 ms, 在所有 C 提交中击败了26.60% 的用户 45 | 内存消耗 :12.7 MB, 在所有 C 提交中击败了92.31%的用户 46 | */ 47 | 48 | 49 | /* 50 | 执行结果： 51 | 通过 52 | 显示详情 53 | 执行用时 :84 ms, 在所有 C 提交中击败了30.85% 的用户 54 | 内存消耗 :12.8 MB, 在所有 C 提交中击败了90.11%的用户 55 | */ -------------------------------------------------------------------------------- /算法/942_增减字符串匹配/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/942_增减字符串匹配/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/961_重复 N 次的元素/make.cmd: -------------------------------------------------------------------------------- 1 | gcc Solution01.c -o test.exe -lstdc++ 2 | test.exe 3 | pause -------------------------------------------------------------------------------- /算法/965_单值二叉树/Solution02.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution 11 | { 12 | private: 13 | bool dfs(TreeNode* node) 14 | { 15 | if(node==NULL) 16 | { 17 | return true; 18 | } 19 | 20 | if(node->val != val) 21 | { 22 | return false; 23 | } 24 | return dfs(node->left) && dfs(node->right); 25 | } 26 | int val = 0; 27 | 28 | public: 29 | bool isUnivalTree(TreeNode* root) 30 | { 31 | if(root==NULL) 32 | { 33 | return true; 34 | } 35 | val = root->val; 36 | return dfs(root); 37 | } 38 | }; 39 | 40 | /* 41 | 执行结果： 42 | 通过 43 | 显示详情 44 | 执行用时 :8 ms, 在所有 C++ 提交中击败了61.30% 的用户 45 | 内存消耗 :10.3 MB, 在所有 C++ 提交中击败了99.64%的用户 46 | */ -------------------------------------------------------------------------------- /算法/965_单值二叉树/Solution03.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for a binary tree node. 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution 11 | { 12 | public: 13 | bool isUnivalTree(TreeNode* root) 14 | { 15 | int val = 0; 16 | TreeNode* temp = NULL; 17 | queue qu; 18 | 19 | if(root==NULL) 20 | { 21 | return true; 22 | } 23 | val = root->val; 24 | qu.push(root); 25 | while(qu.empty()!=true) 26 | { 27 | temp = qu.front(); 28 | if(temp->val !=val) 29 | { 30 | return false; 31 | } 32 | if(temp->left) 33 | { 34 | qu.push(temp->left); 35 | } 36 | if(temp->right) 37 | { 38 | qu.push(temp->right); 39 | } 40 | qu.pop(); 41 | } 42 | return true; 43 | } 44 | }; 45 | 46 | /* 47 | 执行结果： 48 | 通过 49 | 显示详情 50 | 执行用时 :8 ms, 在所有 C++ 提交中击败了61.30% 的用户 51 | 内存消耗 :10.6 MB, 在所有 C++ 提交中击败了84.34%的用户 52 | */ 53 | 54 | -------------------------------------------------------------------------------- /算法/965_单值二叉树/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/965_单值二叉树/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/965_单值二叉树/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/965_单值二叉树/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/973_最接近原点的 K 个点/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/973_最接近原点的 K 个点/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/973_最接近原点的 K 个点/手稿_V1.1.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/973_最接近原点的 K 个点/手稿_V1.1.pdf -------------------------------------------------------------------------------- /算法/976_三角形的最大周长/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/976_三角形的最大周长/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/980_不同路径 III/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/980_不同路径 III/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/989_数组形式的整数加法/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/989_数组形式的整数加法/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/994_腐烂的橘子/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/994_腐烂的橘子/手稿_V1.0.pdf -------------------------------------------------------------------------------- /算法/LCP0001_猜数字/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | int game(vector& guess, vector& answer) 5 | { 6 | int ret_val = 0; 7 | 8 | for(int i = 0 ; i < 3 ; i++) 9 | { 10 | if(guess[i]==answer[i]) 11 | { 12 | ret_val++; 13 | } 14 | } 15 | return ret_val; 16 | } 17 | }; 18 | /* 19 | 执行结果： 20 | 通过 21 | 显示详情 22 | 执行用时 :4 ms, 在所有 C++ 提交中击败了64.30% 的用户 23 | 内存消耗 :8.2 MB, 在所有 C++ 提交中击败了100.00%的用户 24 | */ 25 | 26 | 27 | class Solution 28 | { 29 | public: 30 | int game(vector& guess, vector& answer) 31 | { 32 | int ret_val = 0; 33 | 34 | for(int i = 0 ; i < 3 ; i++) 35 | { 36 | if(!(guess[i]^answer[i])) 37 | { 38 | ret_val++; 39 | } 40 | } 41 | return ret_val; 42 | } 43 | }; 44 | 45 | /* 46 | 执行结果： 47 | 通过 48 | 显示详情 49 | 执行用时 :4 ms, 在所有 C++ 提交中击败了64.30% 的用户 50 | 内存消耗 :8.3 MB, 在所有 C++ 提交中击败了100.00%的用户 51 | */ -------------------------------------------------------------------------------- /算法/LCP0001_猜数字/手稿.md: -------------------------------------------------------------------------------- 1 | ```C 2 | /* 3 | 小A 和 小B 在玩猜数字。小B 每次从 1, 2, 3 中随机选择一个，小A 每次也从 1, 2, 3 中选择一个猜。他们一共进行三次这个游戏，请返回 小A 猜对了几次？ 4 | 输入的guess数组为 小A 每次的猜测，answer数组为 小B 每次的选择。guess和answer的长度都等于3。 5 | 示例 1： 6 | 输入：guess = [1,2,3], answer = [1,2,3] 7 | 输出：3 8 | 解释：小A 每次都猜对了。 9 | 10 | 示例 2： 11 | 输入：guess = [2,2,3], answer = [3,2,1] 12 | 输出：1 13 | 解释：小A 只猜对了第二次。 14 | 限制： 15 | guess的长度 = 3 16 | answer的长度 = 3 17 | guess的元素取值为 {1, 2, 3} 之一。 18 | answer的元素取值为 {1, 2, 3} 之一。 19 | 来源：力扣（LeetCode） 20 | 链接：https://leetcode-cn.com/problems/guess-numbers 21 | 著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。 22 | */ 23 | ``` 24 | 25 | 简单题目,手稿略. 26 | 27 | 28 | *** 29 |
30 | AlimyBreak 31 |
32 |
33 | 2019.10.11 34 |
-------------------------------------------------------------------------------- /算法/README.md: -------------------------------------------------------------------------------- 1 | # LeetCodeStudy - 算法 2 | + 在 https://leetcode-cn.com 上解题代码备份 3 | + 算法文件夹 4 | + 不得加入其它无关内容 5 | + 2019.05.05 6 | + 若有错误,请帮忙指出,若有帮助,可以帮忙给我点star么~ 7 | -------------------------------------------------------------------------------- /算法/面试题10.01_合并排序的数组/Solution01.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | void merge(vector& A, int m, vector& B, int n) 5 | { 6 | 7 | for( int i = 0;i < n; i++ ) 8 | { 9 | A[m+i] = B[i]; 10 | } 11 | 12 | sort(A.begin(),A.end()); 13 | } 14 | }; 15 | /* 16 | 执行结果： 17 | 通过 18 | 显示详情 19 | 执行用时 :8 ms, 在所有 C++ 提交中击败了28.76% 的用户 20 | 内存消耗 :11.5 MB, 在所有 C++ 提交中击败了100.00%的用户 21 | */ 22 | 23 | -------------------------------------------------------------------------------- /算法/面试题10.01_合并排序的数组/Solution03.cpp: -------------------------------------------------------------------------------- 1 | class Solution 2 | { 3 | public: 4 | void merge(vector& A, int m, vector& B, int n) 5 | { 6 | int i = m-1; 7 | int j = n-1; 8 | int k = m+n-1; 9 | 10 | 11 | 12 | /*从大到小归并*/ 13 | while(1) 14 | { 15 | if(i >= 0 && j >= 0 ) 16 | { 17 | if(A[i]= 0 ) 27 | { 28 | A[k--] = A[i--]; 29 | } 30 | else if(j >= 0 ) 31 | { 32 | A[k--] = B[j--]; 33 | } 34 | else 35 | { 36 | break; 37 | } 38 | 39 | } 40 | } 41 | }; 42 | 43 | 44 | /* 45 | 执行结果： 46 | 通过 47 | 显示详情 48 | 执行用时 :4 ms, 在所有 C++ 提交中击败了78.97% 的用户 49 | 内存消耗 :11.6 MB, 在所有 C++ 提交中击败了100.00%的用户 50 | */ -------------------------------------------------------------------------------- /算法/面试题10.01_合并排序的数组/手稿_V1.0.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/AlimyBreak/LeetCodeStudy/97518f669b5675484810743fa6754ab97334165e/算法/面试题10.01_合并排序的数组/手稿_V1.0.pdf --------------------------------------------------------------------------------