比较早写的,有些题目可能需要进行适配
//10.正则表达式:Implement regular expression matching with support for '.' and '*'.
//'.' Matches any single character.
//'*' Matches zero or more of the preceding element.
//The matching should cover the entire input string (not partial).
//动态规划思想,即当前匹配的结果是建立在上一步匹配结果的基础上,与递归有点相似,却使用数组去存放匹配结果。
//bool isMatch(char* s, char* p) {
// int len_s = strlen(s),len_p = strlen(p),count=0;
// bool **dp = (bool **)malloc(sizeof(bool *)*(len_s+1));//len_s+1行
// for (int i = 0; i < len_s+1; i++)
// {
// dp[i] = (bool *)malloc(sizeof(bool)*(len_p+1)); //每行len_p+1列
// memset(dp[i],0,sizeof(dp[i]));
// }
// dp[0][0] = true;//d[i][j]表示串s中前i个与p中前j个匹配的结果,其中认为dp[0][0]是true
// for (int i = 0; i <= len_s; i++)
// {
// for (int j = 1; j <= len_p; j++)
// {
// if (*(p+j-1)!='*')
// {
// dp[i][j] = i>0 && dp[i-1][j-1] && (*(s+i-1)==*(p+j-1)||*(p+j-1)=='.');//如果*(p+j-1)!='*'并且*(s+i-1)==*(p+j-1)||*(p+j-1)=='.',那么dp[i][j]=dp[i-1][j-1]
// }else
// {
// if (i==0 || (*(s+i-1)!=*(p+j-2) && *(p+j-2)!='.'))//如果*(p+j-1)=='*',匹配dp[i][j] = dp[i][j-2]的两种情况,一个是i==0,另外一个类似于aab匹配aabc*
// {
// dp[i][j] = dp[i][j-2];
// }else
// {
// dp[i][j] = dp[i-1][j] || dp[i][j-1] || (j>1 && dp[i][j-2]);//dp[i][j-1]表示*号之前的符号用不止一次,dp[i][j-2]表示不用*号之前的符号,dp[i-1][j]表示串s中回退一个符号进行匹配
// }
//
// }
// }
// }
// return dp[len_s][len_p];
//}
//9.数字是否为回文形式:比如1221,23123等。Determine whether an integer is a palindrome. Do this without extra space.
//bool isPalindrome(int x) {
// int rev=0;
// if (x<0 || (x%10==0 && x!=0))
// {
// return false;
// }
// while (x>rev)
// {
// rev = rev*10 + x%10; //算法核心,即倒过来
// x=x/10;
// if (x<10)
// {
// break;
// }
// }
// return (x==rev || x==rev/10);
//}
//8.Implement atoi to convert a string to an integer.即实现字符串转换成数字
//需要考虑各种不同的情况,比如空格,字母,正负号,溢出等情况
//int myAtoi(char* str) {
// int i=0,count_p=0,count_n=0,index_other=0,index_num=0; //count_p正号个数,count_n负号个数,index_other非数字指标,index_num数字指标
// double result=0; //结果,由于需要考虑溢出,因此需要64位存放
// while (*(str+i)!=0)
// {
// if(!index_other){
// if (*(str+i)>=48 && *(str+i)<=57) //数字对应的ascii码
// {
// result = result*10+*(str+i)-48;
// index_num = 1;
// }else if(*(str+i)==45){ //负号
// count_n++;
// index_num = 1;
// if (*(str+i+1)<48 || *(str+i+1)>57)
// {
// return 0;
// }
// }else if(*(str+i)==43){ //正号
// count_p++;
// index_num = 1;
// if (*(str+i+1)<48 || *(str+i+1)>57)
// {
// return 0;
// }
// }else if(*(str+i)==32) //空格处理
// {
// if (index_num)
// {
// break;
// }else
// {
// continue; //空格前如果没有数字,则继续,作用为忽略多个空格
// }
// }else
// {
// index_other=1;
// }
// }else{ //非正负号,非数字,非空格的处理
// break;
// }
// i++;
// }
// if(count_n>count_p){
// result = -result;
// }else if(result < double(-2147483648)){ //处理溢出情况,vs好像不能运行,但是leetcode上可以
// result = -2147483648;
// }else if(result > double(2147483647)){ //处理溢出情况,vs好像不能运行,但是leetcode上可以
// result = 2147483647;
// }
// return (int)result;
//}
//7.反向输出数字Reverse digits of an integer,Your function should return 0 when the reversed integer overflows
//Example1: x = 123, return 321
//Example2: x = -123, return -321
//int reverse(int x) {
// int rev=0,tmp=0,rev_tmp=0;
// while (x!=0)
// {
// tmp = x%10;
// rev_tmp = rev*10 +tmp; //算法核心,即倒过来
// if ((rev_tmp-tmp)/10!=rev) //计算溢出,即不满足上述等式
// {
// return 0;
// }
// rev = rev_tmp;
// x=x/10;
// }
// return rev;
//}
//6. 字母之字型排列,然后再输出,如下
//The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows
//P A H N
//A P L S I I G
//Y I R
//And then read line by line: "PAHNAPLSIIGYIR"
//char* convert(char* s, int numRows) {
// int len = strlen(s);
// int col = len+1; //取最大情况再加一列
// char *s_result = (char *)malloc(sizeof(char)*len+1);
// char **tmp = (char **)malloc(sizeof(char *)*numRows);//numRows行,tmp矩阵是用于存放排列成之字形整个图形,无字母处用'\0'表示;
// for (int i = 0; i < numRows; i++)
// {
// tmp[i] = (char *)malloc(sizeof(char)*col); //col列
//
// }
// for (int i = 0; i < col; i++)
// {
// for (int j = 0; j < numRows; j++)
// {
// tmp[j][i] = 0;
// }
// }
// int count=0,i_row=0,j_col=0;
// int len_tmp = len-1,numRows_tmp = numRows-1;
// if (!numRows_tmp)
// {
// return s;
// }else
// {
// while (count<=len_tmp)
// {
// if (j_col%numRows_tmp==0) //类似第一列,需要排满所有字母
// {
// for (int i = 0; i <numRows && count<len; i++)
// {
// tmp[i][j_col] = s[count];
// count++;
//
// }
// j_col++;
// }else //其他列,每列仅有一个字母,行列号满足[numRows_tmp-j_col%numRows_tmp][j_col]
// {
// if (count<len)
// {
// tmp[numRows_tmp-j_col%numRows_tmp][j_col] = s[count];
// count++;
// j_col++;
// }
//
// }
// }
// int k = 0;
// for (int i = 0; i < numRows; i++) //将二维数组转换成一维并输出,其中为'\0'忽略
// {
// for (int j = 0; j < col; j++)
// {
// // printf("%c",tmp[i][j]);
// if (tmp[i][j]!='\0')
// {
// s_result[k] = tmp[i][j];
// k++;
// }
// }
// // printf("\n");
// }
// s_result[k] = '\0';
// return s_result;
// }
//}
//5.即求一段字符串里面的最大回文子串
//Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.
//Input: "babad"
//Output: "bab"
//Note: "aba" is also a valid answer.
//Input: "cbbd"
//Output: "bb"
//char* longestPalindrome(char* s) {
// int Length1 = strlen(s)+1;
// int index; //用于标识最大回文子串的起始位置
// int Length = Length1-1;
// int count=0; //最大回文子串的长度
// if (Length==1) //如果字符串只有一个字符,则最大回文子串即该字符串本身
// {
// return s;
// }else
// {
// for (int i = 0; i < Length; i++)
// {
// int count_before1=0,count_before2=0; //用于存放本次循环中,bab模式和bb模式的回文子串长度
// if(i>0 && s[i-1]==s[i+1]){ //统计bab模式下,最大回文子串长度
// count_before1=count_before1+3;
// for (int j = 1; j < Length-1-i; j++) //将bab模式进行扩展(如cbabc),统计该次循环中最大回文子串长度
// {
// if ((i-j)>=1 && s[i-j-1]==s[i+j+1])
// {
// count_before1=count_before1+2;
// }else
// {
// break;
// }
// }
// if (count<count_before1) //如果该次长度大于原先最大回文子串长度,则记录长度与位置
// {
// count = count_before1;
// index = i-count_before1/2; //index表示回文长度的起始位置,是以位置i为对称的
// }
// }
// if (s[i]==s[i+1]) //统计bb模式下,最大回文子串长度
// {
// if(!i){ //统计从第一个字符开始的bb模式最大回文子路,!i即表示i==0
// count_before2=count_before2+2;
// for (int j = 2; j < Length; j++) //将bb模式进行扩展(如bbbb),统计该次循环中最大回文子串长度
// {
// if (s[0]==s[j])
// {
// count_before2++;
// }else
// {
// break;
// }
// }
// if (count<count_before2)
// {
// count = count_before2;
// index = 0;
// }
// }else
// {
// count_before2=count_before2+2;
// for (int j = 1; j < Length-1-i; j++) //统计cbbc模式最大回文子路,即s[i-j]==s[i+j+1]
// {
// if (i>=j && s[i-j]==s[i+j+1])
// {
// count_before2=count_before2+2;
// }else
// {
// break;
// }
// }
// if (count<count_before2)
// {
// count = count_before2;
// index = i-count_before2/2+1;
// }
// }
// }
//
// }
//
// if (count==0) //count==0表示整个字符串均没有满足bb模式或者bab模式的回文,则认为最大回文长度为1,即单个字符,返回值第一个字符
// {
// char *store = (char *)malloc(sizeof(char)*(count+2));
// store[0]=s[0];
// store[1]='\0';
// return store;
// }else
// {
// char *store = (char *)malloc(sizeof(char)*(count+1)); //count大于0表示存在长度大于1的回文,则根据index与count进行截取
// for (int i = 0; i < count; i++)
// {
// store[i]=s[index+i];
// }
// store[count]='\0'; //c语言的字符串最终以'\0'结尾
// return store;
// }
//
// }
//}
//4.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)).
//nums1 = [1, 2]
//nums2 = [3, 4]
//The median is (2 + 3)/2 = 2.5
//nums1 = [1, 3]
//nums2 = [2]
//The median is 2.0
//解题思路如下所示:
// left_part | right_part
//A[0], A[1], ..., A[i-1] | A[i], A[i+1], ..., A[m-1]
//B[0], B[1], ..., B[j-1] | B[j], B[j+1], ..., B[n-1]
//关键是满足B[j-1]<=A[i]以及A[i-1]<=B[j],并且左右两边元素个数一样
//double findMedianSortedArrays(int* nums1, int nums1Size, int* nums2, int nums2Size) {
// int i,j,i_min,i_max;
// if (nums1Size>nums2Size) //交换数组,需要保证nums1长度比较小
// {
// int *temp=nums1;
// nums1 = nums2;
// nums2 = temp;
// int tmp = nums1Size;
// nums1Size = nums2Size;
// nums2Size = tmp;
// }
// i_min=0;
// i_max=nums1Size;
// while (i_min<=i_max) //以下进行二分法查找
// {
// i = (i_min+i_max)/2;
// j = (nums1Size+nums2Size+1)/2-i;
// if(i<nums1Size && nums2[j-1]>nums1[i]) //需要找到满足nums2[j-1]<=nums1[i] nums1[i-1]<=nums2[j],才行
// {
// i_min = i+1;
// }else if(i>0 && nums1[i-1]>nums2[j]) //需要找到满足nums2[j-1]<=nums1[i] nums1[i-1]<=nums2[j],才行
// {
// i_max = i-1;
// }else //以下是满足nums2[j-1]<=nums1[i] nums1[i-1]<=nums2[j]之后的处理过程以及一些边界值的处理
// {
// int max_left=0,min_right=0;
// if (i==0)
// {max_left = nums2[j-1];} //i为0,表示nums1只有一个元素,并且是最大的,nums2的前(nums1Size+nums2Size+1)/2-i个元素放左边
// else if (j==0)
// {max_left = nums1[i-1];} //j为0,表示nums2只有一个元素,并且是最大的,nums1的前(nums1Size+nums2Size+1)/2-i个元素放左边
// else if(nums2[j-1]>nums1[i-1]) //i,j不为0,则左边最大的元素是max(nums2[j-1],nums1[i-1])
// {max_left = nums2[j-1];}
// else
// {max_left = nums1[i-1];}
// if ((nums1Size+nums2Size)%2) //如果总的元素个数为奇数,那么中间数即max_left
// {
// return max_left;
// }
// if (i==nums1Size) //i为nums1Size,表示所有的nums1都在左边,因此右边最小的元素为nums2[j]
// {min_right = nums2[j];}
// else if (j==nums2Size) //j为nums2Size,表示所有的nums2都在左边,因此右边最小的元素为nums1[i]
// {min_right = nums1[i];}
// else if(nums2[j]<nums1[i]) //i,j不为各自的最大值,则右边最大的元素是min(nums2[j],nums1[i])
// {min_right = nums2[j];}
// else
// {min_right = nums1[i];}
// return (max_left+min_right)/2.0;
// }
//
// }
//
//}
//3.Given a string, find the length of the longest substring without repeating characters.
//Given "abcabcbb", the answer is 3.
//Given "", the answer is 0.
//Given "bbbbb", the answer is 1.
//Given "dvdf", the answer is 3.
//Given "pwwkew", the answer is 3
//int lengthOfLongestSubstring(char* s) {
// int count=0,max,jump=0;
// while (*(s+count)!='\0')
// {
// count++;
// }
// int *tmp = (int*)malloc(sizeof(int)*count);
// if (count==0) //需要考虑空字符的情况
// {
// *tmp = max = 0;
// }else
// {
// *tmp = max = 1;
// }
//
// for (int i = 1; i < count; i++) //取出第i个,然后从0到i-1个与第i个进行比较,看有没有相同的
// {
// *(tmp+i)=1;
// for (int k = jump; k < i; k++)
// {
// if (*(s+k)!=*(s+i)) //如果不相同,那么继续进行比较,并且值加1
// {
// *(tmp+i) = *(tmp+i)+1;
// }else
// {
// *(tmp+i) = 1; //如果有发生重复,则计数变为1
// jump = k+1; //如果有发生重复,则从第一个重复之后的那个字母开始接着比
// }
// }
// if (*(tmp+i)>max)
// {
// max = *(tmp+i);
// }
// }
// return max;
//}
//2.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.
//Input: (2 -> 4 -> 3) + (5 -> 6 -> 4)
//Output: 7 -> 0 -> 8
//struct ListNode {
// int val;
// struct ListNode *next;
//};
//struct ListNode *creat(){ //产生链表,以-99为标识表示结尾
// struct ListNode *q,*p,*head;
// q = (struct ListNode *)malloc(sizeof(struct ListNode));
// head = q;
// p = q;
// scanf("%d",&q->val);
// while (q->val!=-99)
// {
// q = (struct ListNode *)malloc(sizeof(struct ListNode));
// p->next = q;
// p = q;
// scanf("%d",&q->val);
// }
// q->next = NULL;
// return head;
//}
//struct ListNode* addTwoNumbers(struct ListNode* l1, struct ListNode* l2) {
// struct ListNode *resultp,*resultq,*result_head;
// result_head = resultp = resultq = (struct ListNode *)malloc(sizeof(struct ListNode));
// int carry=0;
// while (l1->next!=NULL && l2->next!=NULL) //如果都有数据,则进行相加运算,考虑进位
// {
// resultq->val = l1->val+l2->val+carry;
// carry = resultq->val/10;
// resultq->val = resultq->val%10;
// resultp = resultq;
// resultq = (struct ListNode *)malloc(sizeof(struct ListNode));
// resultp->next = resultq;
// l1 = l1->next;
// l2 = l2->next;
// }
// if (l1->next==NULL && l2->next==NULL) //如果都无数据,则返回,考虑进位
// {
// if(carry){
// resultq->val = carry;
// resultq->next = NULL;
// resultp->next = resultq;
// }else
// {
// resultq = NULL;
// resultp->next = resultq;
// }
// return result_head;
// }else if(l1->next==NULL) //如果l1无数据,则继续进行相加运算(仅l2与进位)
// {
// while (l2->next!=NULL)
// {
// resultq->val = l2->val+carry;
// carry = resultq->val/10;
// resultq->val = resultq->val%10;
// resultp = resultq;
// resultq = (struct ListNode *)malloc(sizeof(struct ListNode));
// resultp->next = resultq;
// l2 = l2->next;
// }
// }else if(l2->next==NULL){ //如果l2无数据,则继续进行相加运算(仅l1与进位)
// while (l1->next!=NULL)
// {
// resultq->val = l1->val+carry;
// carry = resultq->val/10;
// resultq->val = resultq->val%10;
// resultp = resultq;
// resultq = (struct ListNode *)malloc(sizeof(struct ListNode));
// resultp->next = resultq;
// l1 = l1->next;
// }
// }
// if(carry){ //加完之后如果还有进位,则需要添加一位,由于前面while循环已经有新生成节点了,所以此处不需要再生成
// resultq->val = carry;
// resultq->next = NULL;
// resultp->next = resultq;
// }else //加完之后如果没有进位,则无需添加一位,由于前面while循环已经有新生成节点了,所以此处需要将节点地址置0
// {
// resultq = NULL;
// resultp->next = resultq;
// }
// return result_head;
//}
//1.twoSum:Given an array of integers, return indices of the two numbers such that they add up to a specific target.
//Given nums = [2, 7, 11, 15], target = 9,
//Because nums[0] + nums[1] = 2 + 7 = 9,
//return [0, 1].
//int* twoSum(int* nums, int numsSize, int target) {
// int *p;
// p = (int*)malloc(sizeof(int) * numsSize);
// for(int i=0;i<numsSize;i++){
// for(int j=i+1;j<numsSize;j++){
// if(nums[i]+nums[j]==target){
// p[0] = i;
// p[1] = j;
// return p;
// }
// }
// }
// p[0] = -1; //如果没有满足条件的,返回-1
// p[1] = -1;
// return p;
//}