diff --git "a/2224020014/chapter_10/\345\217\215\350\275\254\345\257\271.cpp" "b/2224020014/chapter_10/\345\217\215\350\275\254\345\257\271.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..678af8ceab201aca5a639a3a0c3a95194a0a715e --- /dev/null +++ "b/2224020014/chapter_10/\345\217\215\350\275\254\345\257\271.cpp" @@ -0,0 +1,48 @@ +void merge(int size,int* nums,int start,int mid,int end){ + int tmp[size]; + int s=start,t=mid+1,k=start; + while(s<=mid&&t<=end){ + if(nums[s]<=nums[t]){ + tmp[k]=nums[s]; + s++; + } + else{ + tmp[k]=nums[t]; + t++; + } + k++; + } + while(s<=mid) + tmp[k++]=nums[s++]; + while(t<=end) + tmp[k++]=nums[t++]; + for(int i=start;i<=end;i++) + nums[i]=tmp[i]; +} +int mergesort(int size,int*nums,int start,int end){ + if(start==end) + return 0; + int mid=(start+end)/2; + int n1=mergesort(size,nums,start,mid); + int n2=mergesort(size,nums,mid+1,end); + int ret=n1+n2; + int i=start,j=mid+1; + while(i<=mid&&j<=end){ + if((long long)nums[i]>2*(long long)nums[j]){ + j++; + ret+=mid-i+1; + } + else + i++; + } + i=start; + j=mid+1; + merge(size,nums,start,mid,end); + return ret; +} + +int reversePairs(int* nums, int numsSize){ + if(numsSize==0) + return 0; + return mergesort(numsSize,nums,0,numsSize-1); +} \ No newline at end of file diff --git "a/2224020014/chapter_10/\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204.cpp" "b/2224020014/chapter_10/\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..7755e9aa8e558ccd300e28645cae3995915f58dc --- /dev/null +++ "b/2224020014/chapter_10/\346\214\211\345\245\207\345\201\266\346\216\222\345\272\217\346\225\260\347\273\204.cpp" @@ -0,0 +1,20 @@ + +/** + * Note: The returned array must be malloced, assume caller calls free(). + */ +int* sortArrayByParityII(int* nums, int numsSize, int* returnSize){ + int q=1; + int o=0; + int *new = (int*)malloc(sizeof(int)*numsSize); + for(int i=0;i nums[j+1]) { + int temp = nums[j]; + nums[j] = nums[j+1]; + nums[j+1] = temp; + flag = true; + } + } + if (!flag) { + break; + } + } + return nums; +} \ No newline at end of file diff --git "a/2224020014/chapter_10/\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204k\344\270\252\347\202\271.cpp" "b/2224020014/chapter_10/\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204k\344\270\252\347\202\271.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..21d689b8ac4a116bc3b1dff6cb1f13fc735ded62 --- /dev/null +++ "b/2224020014/chapter_10/\346\234\200\346\216\245\350\277\221\345\216\237\347\202\271\347\232\204k\344\270\252\347\202\271.cpp" @@ -0,0 +1,12 @@ +int cmp(const void *a, const void *b) { + int *aa = *(int**)a; + int *bb = *(int**)b; + return aa[0] * aa[0] + aa[1] * aa[1] - bb[0] * bb[0] - bb[1] * bb[1]; +} + +int** kClosest(int** points, int pointsSize, int* pointsColSize, int K, int* returnSize, int** returnColumnSizes){ + qsort(points, pointsSize, sizeof(points[0]), cmp); + *returnSize = K; + *returnColumnSizes = pointsColSize; + return points; +} \ No newline at end of file diff --git "a/2224020014/chapter_10/\351\207\215\346\226\260\346\216\222\345\210\227\345\255\227\347\254\246\344\270\262.cpp" "b/2224020014/chapter_10/\351\207\215\346\226\260\346\216\222\345\210\227\345\255\227\347\254\246\344\270\262.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..b9495a03303d4d6f39c6c08b0adfb80cf50bf155 --- /dev/null +++ "b/2224020014/chapter_10/\351\207\215\346\226\260\346\216\222\345\210\227\345\255\227\347\254\246\344\270\262.cpp" @@ -0,0 +1,8 @@ +char * restoreString(char * s, int* indices, int indicesSize){ + char *ss = (char *)malloc(sizeof(char)*indicesSize + 1); + for (int i = 0; i < indicesSize;i ++) { + ss[indices[i]] = s[i]; + } + ss[indicesSize] = '\0'; + return ss; +} diff --git "a/2224020014/chapter_7/N\345\217\211\346\240\221\347\232\204\345\205\210\346\240\271\351\201\215\345\216\206.cpp" "b/2224020014/chapter_7/N\345\217\211\346\240\221\347\232\204\345\205\210\346\240\271\351\201\215\345\216\206.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..7f503937dbbcce63d1af63cfd557136cd9dbe161 --- /dev/null +++ "b/2224020014/chapter_7/N\345\217\211\346\240\221\347\232\204\345\205\210\346\240\271\351\201\215\345\216\206.cpp" @@ -0,0 +1,28 @@ + +/** + * Definition for a Node. + * struct Node { + * int val; + * int numChildren; + * struct Node** children; + * }; + */ + +/** + * Note: The returned array must be malloced, assume caller calls free(). + */ +void dfs(struct Node* root,int* returnSize,int* pre) +{ + if(root==NULL) return; + pre[(*returnSize)++]=root->val; + for(int i=0;inumChildren;i++) + { + dfs(root->children[i],returnSize,pre); + } +} +int* preorder(struct Node* root, int* returnSize) { + int* pre=malloc(sizeof(int)*10001); + *returnSize=0; + dfs(root,returnSize,pre); + return pre; +} diff --git "a/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.cpp" "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..1a4d27fa1c123cc641054c62decf41acad74c916 --- /dev/null +++ "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.cpp" @@ -0,0 +1,30 @@ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ + +struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) { + if(root == NULL) + { + return NULL; + } + if(root == p || root == q) + { + return root; + } + + struct TreeNode * left = lowestCommonAncestor(root->left, p, q); + struct TreeNode * right = lowestCommonAncestor(root->right, p, q); + + if(left != NULL && right != NULL) + { + return root; + } + + return left == NULL ? right : left; +} + diff --git "a/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.cpp" "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..7a78998d14f8301e870879b8611f2f252b13de44 --- /dev/null +++ "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.cpp" @@ -0,0 +1,27 @@ + +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ +/** + * Note: The returned array must be malloced, assume caller calls free(). + */ + void postbinaryTree(struct TreeNode*node, int*arr,int*arrsize){ + if(!node){ + return ; + } + postbinaryTree(node->left,arr,arrsize); + postbinaryTree(node->right,arr,arrsize); + arr[*arrsize] = node->val; + (*arrsize)++; + } +int* postorderTraversal(struct TreeNode* root, int* returnSize) { + int*newarr = (int*)malloc(1000*sizeof(int)); + *returnSize = 0; + postbinaryTree(root,newarr,returnSize); + return newarr; +} \ No newline at end of file diff --git "a/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.cpp" "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..e4b2d9da2ca2ce6105da24dc957c384d58a9899a --- /dev/null +++ "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.cpp" @@ -0,0 +1,48 @@ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ +/** + * 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){ + //对树为空的情况进行讨论 + *returnSize = 0;//注意要先将returnSize设为0 + if(root == NULL){ + return NULL; + } + //初始化各类值 + int **res = (int**)malloc(sizeof(int*)*2000); + *returnColumnSizes = (int*)malloc(sizeof(int)*2000); + int front = 0, rear = 0; + struct TreeNode *queue[2000]; + queue[rear++] = root; + //队列中有元素的情况 + while(front != rear){ + int last = rear; + int flag = 0; + struct TreeNode *t; + res[*returnSize] = (int*)malloc(sizeof(int)*(last - front)); + //对队列中的所有元素进行处理：把它们放在数组中，然后将他们的左右儿子放在队列中 + while(front < last){ + t = queue[front++]; + res[*returnSize][flag++] = t -> val; + if(t -> left != NULL){ + queue[rear++] = t -> left; + } + if(t -> right != NULL){ + queue[rear++] = t -> right; + } + } + (*returnColumnSizes)[*returnSize] = flag; + (*returnSize)++; + } + return res; +} diff --git "a/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\345\256\275\345\272\246.cpp" "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\345\256\275\345\272\246.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..e3420a20320abe11c1504d6bf2c887cb1c2e279c --- /dev/null +++ "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\345\256\275\345\272\246.cpp" @@ -0,0 +1,50 @@ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ + + +#define MAX_NUM 20005 + +int widthOfBinaryTree(struct TreeNode* root){ + if (root == NULL) { + return 0; + } + struct TreeNode *q[MAX_NUM]; + // 在原节点上修改val值记录不行，有用例会超过int范围，加一个长整型型辅助数组 + unsigned long long idxQ[MAX_NUM]; + + int front = 0; + int rear = 0; + // 根节点赋值为其编号0 + // root->val = 0; + idxQ[rear] = 1; + // 根节点入队 + q[rear++] = root; + int max = 0; + + while (front < rear) { + // 每层宽度：每层最后一个节点的值减去最后一个节点的值+1 + // max = fmax(max, q[rear - 1]->val - q[front]->val + 1); + max = fmax(max, idxQ[rear - 1] - idxQ[front] + 1); + // 本层所有元素出队，同时将子节点入队，且对子节点赋值正确的编号 + int curLevelSize = rear - front; + for (int i = 0; i < curLevelSize; i++) { + unsigned long long idx = idxQ[front]; + struct TreeNode *node = q[front++]; + if (node->left != NULL) { + idxQ[rear] = idx * 2; + q[rear++] = node->left; + } + if (node->right != NULL) { + idxQ[rear] = idx * 2 + 1; + q[rear++] = node->right; + } + } + } + return max; +} diff --git "a/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.cpp" "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..f77e2d2bcf712163845d6e45c01b655419738a1c --- /dev/null +++ "b/2224020014/chapter_7/\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.cpp" @@ -0,0 +1,27 @@ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ +int maxDepth(struct TreeNode* root){ + //结束条件 + if(root == NULL) + { + return 0; + } + + //单层递归 + int L=maxDepth(root->left) + 1; + int R=maxDepth(root->right) + 1; + if(L > R) + { + return L; + } + else + { + return R; + } +} diff --git "a/2224020014/chapter_7/\344\273\216\345\205\210\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.cpp" "b/2224020014/chapter_7/\344\273\216\345\205\210\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..edfc9f9e578e484e4a02818d5e6f8a020f147393 --- /dev/null +++ "b/2224020014/chapter_7/\344\273\216\345\205\210\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.cpp" @@ -0,0 +1,21 @@ +struct TreeNode* tree(int* preorder, int preStar, int preEnd, int* inorder, int inStar, int inEnd){ + if(preStar > preEnd)return NULL; + int rootVal = preorder[preStar]; + int index = 0; + for(int i=inStar; i<=inEnd; i++){ + if(inorder[i] == rootVal){ + index = i; + break; + } + } + struct TreeNode* root = (struct TreeNode*)malloc(sizeof(struct TreeNode)); + root->val = rootVal; + int leftSize = index-inStar; + root->left = tree(preorder, preStar+1, preStar+leftSize, inorder, inStar, index-1); + root->right = tree(preorder, preStar+leftSize+1, preEnd, inorder, index+1, inEnd); + return root; +} + +struct TreeNode* buildTree(int* preorder, int preorderSize, int* inorder, int inorderSize){ + return tree(preorder, 0, preorderSize-1, inorder, 0, inorderSize-1); +} diff --git "a/2224020014/chapter_7/\345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.cpp" "b/2224020014/chapter_7/\345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..1e1067b189e4574308003159534d52f25e7a88af --- /dev/null +++ "b/2224020014/chapter_7/\345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.cpp" @@ -0,0 +1,32 @@ + +typedef struct CostInfo { + int a; + int b; + int diff; +} CostInfo; +int Cmp(const void *a, const void *b) +{ + CostInfo *aa = (CostInfo*)a; + CostInfo *bb = (CostInfo*)b; + if (aa->diff > bb->diff) { + return 1; + } + if (aa->diff > bb->diff) { + return 0; + } + return -1; +} +int twoCitySchedCost(int** costs, int costsSize, int* costsColSize){ + CostInfo *sched = (CostInfo *)malloc(costsSize * sizeof(CostInfo)); + for (int idx = 0; idx < costsSize; idx++) { + sched[idx].a = costs[idx][0]; + sched[idx].b = costs[idx][1]; + sched[idx].diff = costs[idx][0] - costs[idx][1]; + } + qsort(sched, costsSize, sizeof(CostInfo), Cmp); + int sum = 0; + for (int i = 0; i < costsSize / 2; i++) { + sum += sched[i].a + sched[i + costsSize / 2].b; + } + return sum; +} \ No newline at end of file diff --git "a/2224020014/chapter_7/\350\267\257\345\276\204\346\200\273\345\222\214.cpp" "b/2224020014/chapter_7/\350\267\257\345\276\204\346\200\273\345\222\214.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..468530b3c18f90cb523e78bc3bc4cce547d9240c --- /dev/null +++ "b/2224020014/chapter_7/\350\267\257\345\276\204\346\200\273\345\222\214.cpp" @@ -0,0 +1,19 @@ + +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ + +bool hasPathSum(struct TreeNode* root, int targetSum){ + if (root == NULL) { + return false; + } + if (root->left == NULL && root->right == NULL) { + return targetSum == root->val; + } + return hasPathSum(root->left,targetSum-root->val)||hasPathSum(root->right,targetSum-root->val); +} diff --git "a/2224020014/chapter_8/\344\272\214\350\277\233\345\210\266\347\237\251\351\230\265\344\270\255\346\234\200\347\237\255\350\267\257\345\276\204.cpp" "b/2224020014/chapter_8/\344\272\214\350\277\233\345\210\266\347\237\251\351\230\265\344\270\255\346\234\200\347\237\255\350\267\257\345\276\204.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..e585e9731f1fcd2aa8b827e163401a825fcc994f --- /dev/null +++ "b/2224020014/chapter_8/\344\272\214\350\277\233\345\210\266\347\237\251\351\230\265\344\270\255\346\234\200\347\237\255\350\267\257\345\276\204.cpp" @@ -0,0 +1,59 @@ +typedef struct { /* 利用结构体记录坐标值和当前位置累计走的步数 */ + int x; + int y; + int cnt; +} Pos; + +int shortestPathBinaryMatrix(int** grid, int gridSize, int* gridColSize){ + int n = gridSize; + if(grid[0][0] == 1 || grid[n-1][n-1] == 1){ + return -1; + } + if(grid[0][0] == 0 && n == 1){ /* 前置的一些判断，是否直接结束 */ + return 1; + } + int direction[8][2] = { /* 维护8个方向的数组 */ + {0, 1}, + {1, 1}, + {1, 0}, + {-1, -1}, + {-1, 0}, + {-1, 1}, + {0, -1}, + {1, -1} + }; + Pos tmp; + Pos *queue = (Pos *)malloc(sizeof(Pos) * (n * n + 1)); /* 深度搜索标准队列形式 */ + int isVisited[n][n]; /* 搜索方法标准已访问标识 */ + for(int i=0; i= n || y < 0 || y >= n || isVisited[x][y]){ + continue; + } + isVisited[x][y] = 1; + queue[front].x = x; /* 如果可走，进行记录坐标值以及走的步数值 */ + queue[front].y = y; + queue[front].cnt = tmp.cnt + 1; + if(x == n-1 && y == n-1){ /* 优先到最后的一定是最短的 */ + return queue[front].cnt; + } + front++; + } + } + return -1; +} diff --git "a/2224020014/chapter_8/\345\210\244\346\226\255\344\272\214\345\210\206\345\233\276.cpp" "b/2224020014/chapter_8/\345\210\244\346\226\255\344\272\214\345\210\206\345\233\276.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..0d966d1e4fc0fbc3b17b118d33cae1323793cd6e --- /dev/null +++ "b/2224020014/chapter_8/\345\210\244\346\226\255\344\272\214\345\210\206\345\233\276.cpp" @@ -0,0 +1,44 @@ +int FindRoot(int set[], int pos){ + if(set[pos] < 0){ + return pos; + } + else{ + return set[pos] = FindRoot(set, set[pos]); + } +} + +void Union(int set[], int pos1, int pos2){ + int root1 = FindRoot(set, pos1), root2 = FindRoot(set, pos2); + if(root1 != root2){ + if(set[root1] > set[root2]){ + int tmp = root1; + root1 = root2; + root2 = tmp; + } + set[root1] += set[root2]; + set[root2] = root1; + } +} + +bool isBipartite(int** graph, int graphSize, int* graphColSize){ + bool ret = true; + int i, j; + int set[graphSize]; + for(i = 0; i < graphSize; i++){ + set[i] = -1; + } + for(i = 0; i < graphSize; i++){ + for(j = 1; j < graphColSize[i]; j++){ + Union(set, graph[i][0], graph[i][j]); + } + } + for(i = 0; i < graphSize; i++){ + if(graphColSize[i] > 0){ + if(FindRoot(set, i) == FindRoot(set, graph[i][0])){ + ret = false; + break; + } + } + } + return ret; +} diff --git "a/2224020014/chapter_8/\346\211\276\345\210\260\345\260\217\351\225\207\346\263\225\345\256\230.cpp" "b/2224020014/chapter_8/\346\211\276\345\210\260\345\260\217\351\225\207\346\263\225\345\256\230.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..a35d3c4af90551e6dd878d8e72c3a0dfb9b2c81b --- /dev/null +++ "b/2224020014/chapter_8/\346\211\276\345\210\260\345\260\217\351\225\207\346\263\225\345\256\230.cpp" @@ -0,0 +1,23 @@ +int findJudge(int N, int** trust, int trustSize, int* trustColSize){ + int *ret_val = (int *)calloc(N+1, sizeof(int)); + for (int i = 0; i < N+1; ++i) + ret_val[i] = 0; + + for (int i = 0; i < trustSize; ++i) + ++ret_val[trust[i][1]]; //记录被相信的次数 + + for (int i = 0; i < trustSize; ++i) + ret_val[trust[i][0]] = 0;//如果他相信别人，就对被相信的次数清零 + + int num = 0; + int top = -1; + for (int i = 1; i <= N; ++i) { + if (ret_val[i] == N-1) { //查找相信次数为N-1的人 + ++num; + top = i;//记录下标 + } + } + free(ret_val); + return (num > 1 ? -1 : top);//如果有大于1个法官，就为-1，否则就为该下标 +} + diff --git "a/2224020014/chapter_8/\350\257\276\347\250\213\350\241\250.cpp" "b/2224020014/chapter_8/\350\257\276\347\250\213\350\241\250.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..ee7d5dbc42fb2594f7b6e4475a4c8fefb1a17861 --- /dev/null +++ "b/2224020014/chapter_8/\350\257\276\347\250\213\350\241\250.cpp" @@ -0,0 +1,50 @@ +/** + * Note: The returned array must be malloced, assume caller calls free(). + */ +int* findOrder(int numCourses, int** prerequisites, int prerequisitesSize, int* prerequisitesColSize, int* returnSize){ + int a[3000] = {0}; + int i,j, t; + for (i = 0; i < numCourses; i++) { + a[i] = 0; + } + //记录所有点的入度 + for (i = 0; i < prerequisitesSize; i++) { + a[prerequisites[i][0]]++; + } + + //返回的数组 + int * b = (int *)malloc(sizeof(int) * numCourses); + int top = 0; + //入度为0的点放入返回数组中 + for (i = 0; i < numCourses; i++) { + if(0 == a[i]) { + b[top++] = i; + } + } + + //处理入度不为0的点 + for (i= 0; i< numCourses; i++) { + t = 0; + for (j = 0; j < prerequisitesSize; j++) { + if (prerequisites[j][0] != -1 && + a[prerequisites[j][0]] > 0 && + a[prerequisites[j][1]] == 0) { + a[prerequisites[j][0]]--; + if (0 == a[prerequisites[j][0]]) { + b[top++] = prerequisites[j][0]; + } + prerequisites[j][0] = -1; + } + t = 1; + } + if (t == 0) { + break; + } + } + if (numCourses != top) { + *returnSize = 0; + } else { + *returnSize = numCourses; + } + return b; +} diff --git "a/2224020014/chapter_8/\350\277\236\346\216\245\346\211\200\346\234\211\347\202\271\347\232\204\346\234\200\345\260\217\350\264\271\347\224\250.cpp" "b/2224020014/chapter_8/\350\277\236\346\216\245\346\211\200\346\234\211\347\202\271\347\232\204\346\234\200\345\260\217\350\264\271\347\224\250.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..0d337819643c8bae480678ece44fbe28ec70d0d1 --- /dev/null +++ "b/2224020014/chapter_8/\350\277\236\346\216\245\346\211\200\346\234\211\347\202\271\347\232\204\346\234\200\345\260\217\350\264\271\347\224\250.cpp" @@ -0,0 +1,41 @@ + +int res; + +int minCostConnectPoints(int** points, int pointsSize, int* pointsColSize){ + res = 0; + int n = pointsSize; + bool collected[n]; + int dist[n]; //dist[i]表示i号点到点集的最短距离 + int fee[n][n]; //fee[i][j] 表示i、j连接所需的费用 + memset(collected, 0, sizeof(collected)); + + for(int i = 0; i < n; i++){ + fee[i][i] = 0; + for(int j = i + 1; j < n; j++) + fee[i][j] = fee[j][i] = abs(points[i][0] - points[j][0]) + abs(points[i][1] - points[j][1]); + } + //从0号点开始,此时点集只有0 + collected[0] = true; + for(int i = 0; i < n; i++) dist[i] = fee[i][0]; + + while(1){ + int v = -1; + int mindist = INT_MAX; + for(int i = 0; i < n; i++){ + if(collected[i]) continue; + if(dist[i] < mindist){ + mindist = dist[i]; + v = i; + } + } + if(v == -1) break; + res += mindist; + collected[v] = true; + dist[v] = 0; + for(int i = 0; i < n; i++) //更新未收录顶点与收录点集的最短距离 + if(!collected[i] && dist[i] > fee[v][i]) + dist[i] = fee[v][i]; + } + return res; +} + diff --git "a/2224020014/chapter_9/\344\272\214\345\210\206\346\237\245\346\211\276.cpp" "b/2224020014/chapter_9/\344\272\214\345\210\206\346\237\245\346\211\276.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..fb484cb5943ef9d7c8ce268c1ea0d57bec8d1177 --- /dev/null +++ "b/2224020014/chapter_9/\344\272\214\345\210\206\346\237\245\346\211\276.cpp" @@ -0,0 +1,16 @@ +int search(int* nums, int numsSize, int target) { + int l = 0, r = numsSize - 1; + while (l <= r) { + int mid = (l + r) / 2; + if (nums[mid] < target) { + l = mid + 1; + } + else if (nums[mid] > target) { + r = mid - 1; + } + else { + return mid; + } + } + return -1; +} diff --git "a/2224020014/chapter_9/\344\272\214\345\217\211\346\216\222\345\272\217\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.cpp" "b/2224020014/chapter_9/\344\272\214\345\217\211\346\216\222\345\272\217\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..ba0ba8b0925b9bd656260a29a76f551b5b5ed946 --- /dev/null +++ "b/2224020014/chapter_9/\344\272\214\345\217\211\346\216\222\345\272\217\346\240\221\347\232\204\346\234\200\350\277\221\345\205\254\345\205\261\347\245\226\345\205\210.cpp" @@ -0,0 +1,25 @@ + +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * struct TreeNode *left; + * struct TreeNode *right; + * }; + */ + +struct TreeNode* lowestCommonAncestor(struct TreeNode* root, struct TreeNode* p, struct TreeNode* q) { + struct TreeNode* father=root; + while(root!=NULL){ + if(p->valval&&q->valval){ + father=father->left; + } + else if(p->val>father->val&&q->val>father->val){ + father=father->right; + } + else{ + break; + } + } + return father; +} diff --git "a/2224020014/chapter_9/\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.cpp" "b/2224020014/chapter_9/\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..ecd074ab75e84e5be6a2ef539919699c959ad3ca --- /dev/null +++ "b/2224020014/chapter_9/\345\257\273\346\211\276\344\270\244\344\270\252\346\255\243\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.cpp" @@ -0,0 +1,25 @@ +double findMedianSortedArrays(int* a1, int len1, int* a2, int len2){ + if(len1==0 && len2==0) return 0; + double sum=0; + int len=len1+len2; + int a[len], index1=0, index2=0; + while(index1left);//左子树 + if(leftHeight==-1){ + return -1; + } + int rightHeight=getHeight(root->right);//右子树 + if(rightHeight==-1){ + return -1; + } + //遍历中间的根节点 + if(fabs(leftHeight-rightHeight)>1){ + return -1; + }else{ + return 1+fmax(leftHeight,rightHeight); + } +} +bool isBalanced(struct TreeNode* root) { + return getHeight(root)==-1?false:true; +} \ No newline at end of file diff --git "a/2224020014/chapter_9/\347\254\254\344\270\211\345\244\247\347\232\204\346\225\260.cpp" "b/2224020014/chapter_9/\347\254\254\344\270\211\345\244\247\347\232\204\346\225\260.cpp" new file mode 100644 index 0000000000000000000000000000000000000000..c3a43b013536e79462cf20eac27d422ca94678c0 --- /dev/null +++ "b/2224020014/chapter_9/\347\254\254\344\270\211\345\244\247\347\232\204\346\225\260.cpp" @@ -0,0 +1,14 @@ +int cmp(const void *a, const void *b) { + return *(int*)a < *(int*)b; +} + +int thirdMax(int* nums, int numsSize){ + qsort(nums, numsSize, sizeof(nums[0]), cmp); + int diff = 0; + for (int i = 1; i < numsSize; i++) { + if (nums[i] != nums[i - 1] && ++diff == 2) { + return nums[i]; + } + } + return nums[0]; +}