AI_lalaland的博客

char get_s[5000] = {0};                //设置全局变量用于函数之间传递字符串（注意C内存机制）char* longestPalindrome(char* s) {    int i, j, max, flag = 0;    int n = 0;    n = (int)strlen(s);    int le

(在线显示未通过的数据在我自己的IDE(Xcode)上运行结果正确，暂未找到原因，在此记录代码)int len = 0;                                      //记录优先队列长度int v = 0;                                        //记录体积int top = 0;        

int trap(int* height, int heightSize) {    int sum = 0;    int l = 0;    int r = heightSize - 1;    int l_top = height[0];    int r_top = height[heightSize - 1];    while(l         if(he

/** * Return an array of size *returnSize. * Note: The returned array must be malloced, assume caller calls free(). */int bsearchLeft(int array[],int low,int high,int target){    while(low

int searchInsert(int* nums, int numsSize, int target) {    //首部判断    if(numsSize == 0 || nums[0] >= target) return 0;    //主体判断    int i = 0;    while(i         if(nums[i] == target) retur

int b_search(int* array,int low,int high,int target){    while(low        int mid=(low+high)/2;        if(array[mid]>target)            high=mid-1;        else if(array[mid]        low=m

int cmp(const void *a, const void *b){    return *(int*)a - *(int*)b;}//返回nums数组中下标l到r之间（包含l和r）比flag大的最小的数的下标//如果没有比flag大的数则返回-1int min(int *nums, int l, int r, int flag){    int i, po

int removeElement(int* nums, int numsSize, int val) {    int i, j, flag = 0;    for(i = 0; i         if(nums[i] == val){            ++flag;            for(j = i + 1; nums[j] != val && j  

int removeDuplicates(int* nums, int numsSize) {    int i, j = 1;    if(numsSize == 0) return 0;    for(i = 1; i         if(nums[i] != nums[i - 1])            nums[j++] = nums[i];    }   

void rotate(int** matrix, int matrixRowSize, int matrixColSize) {    int i, j, tmp;    for(i = 0; i         for(j = 0; j             tmp = matrix[i][j];            matrix[i][j] = matrix[matr

int maxSubArray(int* nums, int numsSize) {    if(numsSize == 0) return 0;    if(numsSize == 1) return nums[0];    int max = nums[0];    int sum = nums[0];    for(int i = 1; i         if(su

利用动态方程和倒推法int minCostClimbingStairs(int* cost, int costSize) {    int i, f0, f1, f2;    f1 = f2 = 0;    for(i = costSize - 1; i >= 0; --i){        f0 = cost[i] + (f1         f2 = f1;   

int dominantIndex(int* nums, int numsSize) {    if(numsSize     int max = nums[0];    int smax = 0;    int i;    int flag = 0;    for(i = 1; i         if(nums[i]         if(nums[i] >=

int minPathSum(int** grid, int gridRowSize, int gridColSize) {    int i, j;    if(gridRowSize == 0 || gridColSize == 0) return 0;    else if(gridRowSize == 1){        int sum = 0;        for

int uniquePathsWithObstacles(int** obstacleGrid, int obstacleGridRowSize, int obstacleGridColSize) {    int i, j;    int m = obstacleGridRowSize - 1;    int n = obstacleGridColSize - 1;    if(

int uniquePaths(int m, int n) {    if(m     else if(m == 1 || n == 1) return 1;    else{        int a[m][n];        int i, j;        for(i = 0; i         for(j = 0; j         for(i = m

/** * Return an array of arrays. * Note: The returned array must be malloced, assume caller calls free(). */int** generateMatrix(int n) {    if(n == 0) return NULL;    int i, j, k, flag =

/** * Definition for an interval. * struct Interval { *     int start; *     int end; * }; *//** * Return an array of size *returnSize. * Note: The returned array must be malloced, a

/** * Note: The returned array must be malloced, assume caller calls free(). */int* spiralOrder(int** matrix, int matrixRowSize, int matrixColSize) {    if(matrixRowSize == 0 || matrixColSize

/** * Return an array of arrays of size *returnSize. * Note: The returned array must be malloced, assume caller calls free(). */int cmp (const void * a, const void * b){  return ( *(int*)a -

int cmp (const void * a, const void * b){  return ( *(int*)a - *(int*)b );}int threeSumClosest(int* nums, int numsSize, int target) {    int least, max, k, l, r, diff, new_diff, sum, res

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     struct ListNode *next; * }; */struct ListNode* reverseKGroup(struct ListNode* head, int k) {    //当链表为

（递归）/** * Definition for singly-linked list. * struct ListNode { *     int val; *     struct ListNode *next; * }; */struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode*

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     struct ListNode *next; * }; */struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {    int

char* longestCommonPrefix(char** strs, int strsSize) {    if(strsSize == 0)        return "";    int i, j;    char *out = strs[0];    for(i = 1; i     {        j = 0;        while(out[

（贪心算法）int min(int a, int b){    return a > b ? b : a;}int max(int a, int b){    return a > b ? a : b;}int maxArea(int* height, int heightSize) {    int i, j, n;    i = 0; 

bool isPalindrome(int x) {    if(x         return false;        long long num = (long long)x;       //使用long long型变量防止反转时越界    long long test = 0;        while(num)    {        test

int reverse(int x) {    int num = x;    int max = 0x7fffffff;    bool is_pos = (num > 0) ? true : false;    int getnum = 0;        if(!is_pos) num = -num;    while(num)    {        i

char getstr[1000];char* convert(char* s,int numRows) {    int i, j, k = 0;    int tmp;    int num = (int)strlen(s);                                  //记录总个数    //处理numRows=1的

#include #include #define MAX_CHARS_PERLINE 72int main(void){    int i, j, lines, max_times, num_word[26] = {0};    char ch;    lines = 0;    max_times = 0;

#include int up_down(int);int main(void){    int op_times, a, b;    scanf("%d", &op_times);    while(op_times--)    {        scanf("%d%d", &a, &b);

最基本的方法先按生序合并数组再查找；更好的方法是利用递归算法，如下记录。两个有序数组a、b中找到第k小的数字：比较a[k/2-1]和b[k/2-1],即分别有k/2个数字比被比较的这两个数字更小，如果a[k/2-1]a[k/2-1]比所有数中第k小的数还要小，从而可以把a数组中第一位到被该位全部剔除，再在新数组a'和b数组中递归查找第(k-k/2)小的数字。注意：递归过程中k/2可

（自己推导实现的并不标准的KMP算法）int lengthOfLongestSubstring(char* s) {    int length = 0;                    //记录最大长度    int this_len = 1;                   //记录当前取到的最大长度    int cmp_times =

/** * Definition for singly-linked list. * struct ListNode { *     int val; *     struct ListNode *next; * }; */struct ListNode* addTwoNumbers(structListNode* l1, struct

/** * Note: The returned array must be malloced, assume caller calls free(). */int* twoSum(int* nums, int numsSize, int target) {    int i, j;    int *get;    get = (int*)malloc(2 * sizeof

#include #define MIN(a, b)  (a int main(void){    int n, i;    double s, go_t, to_t, min_t;        while(scanf("%d", &n) && n !=0)    {        min_t =

#include #define SIZE 201#define INFARM(a, b, c, d)  a > 0 && b > 0 && c > 0 && d > 0 && a #define AREA(a, b)  a * a + b * bint i, j, x, y, length, p, q, max_area;char fa

#include #include #define MAX_CHARS 50#define MAX_STRINGS 100struct DNA{    char ch[MAX_CHARS];    int inversions;};int cmp(const void *a ,const void *b);

#include #include void graph_print(int);int main(void){    int i, times, oil;    oil = -1;    scanf("%d", &times);    for(i = 1; i     {        scan

思路：快排将数组升序排序，然后选定一个数，夹逼找到另两个数，依次遍历，注意边界条件的设定。/** * Return an array of arrays of size *returnSize. * Note: The returned array must be malloced, assume caller calls free(). *///快排算法void Qsor