《剑指 Offer》
代码高质量
1.考虑清楚所有可能的输入
编码前设计单元测试
1.1 功能测试
1.2 边界测试
1.3 负面测试
使用错误测试用例，测试系统是否不执行它不应该完成的操作。
2. 面试思路
一个合格的应聘者应该在他做事之前明白自己要做的事情究竟是什么，以及该怎么做。一开始就编码的人员，除非后面表现非常优秀，否则很容易通不过。
喜欢应聘者在写代码之前先讲思路，举例子和画图都是很好的方法
第二章
剑指 Offer 04. 二维数组中的查找
在一个 n * m 的二维数组中，每一行都按照从左到右递增的顺序排序，每一列都按照从上到下递增的顺序排序。请完成一个高效的函数，输入这样的一个二维数组和一个整数，判断数组中是否含有该整数。
示例:
现有矩阵 matrix 如下：
[
[1, 4, 7, 11, 15],
[2, 5, 8, 12, 19],
[3, 6, 9, 16, 22],
[10, 13, 14, 17, 24],
[18, 21, 23, 26, 30]
]
给定 target = 5，返回 true。
给定 target = 20，返回 false。
限制：
0 <= n <= 1000
0 <= m <= 1000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-wei-shu-zu-zhong-de-cha-zhao-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
bool findtarget(int **matrix,int left,int right,int target,int matrixSize)
{
printf("%d\n",matrix[left][right]);
if (target == matrix[left][right])
{
printf("true : %d\n",matrix[left][right]);
return true;
}
else if (target < matrix[left][right])
{
if (right -1 >= 0)
{
return findtarget(matrix,left,right-1,target,matrixSize);
}
else
{
return false;
}
}
else
{
if (left + 1 < matrixSize)
{
return findtarget(matrix,left+1,right,target,matrixSize);
}
else
{
return false;
}
}
return false;
}
bool findNumberIn2DArray(int** matrix, int matrixSize, int* matrixColSize, int target){
if (matrix == NULL || matrixSize == 0 || *matrixColSize == 0)
{
return false;
}
int n = *matrixColSize;
return findtarget(matrix,0,n-1,target,matrixSize);
}
解法：
使用网友的“右上角度”的BST树，采用二分查找法。
剑指 Offer 06. 从尾到头打印链表
难度简单116收藏分享切换为英文接收动态反馈
输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。
示例 1：
输入：head = [1,3,2]
输出：[2,3,1]
限制：
0 <= 链表长度 <= 10000
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
typedef struct ListNode Node;
int* reversePrint(struct ListNode* head, int* returnSize){
Node *ptmp = head;
int *ret = NULL;
int size = 0;
*returnSize = 0;
while (ptmp)
{
ret = realloc(ret,sizeof(int)*(*returnSize+1));
ret[*returnSize] = ptmp->val;
(*returnSize) += 1;
ptmp = ptmp->next;
size = *returnSize;
}
//逆转数组
for (int i = 0; i < size/2;i++)
{
int tmp = ret[i];
ret[i] = ret[size-1-i];
ret[size-i-1] = tmp;
}
return ret;
}
剑指 Offer 07. 重建二叉树
难度中等374收藏分享切换为英文接收动态反馈
输入某二叉树的前序遍历和中序遍历的结果，请重建该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如，给出
前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回如下的二叉树：
3
/ \
9 20
/ \
15 7
限制：
0 <= 节点个数 <= 5000
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
typedef struct TreeNode Node;
Node *make_node()
{
Node *pNode = (Node *)malloc(sizeof(Node));
memset(pNode,0,sizeof(Node));
return pNode;
}
Node *buildPro(int **preorder,int *preorderSize,int *inorder,int inorderSize)
{
if (*preorderSize <= 0 || inorderSize <= 0)
{
return NULL;
}
Node *root = make_node();
root->val = (*preorder)[0];
//计算出经DLR的第一个元素划分后的左、右子数组的DLR和LDR,并调用递归
int *new_inorder_left = NULL;
int new_inorder_left_size = 0;
int *new_inorder_right = NULL;
int new_inorder_right_size = 0;
new_inorder_left = &inorder[0];
for (int i = 0;i < inorderSize;i++)
{
if (inorder[i] == (*preorder)[0])//求得两个子数组的未知边界
{
new_inorder_left_size = i;
new_inorder_right = inorder + i + 1;
new_inorder_right_size = inorderSize - i - 1;
break;
}
}
(*preorder) += 1;
(*preorderSize) -= 1;
if (new_inorder_left_size > 0)
{
root->left = buildPro(preorder,preorderSize,new_inorder_left,new_inorder_left_size);
}
if (new_inorder_right_size > 0)
{
root->right = buildPro(preorder,preorderSize,new_inorder_right,new_inorder_right_size);
}
return root;
}
struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize){
return buildPro(&preorder,&preorderSize,inorder,inorderSize);
}
痛点：
c语言，通过DLR的首元素，将LDR分成两段，进入二次递归，那么设计递归函数，一定要传递入新的LRD的首地址和元素个数。一开始我的buildPro的参数一preorder，我传递的是它的本身，一级指针，之后每经历一个节点就往前推1，即preorder+=1，但是后来发现怎么回到根节点的右分支后，怎么preorder就不对呢？后来发现，以为preorder+=1能保证递归过程中值发生变化，其实这里还是C语言的传值调用和传参调用没搞清楚，以为传的是指针就会改变，其实是将一级指针赋值给一级指针，形参的一级指针还是当前函数栈的临时变量，+1这个动作发生在本递归过程中的临时变量中，退栈后但是没起到修改上层函数的变量值的目的，所以，为了改变int变量的值，要传int变量的指针，要改变一级指针的值，就要传递一级指针的指针，即二级指针。
剑指 Offer 09. 用两个栈实现队列
用两个栈实现一个队列。队列的声明如下，请实现它的两个函数 appendTail 和 deleteHead ，分别完成在队列尾部插入整数和在队列头部删除整数的功能。(若队列中没有元素，deleteHead 操作返回 -1 )
示例 1：
输入：
["CQueue","appendTail","deleteHead","deleteHead"]
[[],[3],[],[]]
输出：[null,null,3,-1]
示例 2：
输入：
["CQueue","deleteHead","appendTail","appendTail","deleteHead","deleteHead"]
[[],[],[5],[2],[],[]]
输出：[null,-1,null,null,5,2]
提示：
1 <= values <= 10000最多会对 appendTail、deleteHead 进行 10000 次调用
typedef struct st_stack{
int arrary[10000];
int top;
int tail;
int size;
}stack;
stack *create_stack()
{
stack *pstack = (stack *)malloc(sizeof(stack));
memset(pstack,0,sizeof(stack));
return pstack;
}
bool empty_stack(stack *pstack)
{
if (pstack->size > 0)
{
return false;
}
return true;
}
bool full_stack(stack *pstack)
{
if (pstack->size < 10000)
{
return false;
}
return true;
}
void push_stack(stack *pstack,int val)
{
if (full_stack(pstack) == true)
{
return;
}
pstack->arrary[pstack->top] = val;
pstack->top++;
pstack->size++;
}
int pop_stack(stack *pstack)
{
if (true == empty_stack(pstack))
{
return -1;
}
int tmp = pstack->arrary[pstack->top-1];
pstack->top--;
pstack->size--;
return tmp;
}
typedef struct {
stack *dataA;
stack *dataB;
} CQueue;
CQueue* cQueueCreate() {
CQueue *pQueue = (CQueue *)malloc(sizeof(CQueue));
memset(pQueue,0,sizeof(CQueue));
pQueue->dataA = create_stack();
pQueue->dataB = create_stack();
return pQueue;
}
//元素入队
void cQueueAppendTail(CQueue* obj, int value)
{
if (full_stack(obj->dataA) == false)
{
push_stack(obj->dataA,value);
}
}
int cQueueDeleteHead(CQueue* obj) {
while (false == empty_stack(obj->dataA))
{
int tmp1 = pop_stack(obj->dataA);
if (false == full_stack(obj->dataB))
{
push_stack(obj->dataB,tmp1);
}
}
int tmp = pop_stack(obj->dataB);
while (false == empty_stack(obj->dataB))
{
int tmp2 = pop_stack(obj->dataB);
if (false == full_stack(obj->dataA))
{
push_stack(obj->dataA,tmp2);
}
}
return tmp;
}
void cQueueFree(CQueue* obj) {
if (obj)
{
if (obj->dataA)
{
free(obj->dataA);
}
if (obj->dataB)
{
free(obj->dataB);
}
free(obj);
}
}
/**
* Your CQueue struct will be instantiated and called as such:
* CQueue* obj = cQueueCreate();
* cQueueAppendTail(obj, value);
* int param_2 = cQueueDeleteHead(obj);
* cQueueFree(obj);
*/
剑指 Offer 11. 旋转数组的最小数字
难度简单266
把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。输入一个递增排序的数组的一个旋转，输出旋转数组的最小元素。例如，数组 [3,4,5,1,2] 为 [1,2,3,4,5] 的一个旋转，该数组的最小值为1。
示例 1：
输入：[3,4,5,1,2]
输出：1
示例 2：
输入：[2,2,2,0,1]
输出：0
注意：本题与主站 154 题相同：https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array-ii/
int getmin(int *numbers,int left,int right)
{
int ret = numbers[left];
for (int i = left+1;i <= right;i++)
{
ret = ret<numbers[i]?ret:numbers[i];
}
return ret;
}
int minArray(int* numbers, int numbersSize)
{
if (numbers == NULL || numbersSize <= 0)
{
return -1;
}
int left = 0;
int right = numbersSize - 1;
int mid = left;
while (numbers[left] >=numbers[right])
{
if (right - left == 1)
{
mid = right;
break;
}
mid = (left + right)/2;
if (numbers[left] == numbers[mid] && numbers[mid] == numbers[right])
{
return getmin(numbers,left,right);
}
if (numbers[mid] <= numbers[right])
{
right = mid;
}
else if (numbers[left] <= numbers[mid])
{
left = mid;
}
}
return numbers[mid];
}
剑指 Offer 10- I. 斐波那契数列
难度简单116
写一个函数，输入 n ，求斐波那契（Fibonacci）数列的第 n 项（即 F(N)）。斐波那契数列的定义如下：
F(0) = 0, F(1) = 1
F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
斐波那契数列由 0 和 1 开始，之后的斐波那契数就是由之前的两数相加而得出。
答案需要取模 1e9+7（1000000007），如计算初始结果为：1000000008，请返回 1。
示例 1：
输入：n = 2
输出：1
示例 2：
输入：n = 5
输出：5
提示：
0 <= n <= 100
int fib(int n){
int f[101] = {0};
f[0] = 0;
f[1] = 1;
for (int i = 2;i<=n;i++)
{
f[i] = (f[i-1]+f[i-2])%1000000007;
}
return f[n];
}
//使用常数空间
int fib(int n){
int a = n==0?0:1;
int b = n==0?0:1;
int c = 0;
for (int i = 2;i<=n;i++)
{
a = (b+c)%1000000007;
c = b;
b = a;
}
return a;
}
171. Excel表列序号
难度简单209
给定一个Excel表格中的列名称，返回其相应的列序号。
例如，
A -> 1
B -> 2
C -> 3
...
Z -> 26
AA -> 27
AB -> 28
...
示例 1:
输入: "A"
输出: 1
示例 2:
输入: "AB"
输出: 28
示例 3:
输入: "ZY"
输出: 701
致谢：
特别感谢 @ts 添加此问题并创建所有测试用例。
类似字符串转整数，理解这种从头到尾遍历情况下的进位是如何实现的
int titleToNumber(char * columnTitle){
int len = strlen(columnTitle);
int num = 0;
for (int i = 0;i < len;i++)
{
num = num*26+(columnTitle[i]-'A'+1);
}
return num;
}
剑指 Offer 15. 二进制中1的个数
int hammingWeight(uint32_t n) {
int ret = 0;
while (n>0)
{
ret += (n&1);
n>>=1;
}
return ret;
}
当给定的n为有符号整数时，当n为负数时，n右移会造成高位的符号位变数据位，而高位的符号位依旧为1.
所以此时上面的计数方法就失效了，换个思路，使用无符号的mask，初始为1，去和n的每个bit位上的值作比较，就能得到结果。
int bit1_count(int n)
{
int num = 0;
unsigned int mask = 1;
while (mask)
{
if (n & mask)
num++;
mask<<=1;
}
return num;
}
由n的减法特性，可推得n&(n-1)能使得n的最右边的1变为0。其余的不变。也可以达到计数的效果。
int bit1_count(int n)
{
int num = 0;
while (n)
{
num++;
n = n&(n-1);
}
return num;
}
第三章
剑指 Offer 16. 数值的整数次方
难度中等137
实现 pow(x, n) ，即计算 x 的 n 次幂函数（即，xn）。不得使用库函数，同时不需要考虑大数问题。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
提示：
-100.0 < x < 100.0-231 <= n <= 231-1-104 <= xn <= 104
快速幂（指数降幂）
采用指数降幂的方法————也就是快速幂法。
公式为：
x^n = （x2)n/2,(n为偶数)
x^n = x*(x^(n-1)),(n为奇数)
此外，还需考虑0次幂和负数次幂的情况。
作者：xiao-zhu-s8
链接：https://leetcode-cn.com/problems/shu-zhi-de-zheng-shu-ci-fang-lcof/solution/jian-zhi-16zheng-shu-ci-mi-kuai-su-mi-fa-8oxn/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
double myPow(double x, int n){
double res = 1.0;
if (x == 0)
{
if (n == 0)
{
return 1;
}
return 0;
}
if (n < 0)
{
x = 1/x;
}
while (n != 0)
{
if (n%2 != 0)//n为奇数
{
res *= x;//这里是为了将奇数拆解成偶数，再使用偶数的定理x^n = x^2^n/2
}
x *= x;//x^n = （x^2)^n/2 ,所以求得x^2后，假设下x^2=y,那么还要再求y^n/2,即，进入下一次循环
n/=2;//n减半，这里对于负数，如果使用n>>1是得不到减半的效果的，因为最终符号位会被移动到数据位
//牢记，负数由于其二进制的表示方法和正数不一致，所以不能随便用位运算
//正整数用左右移是为了效率
}
return res;
}
剑指 Offer 18. 删除链表的节点
难度简单110
给定单向链表的头指针和一个要删除的节点的值，定义一个函数删除该节点。
返回删除后的链表的头节点。
**注意：**此题对比原题有改动
示例 1:
输入: head = [4,5,1,9], val = 5
输出: [4,1,9]
解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], val = 1
输出: [4,5,9]
解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明：
- 题目保证链表中节点的值互不相同
- 若使用 C 或 C++ 语言，你不需要
free或delete被删除的节点
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* deleteNode(struct ListNode* head, int val){
if (head == NULL)
{
return NULL;
}
struct ListNode* ptmp1 = NULL;
struct ListNode* ptmp2 = NULL;
struct ListNode* plist = NULL;
//至少两个节点
ptmp2 = head;
while (ptmp2)
{
if (ptmp2->val == val)
{
if (ptmp1 == NULL)//头结点
{
return ptmp2->next;
}
else
{
ptmp1->next = ptmp2->next;
return plist;
}
}
else
{
ptmp1 = ptmp2;
ptmp2 = ptmp2->next;
if (!plist)
{
plist = ptmp1;
}
}
}
return plist;
}
//1.空
//长度为1
//尾节点
剑指 Offer 21. 调整数组顺序使奇数位于偶数前面
难度简单103
输入一个整数数组，实现一个函数来调整该数组中数字的顺序，使得所有奇数位于数组的前半部分，所有偶数位于数组的后半部分。
示例：
输入：nums = [1,2,3,4]
输出：[1,3,2,4]
注：[3,1,2,4] 也是正确的答案之一。
提示：
0 <= nums.length <= 500001 <= nums[i] <= 10000
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* exchange(int* nums, int numsSize, int* returnSize){
int left = 0;
int right = numsSize -1;
*returnSize = 0;
if (nums == NULL)
{
return nums;
}
*returnSize = numsSize;
if ( numsSize <= 1)
{
return nums;
}
int *ret = (int *)malloc(sizeof(int)*numsSize);
memcpy(ret,nums,sizeof(int)*numsSize);
while (left < right)
{
if (ret[left]%2==0 && ret[right]%2 != 0)//只有偶奇的情况才发生交换
{
ret[left] ^= ret[right];
ret[right] ^= ret[left];
ret[left] ^= ret[right];
}
if (ret[left]%2 != 0)//左边已满足是奇数，则右移处理下一个数
{
left++;
}
if (ret[right] %2 == 0)//右边已满足是偶数，则左移处理下一个数
{
right--;
}
}
*returnSize = numsSize;
return ret;
}
剑指 Offer 22. 链表中倒数第k个节点
难度简单161
输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。
例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。
示例：
给定一个链表: 1->2->3->4->5, 和 k = 2.
返回链表 4->5.
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
struct ListNode* getKthFromEnd(struct ListNode* head, int k){
if (head == NULL)
{
return NULL;
}
typedef struct ListNode Node;
Node *p1 = head;
Node *p2 = head;
int i = 0;
while (p2 && i < k)
{
p2 = p2->next;
i++;
}
if (p2 == NULL && i == k)//k刚好为链表长度
{
return head;
}
if (!p2)
{
return NULL;
}
while (p2)
{
p1 = p1->next;
p2 = p2->next;
}
return p1;
}
剑指 Offer 26. 树的子结构
难度中等243收藏分享切换为英文接收动态反馈
输入两棵二叉树A和B，判断B是不是A的子结构。(约定空树不是任意一个树的子结构)
B是A的子结构， 即 A中有出现和B相同的结构和节点值。
例如:
给定的树 A:
3 / \ 4 5 / \ 1 2
给定的树 B：
4 / 1
返回 true，因为 B 与 A 的一个子树拥有相同的结构和节点值。
示例 1：
输入：A = [1,2,3], B = [3,1]
输出：false
示例 2：
输入：A = [3,4,5,1,2], B = [4,1]
输出：true
限制：
0 <= 节点个数 <= 10000
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
typedef struct TreeNode Node;
typedef struct stack
{
Node *array[10000];
int top;
int size;
}stack;
bool compare(Node *p,Node *q)//以为准
{
if (q == NULL)
{
return true;
}
if (p == NULL)
{
return false;
}
if (p->val != q->val)
{
return false;
}
return compare(p->left,q->left) && compare(p->right,q->right);
}
bool isSubStructure(struct TreeNode* A, struct TreeNode* B){
if (A == NULL || B == NULL)
{
return false;
}
stack A_stack;
memset(&A_stack,0,sizeof(stack));
Node* ptmp = NULL;
ptmp = A;
while (ptmp || A_stack.size > 0)
{
while (ptmp)
{
A_stack.array[A_stack.top++] = ptmp;
A_stack.size++;
ptmp = ptmp->left;
}
ptmp = A_stack.array[A_stack.top-1];
if (ptmp)
{
if (true == compare(ptmp,B))
{
return true;
}
A_stack.top--;
A_stack.size--;
ptmp = ptmp->right;
}
}
return false;
}
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
bool DoesTree1HaveTree2(struct TreeNode *A,struct TreeNode *B)
{
if (!B)
{
return true;
}
if (!A)
{
return false;
}
if (A->val != B->val)
{
return false;
}
return DoesTree1HaveTree2(A->left,B->left) && DoesTree1HaveTree2(A->right,B->right);
}
bool isSubStructure(struct TreeNode* A, struct TreeNode* B){
bool result = false;
if (A && B)
{
if (A->val == B->val)
{
result = DoesTree1HaveTree2(A,B);
}
if (!result)
{
result = isSubStructure(A->left,B);
}
if (!result)
{
result = isSubStructure(A->right,B);
}
}
return result;
}
剑指 Offer 28. 对称的二叉树
难度简单148
请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。
例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
1 / \ 2 2 / \ / \3 4 4 3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
1 / \ 2 2 \ \ 3 3
示例 1：
输入：root = [1,2,2,3,4,4,3]
输出：true
示例 2：
输入：root = [1,2,2,null,3,null,3]
输出：false
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
typedef struct TreeNode Node;
bool testsymmetrix(Node *p,Node *q)
{
if (!p&&!q)
{
return true;
}
if ((!p && q)||(p&&!q))
{
return false;
}
if (p->val == q->val)
{
return testsymmetrix(p->left,q->right) && testsymmetrix(p->right,q->left);
}
return false;
}
bool isSymmetric(struct TreeNode* root){
if (!root)
{
return true;
}
Node *p = root->left;
Node *q = root->right;
return testsymmetrix(p,q);
}
剑指 Offer 31. 栈的压入、弹出序列
难度中等154
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如，序列 {1,2,3,4,5} 是某栈的压栈序列，序列 {4,5,3,2,1} 是该压栈序列对应的一个弹出序列，但 {4,3,5,1,2} 就不可能是该压栈序列的弹出序列。
示例 1：
输入：pushed = [1,2,3,4,5], popped = [4,5,3,2,1]
输出：true
解释：我们可以按以下顺序执行：
push(1), push(2), push(3), push(4), pop() -> 4,
push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
示例 2：
输入：pushed = [1,2,3,4,5], popped = [4,3,5,1,2]
输出：false
解释：1 不能在 2 之前弹出。
提示：
0 <= pushed.length == popped.length <= 10000 <= pushed[i], popped[i] < 1000pushed是popped的排列。
typedef struct
{
int arrary[1000];
int top;
int size;
}stack;
bool validateStackSequences(int* pushed, int pushedSize, int* popped, int poppedSize){
stack g_stack;
g_stack.size = g_stack.top = 0;
int j = 0;
for (int i = 0 ; i < pushedSize;i++)
{
g_stack.arrary[g_stack.top++] = pushed[i];
g_stack.size++;
while (g_stack.size > 0 && j < poppedSize && g_stack.arrary[g_stack.top-1] == popped[j])
{
g_stack.top--;
g_stack.size--;
j++;
}
}
if (j == poppedSize)
{
return true;
}
return false;
}
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VCYt9aQZ-1620547993472)(D:\文档\学习笔记\C语言基础\出入栈序列判断)]
（1）要求一个入栈序列的出栈序列，对于一个待入栈的元素，它可以入栈后就出栈，也可以入栈几个元素后再出。这就是出栈序列的构成。
（2）那么入栈序列给定了，判断出栈序列是否合法，如果从入栈序列来找出栈序列，这只能得到所有合法的出栈序列集合，再去与给定的出栈序列注意比对，这种暴力方法显然是不行的。所以，只能由少推多，由出栈序列来推断是否合法！那么，怎么来推断呢？
（3）我们假设给定的出栈序列就是正确的，出栈序列中的元素的首元素pop[x],它在入栈序列中的位置为pos,那么对于入栈序列push_seq,其位置为0~push_seq-1的元素都要在其后出栈。
如上图：有pop[0] = 4,而pop[0]位于push中的pos=3(从0计数），那么对于入栈序列，此时一定有下图：
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jiMZ1uZJ-1620547993475)(D:\文档\学习笔记\C语言基础\辅助栈.jpg)]
只有这样才能满足元素4第一个出栈。
（4）由（3），我们验证一个栈的出栈序列是否能由其入栈序列得到，那么只需要将入栈序列的元素逐个入栈，且每一个元素入栈后，就将栈顶元素和出栈序列的首元素相比，如相等就出栈，就继续重复比较栈的新栈顶元素和pop的新头元素。重复上述两个步骤，直到入栈元素都被遍历完。此时，如果是一个合法的出栈序列，那么j一定等于出栈序列元素个数，或者辅助栈中的元素一定为空。
剑指 Offer 32 - II. 从上到下打印二叉树 II
难度简单94收藏分享切换为英文接收动态反馈
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。
例如:
给定二叉树: [3,9,20,null,null,15,7],
3
/ \
9 20
/ \
15 7
返回其层次遍历结果：
[
[3],
[9,20],
[15,7]
]
提示：
节点总数 <= 1000
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
typedef struct TreeNode Node;
typedef struct st_stack
{
Node *nodearray[3000];
int top;
int tail;
int size;
}Queue;
/**
* Return an array of arrays of size *returnSize.
* The sizes of the arrays are returned as *returnColumnSizes array.
* Note: Both returned array and *columnSizes array must be malloced, assume caller calls free().
*/
int** levelOrder(struct TreeNode* root, int* returnSize, int** returnColumnSizes){
int **ret = NULL;
int *retcol = NULL;
*returnSize = 0;
int tmpcount = 0;
if (root == NULL)
{
return ret;
}
Queue g_queue;
memset(&g_queue,0,sizeof(Queue));
g_queue.nodearray[g_queue.top++] = root;
g_queue.size++;
while (g_queue.size > 0)
{
ret = realloc(ret,sizeof(int *)*(*returnSize + 1));
ret[*returnSize] = (int *)malloc(sizeof(int)*(g_queue.size));
tmpcount = 0;
retcol = realloc(retcol,sizeof(int)*(*returnSize + 1));
retcol[*returnSize] = g_queue.size;
int size = g_queue.size;
for (int i = 0; i< size;i++)
{
Node *ptop = g_queue.nodearray[g_queue.tail];
g_queue.tail++;
g_queue.size--;
ret[*returnSize][tmpcount++] = ptop->val;
if (ptop->left)
{
g_queue.nodearray[g_queue.top++] = ptop->left;
g_queue.size++;
}
if (ptop->right)
{
g_queue.nodearray[g_queue.top++] = ptop->right;
g_queue.size++;
}
}
(*returnSize)++;
}
*returnColumnSizes = retcol;
return ret;
}
剑指 Offer 40. 最小的k个数
难度简单219
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]
限制：
0 <= k <= arr.length <= 100000 <= arr[i] <= 10000
对于这种元素大小范围确定的情况下可以直接使用计数排序
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize){
int *ret = NULL;
*returnSize = 0;
if (arr == NULL || arrSize <= 0 || k == 0)
{
return ret;
}
int cnt_map[10001] = {0};
ret = (int *)malloc(sizeof(int)*k);
int tmpcount = 0;
if (k >= arrSize)
{
memcpy(ret,arr,sizeof(int)*arrSize);
*returnSize = arrSize;
return ret;
}
for (int i = 0 ; i < arrSize;i++)
{
cnt_map[arr[i]]++;//建立数字大小和出现次数的映射
}
for (int i = 0 ;i < 10001;i++)//这样只需要从最小的数字开始取k个即可
{
if (tmpcount == k)//已得到
{
continue;
}
if (cnt_map[i] == 0)//数字未出现
{
continue;
}
if (cnt_map[i] + tmpcount > k)
{
int size = k - tmpcount;
for (int j = 0;j < size;j++)
{
ret[tmpcount++] = i;
}
break;
}
else
{
for (int j = 0;j < cnt_map[i];j++)
{
ret[tmpcount++] = i;
}
}
}
*returnSize = tmpcount;
return ret;
}
剑指 Offer 54. 二叉搜索树的第k大节点
给定一棵二叉搜索树，请找出其中第k大的节点。
示例 1:
输入: root = [3,1,4,null,2], k = 1
3
/
1 4
2
输出: 4
示例 2:
输入: root = [5,3,6,2,4,null,null,1], k = 3
5
/
3 6
/
2 4
/
1
输出: 4
限制：
1 ≤ k ≤ 二叉搜索树元素个数
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/er-cha-sou-suo-shu-de-di-kda-jie-dian-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
typedef struct TreeNode Node;
typedef struct st_stack
{
Node *parray[10000];
int top;
int tail;
int size;
}stack;
//LDR
int kthLargest(struct TreeNode* root, int k){
stack g_stack;
memset(&g_stack,0,sizeof(g_stack));
Node *pseq[10000] = {0};
int node_cnt = 0;
Node *ptmp = root;
while (ptmp != NULL || g_stack.size > 0 )
{
while (ptmp)
{
g_stack.parray[g_stack.top] = ptmp;
g_stack.top++;
g_stack.size++;
ptmp = ptmp->left;
}
ptmp = g_stack.parray[g_stack.top-1];
g_stack.top--;
g_stack.size--;
if (ptmp)
{
pseq[node_cnt++] = ptmp;
ptmp = ptmp->right;
}
}
return pseq[node_cnt - k]->val;
}
剑指 Offer 55 - I. 二叉树的深度
难度简单102
输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。
例如：
给定二叉树 [3,9,20,null,null,15,7]，
3
/ \
9 20
/ \
15 7
返回它的最大深度 3 。
提示：
-
`节点总数 <= 10000
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ int max(int a,int b) { return (a) > (b)?(a):(b); } int maxDepth(struct TreeNode* root){ if (!root) { return 0; } return 1 + max(maxDepth(root->left),maxDepth(root->right)); }如果面试官不让我们用递归，那么我们可以用二叉树的层次遍历，每一层就是一个深度
注意辅助队列的容积为题目限制的最大结点数的2倍，这样即使每层只有一个节点，共计10000个节点10000深度的二叉树，那么的辅助队列的最大大小20000就够了。
/** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *right; * }; */ typedef struct TreeNode Node; typedef struct { Node* arrary[20000]; int top; int tail; int size; }queue; int maxDepth(struct TreeNode* root){ if (!root) { return 0; } int dep = 0; queue g_queue; g_queue.top = g_queue.size = g_queue.tail = 0; g_queue.arrary[g_queue.top++] = root; g_queue.size++; while (g_queue.size > 0) { int size = g_queue.size; Node *ptmp = NULL; if (size>0) { dep++; } for (int i = 0; i < size;i++) { ptmp = g_queue.arrary[g_queue.tail]; g_queue.size--; g_queue.tail++; if (ptmp->left) { g_queue.arrary[g_queue.top++] = ptmp->left; g_queue.size++; } if (ptmp->right) { g_queue.arrary[g_queue.top++] = ptmp->right; g_queue.size++; } } } return dep; }
第四章
剑指 Offer 27. 二叉树的镜像
难度简单123
请完成一个函数，输入一个二叉树，该函数输出它的镜像。
例如输入：
4 / \ 2 7 / \ / \1 3 6 9
镜像输出：
4 / \ 7 2 / \ / \9 6 3 1
示例 1：
输入：root = [4,2,7,1,3,6,9]
输出：[4,7,2,9,6,3,1]
限制：
0 <= 节点个数 <= 1000
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* struct TreeNode *left;
* struct TreeNode *right;
* };
*/
struct TreeNode* mirrorTree(struct TreeNode* root){
typedef struct TreeNode Node;
if (!root)
{
return root;
}
Node* ptmp = root->left;
root->left = root->right;
root->right = ptmp;
if (root->left)
{
mirrorTree(root->left);
}
if (root->right)
{
mirrorTree(root->right);
}
return root;
}
剑指 Offer 29. 顺时针打印矩阵
难度简单216
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。
示例 1：
输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]
示例 2：
输入：matrix = [[1,2,3,4],[5,6,7,8],[9,10,11,12]]
输出：[1,2,3,4,8,12,11,10,9,5,6,7]
限制：
0 <= matrix.length <= 1000 <= matrix[i].length <= 100
int* spiralOrder(int** matrix, int matrixSize, int* matrixColSize, int* returnSize){
*returnSize = 0;
if (matrix == NULL || matrixSize <= 0 || matrixColSize == NULL)
{
return NULL;
}
int up = 0;
int down = matrixSize-1;
int left = 0;
int right = *matrixColSize -1;
int *res = NULL;
int count = 0;
const int num = matrixSize*(*matrixColSize);
if (num <= 0)
{
return res;
}
res = (int *)malloc(sizeof(int)*num);
memset(res,0,sizeof(int)*num);
while (count < num)
{
for (int i = left;i <= right;i++)
{
res[count++] = matrix[up][i];
}
up++;
if (up > down)
{
break;
}
for (int j = up;j <= down;j++)
{
res[count++] = matrix[j][right];
}
right--;
if (right < left)
{
break;
}
for (int j = right;j >= left;j--)
{
res[count++] = matrix[down][j];
}
down--;
if (down < up)
{
break;
}
for (int j = down;j >= up;j--)
{
res[count++] = matrix[j][left];
}
left++;
if (left > right)
{
break;
}
}
*returnSize = count;
return res;
}
注意这个边界left、right、up、down移动后的边界判断的必要性，必须判断，不然就不能保证上下左右四个方向都是缩小包围圈的地进行遍历。
剑指 Offer 33. 二叉搜索树的后序遍历序列
难度中等236
输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历结果。如果是则返回 true，否则返回 false。假设输入的数组的任意两个数字都互不相同。
参考以下这颗二叉搜索树：
5
/ \
2 6
/ \
1 3
示例 1：
输入: [1,6,3,2,5]
输出: false
示例 2：
输入: [1,3,2,6,5]
输出: true
提示：
数组长度 <= 1000
bool verifyPostorder(int* postorder, int postorderSize){
if (postorderSize <= 0 || postorder == NULL)
{
return true;
}
int i = 0;
int root = postorder[postorderSize-1];
for (;i < postorderSize-1;i++)
{
if (postorder[i] > root)
{
break;
}
}
for (int j = i;j < postorderSize-1;j++)
{
if (postorder[j] < root)
{
return false;
}
}
int left = true;
if (i>0)
{
left = verifyPostorder(postorder,i);
}
int right = true;
if (i < postorderSize-1)
{
right = verifyPostorder(postorder+i,postorderSize-i-1);
}
return left&&right;
}
面试题 34. 二叉树中和为某一值的路径
难度中等157
输入一棵二叉树和一个整数，打印出二叉树中节点值的和为输入整数的所有路径。从树的根节点开始往下一直到叶节点所经过的节点形成一条路径。
示例:
给定如下二叉树，以及目标和 target = 22，
5
/ \
4 8
/ / \
11 13 4
/ \ / \
7 2 5 1
返回:
[
[5,4,11,2],
[5,8,4,5]
]
提示：
节点总数 <= 10000
typedef struct TreeNode Node;
void dfs(int ***res,int *returnSize,int cur,Node *root,const int target,int *cur_array,int cur_size,int **retcol)
{
if(!root)
{
return;
}
cur += root->val;
cur_array[cur_size] = root->val;
if (!root->left && !root->right && cur == target)
{
(*res) = realloc((*res),sizeof(int *)*(*returnSize+1));
(*res)[*returnSize] = malloc(sizeof(int)*(cur_size+1));
memcpy((*res)[*returnSize],cur_array,sizeof(int)*(1+cur_size));
*retcol = realloc(*retcol,sizeof(int)*(*returnSize+1));
(*retcol)[*returnSize] = cur_size+1;
(*returnSize)++;
return;
}
if (root->left)
{
dfs(res,returnSize,cur,root->left,target,cur_array,cur_size+1,retcol);
}
if (root->right)
{
dfs(res,returnSize,cur,root->right,target,cur_array,cur_size+1,retcol);
}
}
int** pathSum(struct TreeNode* root, int target, int* returnSize, int** returnColumnSizes)
{
int **res = NULL;
int *retcol = NULL;
int cur = 0;
int cur_array[10000] = {0};
int cur_size = 0;
(*returnSize) = 0;
dfs(&res,returnSize,cur,root,target,cur_array,cur_size,&retcol);
*returnColumnSizes = retcol;
return res;
}
剑指 Offer 35. 复杂链表的复制
难度中等185
请实现 copyRandomList 函数，复制一个复杂链表。在复杂链表中，每个节点除了有一个 next 指针指向下一个节点，还有一个 random 指针指向链表中的任意节点或者 null。
示例 1：
输入：head = [[7,null],[13,0],[11,4],[10,2],[1,0]]
输出：[[7,null],[13,0],[11,4],[10,2],[1,0]]
示例 2：
输入：head = [[1,1],[2,1]]
输出：[[1,1],[2,1]]
示例 3：
输入：head = [[3,null],[3,0],[3,null]]
输出：[[3,null],[3,0],[3,null]]
示例 4：
输入：head = []
输出：[]
解释：给定的链表为空（空指针），因此返回 null。
提示：
-10000 <= Node.val <= 10000Node.random为空（null）或指向链表中的节点。- 节点数目不超过 1000 。
**注意：**本题与主站 138 题相同：https://leetcode-cn.com/problems/copy-list-with-random-pointer/
class Solution {
public:
Node* copyRandomList(Node* head) {
unordered_map<Node *,Node *> node_map;
Node *ptmp = head;
Node *res = NULL;
while (ptmp)
{
Node *node = new Node(ptmp->val);
node_map.insert(make_pair(ptmp,node));
if (!res)
{
res = node;
}
ptmp = ptmp->next;
}
for (auto v:node_map)
{
if (v.first->next)
{
v.second->next = node_map[v.first->next];
}
if (v.first->random)
{
v.second->random = node_map[v.first->random];
}
}
return res;
}
};
使用一个hash表，在遍历原始链表的时候，每遍历一个节点N,就对应地创建一个节点N’,并将N和N’的指针插入hash表中。这样，后续再次遍历hash表，便可由N的next信息和random信息找到N’的next和random信息。
剑指 Offer 36. 二叉搜索树与双向链表
难度中等225收藏分享切换为英文接收动态反馈
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的循环双向链表。要求不能创建任何新的节点，只能调整树中节点指针的指向。
为了让您更好地理解问题，以下面的二叉搜索树为例：
我们希望将这个二叉搜索树转化为双向循环链表。链表中的每个节点都有一个前驱和后继指针。对于双向循环链表，第一个节点的前驱是最后一个节点，最后一个节点的后继是第一个节点。
下图展示了上面的二叉搜索树转化成的链表。“head” 表示指向链表中有最小元素的节点。
特别地，我们希望可以就地完成转换操作。当转化完成以后，树中节点的左指针需要指向前驱，树中节点的右指针需要指向后继。还需要返回链表中的第一个节点的指针。
**注意：**本题与主站 426 题相同：https://leetcode-cn.com/problems/convert-binary-search-tree-to-sorted-doubly-linked-list/
**注意：**此题对比原题有改动。
/*
// Definition for a Node.
class Node {
public:
int val;
Node* left;
Node* right;
Node() {}
Node(int _val) {
val = _val;
left = NULL;
right = NULL;
}
Node(int _val, Node* _left, Node* _right) {
val = _val;
left = _left;
right = _right;
}
};
*/
class Solution {
public:
Node* treeToDoublyList(Node* root) {
vector<Node *> vnd;
stack<Node *> stack;
Node *p = root;
if (p == NULL)
{
return p;
}
while (p || stack.size() > 0)//得到其LDR的序列
{
while (p)
{
stack.push(p);
p = p->left;
}
p = stack.top();
stack.pop();
vnd.push_back(p);
p = p->right;
}
for (int i = 0; i < vnd.size();i++)//根据循环链表的特征，重新更改其指针关系
{
if (i == 0)
{
vnd[i]->left = vnd[vnd.size()-1];
}
else
{
vnd[i]->left = vnd[i-1];
}
if (i + 1 == vnd.size())
{
vnd[i]->right = vnd[0];
}
else
{
vnd[i]->right = vnd[i+1];
}
}
return vnd[0];
}
};
剑指 Offer 38. 字符串的排列
难度中等236
输入一个字符串，打印出该字符串中字符的所有排列。
你可以以任意顺序返回这个字符串数组，但里面不能有重复元素。
示例:
输入：s = "abc"
输出：["abc","acb","bac","bca","cab","cba"]
限制：
1 <= s 的长度 <= 8
//c语言超时
void DFS(const char *str,const int len,char ***res,int *returnSize,char *cur_str,int cur_size,int *num_visited)
{
if (cur_size == len)
{
(*res) = realloc((*res),sizeof(char *)*(*returnSize + 1));
(*res)[*returnSize] = (char *)malloc(len+1);
strncpy((*res)[*returnSize],cur_str,len);
(*res)[*returnSize][len] = '\0';
(*returnSize) += 1;
return;
}
int visited[128] = {0};
for (int i = 0; i < len;i++)
{
if (num_visited[i] == 1)//深度优先遍历的保证
{
continue;
}
if (visited[(int)str[i]] == 1)//同层次重复元素剪枝去重
{
continue;
}
num_visited[i] = 1;
visited[(int)str[i]] = 1;
cur_str[cur_size] = str[i];
DFS(str,len,res,returnSize,cur_str,cur_size+1,num_visited);
num_visited[i] = 0;
}
}
char** permutation(char* s, int* returnSize){
char **res = NULL;
char cur_str[20] = {0};
int cur_size = 0;
int len = strlen(s);
(*returnSize) = 0;
int *num_visited = (int *)malloc(sizeof(int)*len);
memset(num_visited,0,sizeof(int)*len);
DFS(s,len,&res,returnSize,cur_str,cur_size,num_visited);
return res;
}
//cpp 通过
class Solution {
public:
void dfs(const string &str,vector<string> &res,string& cur_str,map<int,int> &mp)
{
if (cur_str.size() == str.size())
{
res.push_back(cur_str);
return;
}
bool visited[128] = {0};
for (size_t i = 0; i < str.size();++i)
{
if (mp[i] == 0 && visited[(int)str[i]] == 0)
{
mp[i] = 1;
visited[(int)str[i]] = 1;
cur_str.push_back(str[i]);
dfs(str,res,cur_str,mp);
mp[i] = 0;
cur_str.pop_back();
}
}
}
vector<string> permutation(string s) {
vector<string> res;
map<int,int> nummap;
string cur_str;
dfs(s,res,cur_str,nummap);
return res;
}
};
第五章
剑指 Offer 39. 数组中出现次数超过一半的数字
难度简单143收藏分享切换为英文接收动态反馈
数组中有一个数字出现的次数超过数组长度的一半，请找出这个数字。
你可以假设数组是非空的，并且给定的数组总是存在多数元素。
示例 1:
输入: [1, 2, 3, 2, 2, 2, 5, 4, 2]
输出: 2
限制：
1 <= 数组长度 <= 50000
//基于快排的分治思想来做
int parttion(int *g,int left,int right)
{
int key = g[left];
while (left < right)
{
while (left < right && g[right] >= key)
{
right--;
}
g[left] = g[right];
while (left < right && g[left] <= key)
{
left++;
}
g[right] = g[left];
}
g[left] = key;
return left;
}
int majorityElement(int* nums, int numsSize){
if (!nums || numsSize <= 0)
{
return -1;
}
int left = 0;
int right = numsSize - 1;
int k = numsSize>>1;
int piviot = parttion(nums,left,right);
while (piviot != k)
{
if (piviot > k)
{
right = piviot-1;
piviot = parttion(nums,left,right);
}
else
{
left = piviot + 1;
piviot = parttion(nums,left,right);
}
}
return nums[k];
}
//同归于尽法
int majorityElement(int* nums, int numsSize){
if (!nums || numsSize <=0)
{
return -1;
}
int ret = nums[0];
int count = 1;
for (int i = 1;i < numsSize;++i)
{
if (ret == nums[i])
{
++count;
}
else
{
--count;
if (count <= 0)
{
count = 1;
ret = nums[i];
}
}
}
return ret;
}
剑指 Offer 40. 最小的k个数
难度简单234收藏分享切换为英文接收动态反馈
输入整数数组 arr ，找出其中最小的 k 个数。例如，输入4、5、1、6、2、7、3、8这8个数字，则最小的4个数字是1、2、3、4。
示例 1：
输入：arr = [3,2,1], k = 2
输出：[1,2] 或者 [2,1]
示例 2：
输入：arr = [0,1,2,1], k = 1
输出：[0]
限制：
0 <= k <= arr.length <= 100000 <= arr[i] <= 10000
**解题思路: **
此题目求数组中最小的K个数（无序对其进行排序），也既是排序后的数组中0~k-1的数，而由快速排序我们可知，每次选取一个枢纽值，可将数组划分为三部分：子数组a+枢纽元素x+子数组b,
一定满足:
(1)子数组a中的元素都<=x
(2)子数组b中的元素都>=x
由此，我们可以通过判断a中的元素个数n：
（1）若n == k,则说明这前n个元素就是最小的k个元素,我们直接取即可。
（2）若n < k,则说明前n个元素是构成前k个元素的一部分，于是我们继续使用上述方法求剩下的k-n个元素
（3）若n > k,说明此趟划分的前n个元素未前K个最小元素的父集，那么我们继续在这个父集中求前k个元素即可。
这样的好处是，我们不需要将所有元素都排序后再取前k个元素，时间复杂度得到一定的优化
代码:
int parttion(int *g,int left,int right)
{
int key = g[left];
while (left < right)
{
while (left < right && g[right] >= key)
{
right--;
}
g[left] = g[right];
while (left < right && g[left] <= key)
{
left++;
}
g[right] = g[left];
}
g[left] = key;
return left;
}
void quicksort(int *g,int left,int right,int *res,int *retsize,int k)
{
if (!g || left > right)
{
return;
}
if (k == 0)
{
return;
}
int piviot = parttion(g,left,right);
if (piviot - left == k)
{
for (int i = left;i < piviot;++i)
{
res[*retsize] = g[i];
(*retsize) += 1;
--k;
}
left = piviot;
}
else if (piviot - left < k)
{
for (int i = left;i <= piviot;++i)
{
res[*retsize] = g[i];
(*retsize) += 1;
--k;
}
left = piviot+1;
}
else
{
right = piviot-1;
}
printf("p: %d l: %d r: %d k: %d\n",piviot,left,right,k);
quicksort(g,left,right,res,retsize,k);
}
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* getLeastNumbers(int* arr, int arrSize, int k, int* returnSize)
{
(*returnSize) = 0;
if (!arr || arrSize <= 0)
{
return NULL;
}
int *res = (int *)malloc(sizeof(int)*k);
if (!res)
{
return NULL;
}
int left = 0;
int right = arrSize-1;
quicksort(arr,left,right,res,returnSize,k);
return res;
}
剑指 Offer 42. 连续子数组的最大和
难度简单241收藏分享切换为英文接收动态反馈
输入一个整型数组，数组中的一个或连续多个整数组成一个子数组。求所有子数组的和的最大值。
要求时间复杂度为O(n)。
示例1:
输入: nums = [-2,1,-3,4,-1,2,1,-5,4]
输出: 6
解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。
提示：
1 <= arr.length <= 10^5-100 <= arr[i] <= 100
注意：本题与主站 53 题相同：https://leetcode-cn.com/problems/maximum-subarray/
int max(int a,int b)
{
return a>b?a:b;
}
int maxSubArray(int* nums, int numsSize){
int cur_sum = 0;
int res = -200;
for (int i = 0 ; i < numsSize;i++)
{
cur_sum = max(cur_sum + nums[i],nums[i]);
res = max(res,cur_sum);
}
return res;
}
curSum = max(curSum + nums[i],nums[i]); 这是求累加过程中出现的所有局部最大值的情况
为什么会是curSum+nums[i]与nums[i]比较取最大值？因为，curSum+nums[i]表示的是从数组某个位置到下标i的连续子数组的和，然而若是这个和都小于当前元素nums[i]，那我们还有什么理由不重新以i为新连续子数组的起始坐标，开始计算新的连续的子数组的最大和呢？
而，res = max(res, curSum);，则是常规的在遍历过程里求所最大值的步骤。
剑指 Offer 51. 数组中的逆序对
难度困难401
在数组中的两个数字，如果前面一个数字大于后面的数字，则这两个数字组成一个逆序对。输入一个数组，求出这个数组中的逆序对的总数。
示例 1:
输入: [7,5,6,4]
输出: 5
限制：
0 <= 数组长度 <= 50000
归并排序
int merge(int *g,int l,int m,int r)
{
int *tmp = (int *)malloc(sizeof(int)*(r-l+1));
int idx = 0;
int L_idx = l;
int R_idx = m+1;
int cnt = 0;
while (L_idx <= m && R_idx <= r)
{
if (g[L_idx] <= g[R_idx])
{
tmp[idx++] = g[L_idx++];
}
else
{
tmp[idx++] = g[R_idx++];
cnt += m - L_idx + 1;
}
}
while (L_idx <= m)
{
tmp[idx++] = g[L_idx++];
}
while (R_idx <= r)
{
tmp[idx++] = g[R_idx++];
}
for (int i = l;i <= r;++i)
{
g[i] = tmp[i-l];
}
free(tmp);
return cnt;
}
int merge_sort(int *g,int left,int right)
{
int l = 0,m = 0,r = 0;
if (left < right)
{
int mid = (left+right)/2;
l = merge_sort(g,left,mid);
r = merge_sort(g,mid+1,right);
m = merge(g,left,mid,right);
}
return l+r+m;
}
int mergecount(int *g,int size)
{
if (!g || size <= 0)
{
return 0;
}
int left = 0;
int right = size-1;
int cnt = merge_sort(g,left,right);
return cnt;
}
int reversePairs(int* nums, int numsSize){
return mergecount(nums,numsSize);
}
剑指 Offer 56 - I. 数组中数字出现的次数
难度中等382
一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。
示例 1：
输入：nums = [4,1,4,6]
输出：[1,6] 或 [6,1]
示例 2：
输入：nums = [1,2,10,4,1,4,3,3]
输出：[2,10] 或 [10,2]
限制：
2 <= nums.length <= 10000
int* singleNumbers(int* nums, int numsSize, int* returnSize)
{
int *ret = NULL;
*returnSize = 0;
int target = 0;
for (int i = 0; i < numsSize;++i)
{
target ^= nums[i];
}
if (target == 0)
{
return ret;
}
int diff_pos = 0;
while ( target != 0)//由两数的异或结果，可求得它俩二进制形式中最开始不同的bit位。
{
if ( target&1 == 1)
{
break;
}
++diff_pos;
target >>= 1;
}
ret = (int *)malloc(sizeof(int)*2);
ret[0] = 0;
ret[1] = 0;
(*returnSize) = 2;
for (int i = 0; i < numsSize;++i)
{//由上得到两个单独出现的数的不同的二进制位，可将整个数组根据该位划分为两部分，一部分是该位为0的数的集合，另一部分是为1的集合。
if (((nums[i] >> diff_pos)&0x1) == 0)
{
ret[0] ^= nums[i];
}
else
{
ret[1] ^= nums[i];//该位为1的数组互相异或得到要求两个不同的数中的一个
}
}
return ret;
}
异或运算的几个性质
- 交换律
- 结合律（即(ab)c == a(bc)）
- 对于任何数x，都有xx=0，x0=x
- 自反性 A XOR B XOR B = A xor 0 = A —> A XOR B = C 则 C XOR B = A
- 根据异或运算的规律和数组的定义，可知最终的异或结果为要求的两个只出现一次的数异或的结果。
- 两个不同的数异或，比如1和6，异或结果7的二进制表示为：00…0111,则求得1和6的二进制位开始出现差异的为从右往左的第一个bit位（从右往左的第一个不为0的bit位）。
- 根据该bit位的位置，将数组中该位置的bit位为0的数划分到数组1，为1的数划分到数组2
- 将数组1中的数互相异或，得到一个不为0的数A，同理，数组2中的数互相异或得到数B
7644
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
