Leetcode刷题

Leetcode题库

 

 

 

本博客用于记录在LeetCode网站上一些题的解答方法。具体实现方法纯属个人的一些解答，这些解答可能不是好的解答方法，记录在此，督促自己多学习多练习。

 

 

---

There are two sorted arrays nums1 and nums2 of size m and n respectively.

Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).

Example 1:

nums1 = [1, 3]
nums2 = [2]

The median is 2.0

Example 2:

nums1 = [1, 2]
nums2 = [3, 4]

The median is (2 + 3)/2 = 2.5

 double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
     int *nums = NULL;
     int totle_num = ;
     int mid_num = ;
     double mid = ;
     int i = , j = , k = ;

     totle_num = nums1Size + nums2Size;
     mid_num = totle_num >> ;

     nums = (int *)malloc(sizeof(int) * (totle_num));
     if (nums == NULL) {
         return -;
     }

     for (k = ; k < (mid_num + ); k++) {
         if (nums1Size ==  || i == nums1Size) {
             *(nums + k) = *(nums2 + j);
             j++;
         } else if (nums2Size ==  || j == nums2Size) {
             *(nums + k) = *(nums1 + i);
             i++;
         } else if (*(nums1 + i) <= *(nums2 + j)) {
             *(nums + k) = *(nums1 + i);
             i++;
         } else if (*(nums1 + i) > *(nums2 + j)){
             *(nums + k) = *(nums2 + j);
             j++;
         }
     }

     if (totle_num %  == ) {
         mid = (double)((*(nums + (mid_num - )) + *(nums + mid_num))) / (double);
     } else {
         mid = *(nums + mid_num);
     }
     free(nums);

     return mid;
 }

---

 

You are given two non-empty linked lists representing two non-negative integers. The digits are stored in reverse order and each of their nodes contain a single digit. Add the two numbers and return it as a linked list.

You may assume the two numbers do not contain any leading zero, except the number 0 itself.

Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)

Output: 7 -> 0 -> 8

 

 

 

 /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     struct ListNode *next;
  * };
  */
 struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
     struct ListNode *tail1 = NULL;
     struct ListNode *tail2 = NULL;
     struct ListNode *new = NULL;;
     int tmp = ;

     if (NULL == l1 || NULL == l2) {
         perror("list NULL!\n");
         return NULL;
     }

     for (tail1 = l1, tail2 = l2; (tail1->next != NULL) || (tail2->next != NULL);) {
         if ((tail1->next != NULL) && (tail2->next != NULL)) {
             tail1->val += tail2->val;
         } else if ((tail1->next != NULL) && (tail2->next == NULL)) {
             if (tail2 != NULL) {
                 tail1->val += tail2->val;
             }
         } else if ((tail1->next == NULL) && (tail2->next != NULL)) {
             if (tail1 != NULL) {
                 tail1->val += tail2->val;
                 new = (struct ListNode *)malloc(sizeof(struct ListNode));
                 if (NULL == new) {
                     perror("malloc failed!\n");
                     return NULL;
                 }
                 tail1->next = new;
                 new->val = ;
                 new->next = NULL;
             }
         }

         tail1->val += tmp;
         if (tail1->val < ) {
             tmp = ;
         } else {
             tmp = tail1->val / ;
             tail1->val %= ;
         }

         if (tail1->next != NULL) {
             tail1 = tail1->next;
         }
         if (tail2->next != NULL) {
             tail2 = tail2->next;
         } else {
             tail2->val = ;
         }
     }

     if (tail1 != NULL) {
         if (tail2 != NULL) {
             tail1->val += tail2->val;
         }
         tail1->val += tmp;
         if (tail1->val >= ) {
             tmp = tail1->val / ;
             tail1->val %= ;
             new = (struct ListNode *)malloc(sizeof(struct ListNode));
             if (NULL == new) {
                 perror("malloc failed!\n");
                 return NULL;
             }
             tail1->next = new;
             new->val = tmp;
             new->next = NULL;
         }
     }

     return l1;
 } 

 

 

---

 

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order.

You may assume no duplicates in the array.

Here are few examples.
[1,3,5,6], 5 → 2
[1,3,5,6], 2 → 1
[1,3,5,6], 7 → 4

[1,3,5,6], 0 → 0

 

 

 int searchInsert(int* nums, int numsSize, int target) {
     int *pNum = NULL;
     int i = ;

     if (NULL == nums) {
         return -;
     }

     if (numsSize <= ) {
         return -;
     }

     pNum = nums;

     for (i = ; i < numsSize; i++) {
         if (*(pNum + i) >= target) {
             return i;
         } else {
             if (i == numsSize - ) {
                 return numsSize;
             }
         }
     }

     return -;
 }

 

 

 

Merge two sorted linked lists and return it as a new list. The new list should be made by splicing together the nodes of the first two lists.

 

 

 /**
  * Definition for singly-linked list.
  * struct ListNode {
  *     int val;
  *     struct ListNode *next;
  * };
  */
 struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2) {
     struct ListNode *tail1 = NULL;
     struct ListNode *tail2 = NULL;
     struct ListNode *bak_node1 = NULL;
     struct ListNode *bak_node2 = NULL;
     struct ListNode *bak_node = NULL;

     if (l1 == NULL) {
         return l2;
     }

     if (l2 == NULL) {
         return l1;
     }

     // 找到第一个数据最小的链表，作为返回链表
     if (l1->val <= l2->val) {
         tail1 = l1;
         tail2 = l2;
     } else {
         tail1 = l2;
         tail2 = l1;
     }
     bak_node1 = tail1;
     bak_node2 = tail2;

     bak_node = tail1;

     while (tail2 != NULL) {
         while (tail1->val <= tail2->val) {
             if (tail1->next == NULL) {
                 tail1->next = tail2;
                 return bak_node;
             }
             bak_node1 = tail1;
             tail1 = tail1->next;
         }

         bak_node2 = tail2->next;
         tail2->next = tail1;
         bak_node1->next = tail2;
         bak_node1 = bak_node1->next;
         tail2 = bak_node2;
     }

     return bak_node;
 }

 

 

 

 bool isValid(char* s) {
     char *pString = NULL;
     int flag1 = , flag2 = , flag3 = ;
     int flag = ;

     if (s == NULL) {
         perror("String NULL!\n");
         return false;
     }

     pString = s;

     while (*pString != '\0') {
         if (*pString == '(') {
             flag1++;
             flag = ;
         } else if (*pString == ')') {
             if (flag ==  && flag1 != ) {
                 flag1--;
             } else if (flag == ) {
                 return false;
             }
         }

         if (*pString == '{') {
             flag2++;
             flag = ;
         } else if (*pString == '}') {
             if (flag ==  && flag2 != ) {
                 flag2--;
             } else if (flag == ) {
                 return false;
             }
         }

         if (*pString == '[') {
             flag3++;
             flag = ;
         } else if (*pString == ']') {
             if (flag ==  && flag3 != ) {
                 flag3--;
             } else if (flag == ) {
                 return false;
             }
         }

         if (flag1 + flag2 + flag3 > ) {
             return false;
         }
         pString++;
     }

     if ((flag1 != ) || (flag2 != ) || (flag3 != )) {
         return false;
     }

     return true;
 }

 

 

---

 

Determine whether an integer is a palindrome. Do this without extra space.

click to show spoilers.

Some hints:

Could negative integers be palindromes? (ie, -1)

If you are thinking of converting the integer to string, note the restriction of using extra space.

You could also try reversing an integer. However, if you have solved the problem "Reverse Integer", you know that the reversed integer might overflow. How would you handle such case?

There is a more generic way of solving this problem.

 

 bool isPalindrome(int x) {
     int data = ;
     int num = ;
     int count = ;
     int i = ;
     int tmp1 = , tmp2 = ;

     data = x;

     if (data < ) {
         return ;
     }

     while (data / ) {
         data /= ;
         tmp1 *= ;
         count++;
     }
     if (data != ) {
         count++;
         if (count != ) {
             tmp1 *= ;
         }
     }

     data = x;
     i = ;
     if (count == ) {
         if (data /  != data % ) {
             return ;
         }
         i++;
         tmp2 *= ;
     }
     while ((i < count / ) && ((data % tmp1 / (tmp1 / )) == (data % (tmp2 * ) / tmp2))) {
         tmp1 /= ;
         tmp2 *= ;
         i++;
     }
     if (i != count / ) {
         return ;
     }

     return ;
 }

 

 

---

 

Reverse digits of an integer.

Example1: x = 123, return 321
Example2: x = -123, return -321

click to show spoilers.

Have you thought about this?

Here are some good questions to ask before coding. Bonus points for you if you have already thought through this!

If the integer's last digit is 0, what should the output be? ie, cases such as 10, 100.

Did you notice that the reversed integer might overflow? Assume the input is a 32-bit integer, then the reverse of 1000000003 overflows. How should you handle such cases?

For the purpose of this problem, assume that your function returns 0 when the reversed integer overflows.

Note:

The input is assumed to be a 32-bit signed integer. Your function should return 0 when the reversed integer overflows.

 

 int reverse(int x) {
     int array[] = {  };
     int int_max = 0x7FFFFFFF;
     int int_min = 0x80000000;
     int data = ;
     int count = ;
     int num = ;
     int i = ;

     data = x;
     if ((int)data > (int)0x7FFFFFFF) {
         printf("data > 0x7FFFFFFF");
         return ;
     }   

     if ((int)data < (int)0x80000000) {
         printf("data < 0x80000000\n");
         return ;
     }   

     if (data == ) {
         printf("data == 0\n");
         return ;
     }   

     i = ;
     data = x;
     count = ;
     while ((data / ) != ) {
         array[i++] = data % ;
         data = data / ;
         count++;
     }
     if (data != ) {
         array[i] = data;
         data = ;
         count++;
     }

     if (count == ) {
         i = ;
         num = ;
         while (i < count) {
             if ((array[i] == int_max/num) || (array[i] == int_min/num)) {
                 i++;
                 int_max %= num;
                 int_min %= num;
                 num /= ;
             } else if ((array[i] < int_max/num) && (array[i] > int_min/num)) {
                 break;
             } else {
                 return ;
             }
         }
     }

     for (i = count - , num = ; i >= ; i--) {
         data += array[i] * num;
         num *= ;
     }
     if ((int)data > (int)0x7FFFFFFF) {
         printf("After: data > 0x7FFFFFFF");
         return ;
     }   

     if ((int)data < (int)0x80000000) {
         printf("After: data < 0x80000000\n");
         return ;
     }

     return data;
 }

---

 

Given an array of integers, return indices of the two numbers such that they add up to a specific target.

You may assume that each input would have exactly one solution, and you may not use the same element twice.

Example:

Given nums = [2, 7, 11, 15], target = 9,

Because nums[0] + nums[1] = 2 + 7 = 9,
return [0, 1].

 

 

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

     parray = (int *)malloc(sizeof(int) * );
     if (NULL == parray) {
         perror("malloc error!\n");
         return NULL;
     }

     for (i = ; i < numsSize; i++) {
         for (j = i + ; j < numsSize; j++) {
             if (nums[i] + nums[j] == target) {
                 *parray = i;
                 *(parray + ) = j;
                 break;
             }
         }
     }

     return parray;
 }