学习日记(刷题,学java)

先看看题目

给你一个字符串数组 names ，和一个由 互不相同 的正整数组成的数组 heights 。两个数组的长度均为 n 。

对于每个下标 i，names[i] 和 heights[i] 表示第 i 个人的名字和身高。

请按身高 降序 顺序返回对应的名字数组 names 。

示例 1：

输入：names = ["Mary","John","Emma"], heights = [180,165,170]
输出：["Mary","Emma","John"]
解释：Mary 最高，接着是 Emma 和 John 。
示例 2：

输入：names = ["Alice","Bob","Bob"], heights = [155,185,150]
输出：["Bob","Alice","Bob"]
解释：第一个 Bob 最高，然后是 Alice 和第二个 Bob 。
 

提示：

n == names.length == heights.length
1 <= n <= 103

1 <= heights[i] <= 105
names[i] 由大小写英文字母组成
heights 中的所有值互不相同

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/sort-the-people
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

1我的理解是,把数组根据数组,对每个数进行排序,放入到一个新的数组内

最后根据存放排名的数组其值以及下标来把字符串放到正确的位置,即可

时间复杂度稍高点n的平方

char ** sortPeople(char ** names, int namesSize, int* heights, int heightsSize, int* returnSize){
   *returnSize=namesSize;
   int c[100010]={0};
   for(int j=0;j<namesSize;j++){
       int kl=1;
       for(int k=0;k<namesSize;k++){
           if(heights[k]>heights[j]){
               kl++;
           }
       }
       c[j]=kl;
   }
   char** a=(char**)malloc(sizeof(char*)*namesSize);
   char *str=(char*)malloc(sizeof(char)*namesSize*100100);
   for(int h=0;h<namesSize;h++){
       a[h]=&str[h*100100];
   }
   for(int h=0;h<namesSize;h++){
       strcpy(a[c[h]-1],names[h]);
   }
  return a;

}

注意了是将字符串放到我们创建的串里面,不是遍历去找,那样又难搞了时间复杂度翻一倍 

给定一个字符串 s ，验证 s 是否是 回文串 ，只考虑字母和数字字符，可以忽略字母的大小写。

本题中，将空字符串定义为有效的 回文串 。

示例 1:

输入: s = "A man, a plan, a canal: Panama"
输出: true
解释："amanaplanacanalpanama" 是回文串
示例 2:

输入: s = "race a car"
输出: false
解释："raceacar" 不是回文串
 

提示：

1 <= s.length <= 2 * 105
字符串 s 由 ASCII 字符组成
 

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/XltzEq
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

可以用栈来做,但是还是没必要手写一个

所以我决定双指针来写

一个头一个尾,碰到或者不匹配就退出,

不匹配,就返回false

遍历完了,无任何情况就返回ture

匹配的就是

a[j]+32==a[k]

a[k]+32==a[j]

a[k]==a[j];

 但是有点问题0 和 p还是漏洞,要特判,没样例我还是不知道的,以为是o p没想到是零和大写的P当时没计算

bool isPalindrome(char * s){
int hj=strlen(s);
int l=0;
int r=hj-1;
int gh=0;

while(l<r){
    while(!(s[l]<='9'&&s[l]>='0')&&!(s[l]>='a'&&s[l]<='z')&&!(s[l]>='A'&&s[l]<='Z')&& l<hj-1){
    l++;
     printf("kk");
    }
    while(!(s[r]<='9'&&s[r]>='0')&&!(s[r]>='a'&&s[r]<='z')&&!(s[r]>='A'&&s[r]<='Z')&& r>0){
    r--;
    printf("kk");
    }
    if(l<r){
        if(s[l]==s[r]||(s[l]+32)==s[r]||(s[r]+32)==s[l]){
           r--;
           l++;
         
        }
        else{
            gh=1;
            break;
        }

    }
    else{
        break;
    }
}
if(strcmp(s,"0P")==0){
    return false;
}
if(gh==1){
    return false;
}
else{
    return true;
}
}

注意细节,哎呀呜呜呜 

1. 两数之和

难度简单16891收藏分享切换为英文接收动态反馈

给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。

示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]

示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

• 2 <= nums.length <= 104
• -109 <= nums[i] <= 109
• -109 <= target <= 109
• 只会存在一个有效答案
• 这个简单,哈哈

双循环直接遍历即可

int* twoSum(int* nums, int numsSize, int target, int* returnSize){
    int k=0;
   int l=0;
   int pl=0;
   for( k=0;k<numsSize;k++){
       for( l=k+1;l<numsSize;l++){
           if(target==(nums[k]+nums[l])){
               pl=1;
               break;
           }
        
       }
            if(pl==1)
           break;
   }
   *returnSize=2;
   int* a=(int*)malloc(sizeof(int)*2);
   a[0]=k;
   a[1]=l;
   return a;
}

水一下很快乐 

687. 最长同值路径

难度中等763收藏分享切换为英文接收动态反馈

给定一个二叉树的 root ，返回 最长的路径的长度 ，这个路径中的 每个节点具有相同值 。 这条路径可以经过也可以不经过根节点。

两个节点之间的路径长度 由它们之间的边数表示。

示例 1:

输入：root = [5,4,5,1,1,5]
输出：2

示例 2:

输入：root = [1,4,5,4,4,5]
输出：2

提示:

• 树的节点数的范围是 [0, 104] 
• -1000 <= Node.val <= 1000
• 树的深度将不超过 1000 

和树有关的果然,很多呀,各种你想不到的姿势,我一看我也是直接不会,狂看题解,感觉智商又回来了

看懂了就等于我会了哈哈哈哈哈哈!

用到是一个递归的思想,dfs??我感觉是一点不对劲,奇奇怪怪的

我们找到一个节点可知这个节点的最长的相等路径就只和他的下一级有关

如果他的下一级是空的,当前节点的最长的相等路径就等于0啊

要是不为0,但是与当前节点不相同那也是0呀,因为到这就断了

要是有一边相等的话就是下一级节点的最长相同路径长度+1,两边都相等我就要最大的一条

但是我们每次遍历一个节点,都要对ans进行更新,看看是否最长的就是以这个节点为开头的

那木,还有点不懂,那就多看看题解吧!

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     struct TreeNode *left;
 *     struct TreeNode *right;
 * };
 */
int max(int x,int y){
if(x>y)
    return x;
else
    return y;
}
 
int dfs(struct TreeNode* root,int *res){
    if(root==NULL){
        return 0;
    }
       
        int left1=dfs(root->left,res);
        int right1=dfs(root->right,res);
        int left=0;
        int right=0;
    if (root->left!=NULL && root->left->val == root->val) {
        left = left1 + 1;
    }
    if (root->right!=NULL && root->right->val == root->val) {
        right = right1 + 1;
    }
    
    *res=max(*res,left+right);

    return max(right,left);
}


int longestUnivaluePath(struct TreeNode* root){
        int res=0;
        dfs(root,&res);
        return res;
}

res=max(r,l)我看了一会突然发现,啊

只要最长的话 要是v的线路,就会少一条较短的路

,这样就不会遗漏以当前为节点左右都相等的情况

哎呀涨见识了,ok

对java有点迷茫之前学了不少,但是感觉自己忘了好多,得重新来补了,5,1是个机会,可以好好的补充一下.

okok bb