leetcodo--Easy part

char* addBinary(char* a, char* b) {
    if (*a == '\0') return b;
    if (*b == '\0') return a;
    
    
    int index_a = strlen(a) - 1;
    int index_b = strlen(b) - 1;
    int carry = 0;
    int sum = 0;
    int index_ans = 0;
    char *ans = NULL;
    if (index_a >= index_b)
        ans = malloc(sizeof(char) * (index_a + 1 + 2)); //strlen(a) + 2, carry-bit and '\0'
    else
        ans = malloc(sizeof(char) * (index_b + 1 + 2));
    while (index_a >= 0 && index_b >= 0) {
        sum = (a[index_a] - '0') + (b[index_b] - '0') + carry;
        carry = sum/2;
        sum %= 2;
        ans[index_ans++] = sum + '0';
        --index_a;
        --index_b;
    }
    while (index_a >= 0) {
        sum = a[index_a] - '0' + carry;
        carry = sum / 2;
        sum %= 2;
        ans[index_ans++] = sum + '0';
        --index_a;
    }
    while (index_b >= 0) {
        sum = b[index_b] - '0' + carry;
        carry = sum / 2;
        sum %= 2;
        ans[index_ans++] = sum + '0';
        --index_b;
    }
    if (carry > 0) {
        ans[index_ans++] = carry + '0';
    }
    ans[index_ans] = '\0';
    return ans;
}

写得和add binary差不多，又臭又长

然后发现可以这么写

1 char* addBinary(char* a, char* b) {
 2     if (*a == '\0') return b;
 3     if (*b == '\0') return a;
 4     
 5     int len_a = strlen(a), len_b = strlen(b);
 6     char c = 0;
 7     int len_ans;
 8     char *ans = NULL;
 9 
10     len_ans = 2 + ((len_a > len_b) ? len_a : len_b);
11     ans = malloc(sizeof(char) * len_ans);
12     memset(ans, '0', sizeof(char) * len_ans);
13     ans[--len_ans] = '\0';
14     while (len_ans--) {
15         c += ((len_a > 0) ? (a[--len_a] - '0') : 0) + ((len_b > 0) ? (b[--len_b] - '0') : 0);
16         
17         ans[len_ans] = c % 2 + '0';
18         c /= 2;
19     }
20     if (ans[0] == '0') ans++;
21     return ans;
22 }

 

Climbing stairs

动态规划，爬到台阶n设为一个状态，state(n) 表示这个状态下有多少种爬法，如果一步只能走1或2阶楼梯，那么
现在的状态的前一个状态有两种可能，state(n-1)和state(n-2)，故有state(n) = state(n-1) + state(n-2)。

初始状态：state(1) = 1, state(2) = 2;

int climbStairs(int n) { //n2 means n 
    int n2 = 1;
    int n1 = 2;
    int temp;
    if (n == 1) return n2;
    if (n == 2) return n1;
    
    for (int i = 3; i <= n; i++) {
        temp = n1 + n2;
        n2 = n1;
        n1 = temp;
    }
    return n1;
}

 

88.Merge Sorted Array

已知范围可以从后边开始。。

void merge(int* nums1, int m, int* nums2, int n) {
     int i1 = m - 1;
     int i2 = n -1;
     while (i1 >= 0 && i2 >= 0)
     {
         if (nums1[i1] > nums2[i2])
         {
             nums1[i1+i2+1] = nums1[i1];
             i1--;
         }
         else{
             nums1[i1+i2+1] = nums2[i2];
             i2--;
         }
     }
     while(i2 >= 0)
     {
          nums1[i1+i2+1] = nums2[i2];
          i2--;
     }
}

 

338.Counting Bits

本来想的是 any i in [0,num] 的解法，后来发现都已经用一个数组保存子问题了。。。也是一种DP吧

23ms

int* countBits(int num, int* returnSize) {
    num++;
    *returnSize = num;
    int *bitCountArray = malloc(sizeof(int) * (*returnSize));
    bitCountArray[0] = 0;
    for (int i = 1; i < num; i++) {
        bitCountArray[i] = i&1 ? (bitCountArray[i>>1] + 1) : bitCountArray[i>>1]; 
    }
    return bitCountArray;
}

原来的解法

int* countBits(int num, int* returnSize) {
    num++;
    *returnSize = num;
    int *bitCountArray = malloc(sizeof(int) * (*returnSize));
    bitCountArray[0] = 0;
    for (int i = 1; i < num; i++) {
        bitCountArray[i] = pop(i);
    }
    return bitCountArray;
}
inline int pop(unsigned x) {
    x = (x & 0x55555555) + ((x >> 1) & 0x55555555);
    x = (x & 0x33333333) + ((x >> 2) & 0x33333333);
    x = (x & 0x0f0f0f0f) + ((x >> 4) & 0x0f0f0f0f);
    x = (x & 0x00ff00ff) + ((x >> 8) & 0x00ff00ff);
    x = (x & 0x0000ffff) + ((x >> 16) & 0x0000ffff);
    return x;
}

 

 

 

Best time to Buy and Sell

买卖石头是有顺序的，最简单的方法超时：

int maxProfit(int* prices, int pricesSize) {
    int max_diff = 0;
    for (int i = 0; i < pricesSize; i++) {
        int diff = find_diff(i, pricesSize, prices);
        if (diff > max_diff) 
            max_diff = diff;
    }
    return max_diff;
}

int find_diff(int low, int high, int *prices) {
    int max = prices[low];
    for (int i = low; i < high; i++) {
        if (prices[i] > max)
            max = prices[i];
    }
    return max-prices[low];
}

可以换一个思路，虽然只能买卖一次，但是可以通过连续买卖模拟出最佳操作，因为profile = buy:day[i] + sell:day[i+1] = day[i+1] - day[i]，

故如果在第k天存在最佳卖出的价格，其间存在关系 ((i+1) - i) + ((i+2) - (i+1)) +...+(k - (k-1)) = k - i ，

整个过程不用回退。（一句话解释：今天买明天卖，明天卖的可以在明天接着买回来）

所以可以写成一个online的算法（中途结束会给出近似解，有点像另一道最长子序的题）

int maxProfit(int price[], int n)
{
    int ret = 0, past = 0;
    for(int i = 1; i < n; i++)
    {
        ret += price[i] - price[i-1];
        if(ret < 0) ret = 0;
        if(ret > past) past = ret;
    }
    return past;
}

 

1. Two Sum

用hash

typedef struct linkList{
    int data;
    int index_nums;
    struct linkList *ptr;
}linkList;

void hashInsert(int index, int val, int hashSize, linkList *hashT){ //这是一个链表实现的哈希表，参数int i保存hash节点在原来数组中下标
    int tmp_val;
    tmp_val = (val < 0)? -val : val;
    linkList *tmp_ptr = &hashT[tmp_val % hashSize];
    while(tmp_ptr->ptr) tmp_ptr = tmp_ptr->ptr;
    tmp_ptr->ptr = (linkList *)calloc(1, sizeof(linkList));
    tmp_ptr->ptr->data = val;
    tmp_ptr->ptr->index_nums = index;
}

_Bool hashSearch(int exist_index, int val, int *return_index, int hashSize, linkList *hashT){ 
    int tmp_val;
    (val < 0) ? (tmp_val = (-1) * val) : (tmp_val = val);
    linkList *tmp_ptr = &hashT[tmp_val % hashSize];
    tmp_ptr = tmp_ptr->ptr;
    while(tmp_ptr) {
        if((tmp_ptr->data == val) && (tmp_ptr->index_nums != exist_index)){ //这个数不是其
            *return_index = tmp_ptr->index_nums;
            return true;
        }
        tmp_ptr = tmp_ptr->ptr;
    }
    return false;
}

int* twoSum(int* nums, int numsSize, int target) {
        linkList *hashT;
    int i, *ans, val, index, hashTSize =  numsSize;

    hashT = (linkList *)calloc(hashTSize, sizeof(linkList));
    ans = (int *)calloc(2, sizeof(int));
    for(i = 0; i < numsSize; i++) hashInsert(i, nums[i], hashTSize, hashT);
    for(i = 0; i < numsSize; i++) {
        val = target - nums[i];
        if(hashSearch(i, val, &index, hashTSize, hashT)){
            ans[0] = i;
            ans[1] = index;
            break;
        }
    }
    return ans;
}

 

6. ZigZag Conversion

题目给出的排版不清楚，看文字说明就好

因为读的顺序是 第0行->第1行->...->第nRows-1行，所以可以根据这一点创建一个大小为nRows的二维数组，[[row0],[row1],...,]，分别保存每一行的数据。

然后遍历字符串，将每个字符放入它应在的数组，遍历后再把二维数组归为一个数组。

char *convert(char *s, int nRows) {
    if (nRows <= 1 || s == NULL) return s;
    
    int row = 0;
    int step = 1;
    
    char **rows = malloc(nRows * sizeof(char *));
    for (int i = 0; i < nRows; i++) {
        rows[i] = calloc(300, sizeof(char));
    }
    for (int i = 0; i < strlen(s); i++) {
        if (row == nRows-1) step = -1;
        if (row == 0) step = 1;
        strncat(rows[row], s+i, 1);
        row += step;
    }
    
    char *ans = calloc(300 * nRows, sizeof(char));
    
    for (int i = 0; i < nRows; i++) {
        strcat(ans, rows[i]);
    }
    
    for (int i = 0; i < nRows; i++) {
        free(rows[i]);
    }
    free(rows);
    
    return ans;
}

 

还有一种解法就是根据每一行的数的下标关系将其放到对应的位置。

在内部循环中，每次放入两个同一行的数（如果不是第一行或者最后一行，则每次只放入一个数）

char* convert(char* s, int numRows) {
    int n=strlen(s);
    char* a = malloc(sizeof(char) * (n+1));
    int k=0;
    if(numRows==1 || n<=numRows)return s;
    for(int i=0;i<numRows;i++)
    {
        for(int j=i;j<n;j+=2*(numRows-1))
        {
            a[k++]=s[j];
            if(i!=0 && i!=numRows-1)
            {
              int t=j+2*(numRows-1)-2*i;
              if(t<n)
              a[k++]=s[t];
            }
        }
    }
   a[k]='\0';  
   return a;
}

 

 

7. Reverse Integer

主要考虑一下乘法溢出，这里用的csapp里的tmul_ok

int reverse(int x) {
    int unit;
    int reverse_x = 0;
    int positive_x = x;
    while(positive_x/10 != 0)
    {
        unit = positive_x % 10;
        reverse_x = reverse_x*10 + unit;
        positive_x /= 10;
    }
    if(!tmul_ok(reverse_x, 10))
        return 0;
    reverse_x = reverse_x*10 + positive_x;
    
    return reverse_x;
}
int tmul_ok(int x, int y)
{
    return !x || x*y/x == y;
}

 

8. String to Integer (atoi)

主要考虑加法溢出、乘法溢出　　

int myAtoi(char* str) {  
    int i, n, sign;
    
    for(i = 0; isspace(str[i]); i++)
        ;
    sign = ((str[i] == '-') ? -1 : 1);
    if(str[i] == '+' || str[i] == '-')
          i++;
    for(n = 0; isdigit(str[i]); i++){
        if(!tmul_ok(10, n)){
            return sign==1 ? 2147483647 : -2147483648;
        }
        n = 10 * n;
        if(!tadd_ok(sign*n, sign*(str[i]-'0')))
            return sign==1 ? 2147483647 : 2147483648;
        n = n + str[i] - '0';
    }
    return sign * n;
}
int tmul_ok(int x, int y)
{
    return x && x*y/x == y;
}
int tadd_ok(int x, int y)
{
    int sum = x + y;
    int neg_over = x < 0 && y < 0 && sum >= 0;
    int pos_over = x >= 0 && y >= 0 && sum < 0;
    return !neg_over && !pos_over;
}

 

9. Palindrome Number

bool isPalindrome(int x) {
    if (x < 0) return false;
    int y=0;
    int xx=x;
    while (xx>0) {
        y = y*10 + xx%10;
        xx/=10;
    }
    return (y == x);
}

 

14. Longest Common Prefix

一个二维数组strs，有strsSize个字符指针

如果每次都完整地比较两个相邻的字符串，那么当遇到不相等的字符时就会跳出，忽略了后面可能更短的部分，比如["abab","aba",""]所以每次必须比较同一个位置上所有字符串的字符。

char* longestCommonPrefix(char** strs, int strsSize) {
    int i,j;
    char* s="";
    if(strsSize==0) return s;
    for(i = 1; i < strsSize; i++) 
    for (j = 0; j < strlen(*strs); j++)
      
        if(*(*(strs+i)+j)!=*(*strs+j)) goto EXIT; 
   EXIT: 
    if(j==0) return s;
    *(*strs+j)='\0';
  return *strs;
}

 

19. Remove Nth Node From End of List

可以设置两个节点，倒数第n个也就是其中一个节点比另一个节点“慢”n个节点

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
    struct ListNode *scout = head, *target = head;
    int count = 0;
    while(scout){
        scout = scout->next;
        if(count > n) target = target->next;
        count++;
    }
    if(count > n) target->next = target->next->next;
    else head = head->next;
    return head;
}

 

20. Valid Parentheses

经典的括号匹配问题

bool isValid(char* s)
{
    char a[10000];
    int i, j, k, ct1=0;
    for(i = 0; i < strlen(s); i++)
    {
        switch(s[i])
        {
            case '(': a[ct1]='(';ct1++;break;
            case '{': a[ct1]='{';ct1++;break;
            case '[': a[ct1]='[';ct1++;break;
            case ')': if(a[ct1-1]=='(')ct1--;else return false;break;
            case '}': if(a[ct1-1]=='{')ct1--;else return false;break;
            case ']': if(a[ct1-1]=='[')ct1--;else return false;break;
        }
    }
    if(ct1==0)
        return true;
    else
        return false;
}

 

21. Merge Two Sorted Lists

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
    struct ListNode* dummy = malloc(sizeof(struct ListNode));
    struct ListNode* ptr = dummy;
    dummy->next = NULL;
    if (l1 == NULL)
        return l2;
    else if (l2 == NULL)
        return l1;
    while (l1 != NULL && l2 != NULL) {
        if (l1->val > l2->val) {
            ptr->next = l2;
            l2 = l2->next;
        }
        else {
            ptr->next = l1;
            l1 = l1->next;
        }
        ptr = ptr->next;
    }
    if (l1 == NULL) 
        ptr->next = l2;
    else if(l2 == NULL)
        ptr->next = l1;
    ptr = dummy->next;
    free(dummy);
    return ptr;
}

 

24. Swap Nodes in Pairs

基本的链表变换操作

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     struct ListNode *next;
 * };
 */
struct ListNode* swapPairs(struct ListNode* head) {
    if(head == NULL)
        return head;
    if(head->next == NULL)
        return head;
    struct ListNode *ptr_pre;
    struct ListNode *ptr;
    struct ListNode *ptr_next;
    struct ListNode *dummy = malloc(sizeof(struct ListNode));
    ptr = head;
    ptr_next = head->next;
    ptr_pre = dummy;
    ptr_pre->next = ptr;
    while(ptr_next){
        ptr->next = ptr_next->next;
        ptr_next->next = ptr;
        ptr_pre->next = ptr_next;
        
        ptr_pre = ptr;
        if(ptr->next)
            ptr = ptr->next;
        ptr_next = ptr->next;
    }
    head = dummy->next;
    free(dummy);
    return head;
}

 

26. Remove Duplicates from Sorted Array

设置一个index指向最后一个未重复的元素

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

 

27. Remove Element

不必真的去除val，因为不能申请额外的空间，只要设置一个普通的index i一直前进，然后再设置一个指向除了val以外的数的index

int removeElement(int* nums, int numsSize, int val) {
    int i = 0;
    int j = 0;
    while (i < numsSize) {
        if (nums[i] == val) {
            i++;
            continue;
        }
        else {
            nums[j] = nums[i];
            i++;
            j++;
            continue;
        }
    }
    return j;
}

 

28. Implement strStr()

暴力搜索，参考K&R的实现

int strStr(char *haystack, char *needle)
{
    int i, j, k;
    if(needle == NULL) return 0;
    for(i = 0; haystack[i] != '\0'; i++){
        for(j = i, k = 0; needle[k] != '\0' && needle[k] == haystack[j]; j++, k++)
            ;
        if(k > 0 && needle[k] == '\0')
            return i;
    }
    return -1;
}

亦可使用KMP