力扣练习3（十题）

最新推荐文章于 2024-05-23 20:09:14 发布

冷血～多好

最新推荐文章于 2024-05-23 20:09:14 发布

阅读量181

点赞数

分类专栏：力扣文章标签： html

本文链接：https://blog.csdn.net/qq_44716544/article/details/120579327

版权

力扣专栏收录该内容

4 篇文章 0 订阅

订阅专栏

1.（1436) 旅行终点站

给你一份旅游线路图，该线路图中的旅行线路用数组 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站，即没有任何可以通往其他城市的线路的城市。

题目数据保证线路图会形成一条不存在循环的线路，因此恰有一个旅行终点站。

示例 1：

输入：paths = [["London","New York"],["New York","Lima"],["Lima","Sao Paulo"]]
输出："Sao Paulo"
解释：从 "London" 出发，最后抵达终点站 "Sao Paulo" 。本次旅行的路线是 "London" -> "New York" -> "Lima" -> "Sao Paulo" 。
示例 2：

输入：paths = [["B","C"],["D","B"],["C","A"]]
输出："A"
解释：所有可能的线路是：
"D" -> "B" -> "C" -> "A".
"B" -> "C" -> "A".
"C" -> "A".
"A".
显然，旅行终点站是 "A" 。
示例 3：

输入：paths = [["A","Z"]]
输出："Z"

提示：

1 <= paths.length <= 100
paths[i].length == 2
1 <= cityAi.length, cityBi.length <= 10
cityAi != cityBi
所有字符串均由大小写英文字母和空格字符组成。

class Solution {
    public String destCity(List<List<String>> paths) {

  String s="";
            List<String> list=new ArrayList<>();
            list=paths.get(0);
            s=list.get(1);
            int n=0;
            while (true) {
                for (int i = 0; i < paths.size(); i++) {

                    if (s.equals(paths.get(i).get(0))) {
                        s = paths.get(i).get(1);
            
                      
                    }

                }
                n++;
                if(n==paths.size()){
                    break;
                }
            }
           return s;

    }
}

2.(67)二进制求和

给你两个二进制字符串，返回它们的和（用二进制表示）。

输入为非空字符串且只包含数字 1 和 0。

示例 1:

输入: a = "11", b = "1"
输出: "100"
示例 2:

输入: a = "1010", b = "1011"
输出: "10101"

提示：

每个字符串仅由字符 '0' 或 '1' 组成。
1 <= a.length, b.length <= 10^4
字符串如果不是 "0" ，就都不含前导零。

class Solution {
    public String addBinary(String a, String b) {
   
          int max,min=0;
        String sMax,sMin="";
        if(a.length()>b.length()){
             max=a.length();
             min=b.length();
             sMax=a;
             sMin=b;
        }
        else {
             max=b.length();
             min=a.length();
             sMax=b;
             sMin=a;
        }

        String result="";
        int n=0;
        int k=max-1;
        for(int i=min-1;i>=0;i--){

            if(Integer.parseInt(String.valueOf(sMin.charAt(i)))+Integer.parseInt(String.valueOf(sMax.charAt(k)))+n==2){
                n=1;
                result+="0";

            }
           else if(Integer.parseInt(String.valueOf(sMin.charAt(i)))+Integer.parseInt(String.valueOf(sMax.charAt(k)))+n==3){
                n=1;
                result+="1";

            }
            else if(Integer.parseInt(String.valueOf(sMin.charAt(i)))+Integer.parseInt(String.valueOf(sMax.charAt(k))+n)==0){
            n=0;

            result+="0";

            }
            else {
                n=0;

                result+=1;
            }
           k--;
        }

      if(k>=0){

          for(int i=k;i>=0;i--){
             if(Integer.parseInt(String.valueOf(sMax.charAt(i)))+n==2) {
                 n=1;
                 result+=0;
             }
             else if(Integer.parseInt(String.valueOf(sMax.charAt(i)))+n==0){

                 n=0;
                 result+="0";

             }
             else {
                 n=0;
                 result+=1;




             }
          }
      }
        if(n==1){
            result+="1";
        }
      String result2="";
      for(int i=result.length()-1;i>=0;i--){
          result2+=result.charAt(i);
      }

    return  result2;
    }
}

3.(83)删除排序链表中的重复元素

存在一个按升序排列的链表，给你这个链表的头节点 head ，请你删除所有重复的元素，使每个元素 只出现一次 。

返回同样按升序排列的结果链表

提示：

链表中节点数目在范围 [0, 300] 内
-100 <= Node.val <= 100
题目数据保证链表已经按升序排列

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {

    public ListNode deleteDuplicates(ListNode head) {


        if(head==null){
            return null;
        }
        else if(head.next==null){
            return head;
        }
        ListNode listNode=new ListNode();
        ListNode listNode2=listNode;
        int n=0;
        listNode.next=head;
        n=head.val;
        while (true){

            head=head.next;
            if(head==null){
                break;
            }
            if(n!=head.val){
                listNode=listNode.next;
                listNode.next=head;
                n=head.val;
           
            }
             if(head.next==null&&n==head.val){
                listNode.next.next=null;
                break;
            }

      
        }


        return listNode2.next;

    }

}

4.(88)合并两个有序数组

给你两个按非递减顺序排列的整数数组 nums1 和 nums2，另有两个整数 m 和 n ，分别表示 nums1 和 nums2 中的元素数目。

请你合并 nums2 到 nums1 中，使合并后的数组同样按非递减顺序排列。

注意：最终，合并后数组不应由函数返回，而是存储在数组 nums1 中。为了应对这种情况，nums1 的初始长度为 m + n，其中前 m 个元素表示应合并的元素，后 n 个元素为 0 ，应忽略。nums2 的长度为 n 。

示例 1：

输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
输出：[1,2,2,3,5,6]
解释：需要合并 [1,2,3] 和 [2,5,6] 。
合并结果是 [1,2,2,3,5,6] ，其中斜体加粗标注的为 nums1 中的元素。
示例 2：

输入：nums1 = [1], m = 1, nums2 = [], n = 0
输出：[1]
解释：需要合并 [1] 和 [] 。
合并结果是 [1] 。
示例 3：

输入：nums1 = [0], m = 0, nums2 = [1], n = 1
输出：[1]
解释：需要合并的数组是 [] 和 [1] 。
合并结果是 [1] 。
注意，因为 m = 0 ，所以 nums1 中没有元素。nums1 中仅存的 0 仅仅是为了确保合并结果可以顺利存放到 nums1 中。

提示：

nums1.length == m + n
nums2.length == n
0 <= m, n <= 200
1 <= m + n <= 200
-109 <= nums1[i], nums2[j] <= 109

进阶：你可以设计实现一个时间复杂度为 O(m + n) 的算法解决此问题吗？

class Solution {
    public void merge(int[] nums1, int m, int[] nums2, int n) {
    int num = n - 1;
        if (n > 0) {
            for (int i = nums1.length - 1; i >= 0; i--) {

                if (num < 0) {
                    break;
                }
                nums1[i] = nums2[num];
                num--;

            }

        }
        int temp = 0; // 临时变量
        for (int i = 0; i < nums1.length - 1; i++) {

            for (int j = 0; j < nums1.length - 1 - i; j++) {
                // 如果前面的数比后面的数大，则交换
                if (nums1[j] > nums1[j + 1]) {
                    temp = nums1[j];
                    nums1[j] = nums1[j + 1];
                    nums1[j + 1] = temp;
                }
            }

        }
    }
}

5.(414) 第三大的数

给你一个非空数组，返回此数组中 第三大的数 。如果不存在，则返回数组中最大的数。

示例 1：

输入：[3, 2, 1]
输出：1
解释：第三大的数是 1 。
示例 2：

输入：[1, 2]
输出：2
解释：第三大的数不存在, 所以返回最大的数 2 。
示例 3：

输入：[2, 2, 3, 1]
输出：1
解释：注意，要求返回第三大的数，是指在所有不同数字中排第三大的数。
此例中存在两个值为 2 的数，它们都排第二。在所有不同数字中排第三大的数为 1 。

提示：

1 <= nums.length <= 104
-231 <= nums[i] <= 231 - 1

class Solution {
    public int thirdMax(int[] nums) {


        int temp = 0; // 临时变量
        for (int i = 0; i < nums.length - 1; i++) {

            for (int j = 0; j < nums.length - 1 - i; j++) {
                // 如果前面的数比后面的数大，则交换
                if (nums[j] < nums[j + 1]) {
                    temp = nums[j];
                    nums[j] = nums[j + 1];
                    nums[j + 1] = temp;
                }
            }
        }


        int n[]=new int[nums.length];
        int n2=nums[0];
        n[0]=nums[0];
        int n3=1;
        if(nums.length<3){
            return nums[0];
        }
        else {
          for(int i=1;i<nums.length;i++){
              if(n2!=nums[i]){
                  n[n3]=nums[i];
                n2=nums[i];
                  n3++;
              }
              if(n3==3){
                 break;
              }
          }

        }

       if(n3<3){
            return n[0];
        }
        else {
            return n[2];

        }

    }
}

6.(41) 缺失的第一个正数

给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。

请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。

1：

输入：nums = [1,2,0]
输出：3
示例 2：

输入：nums = [3,4,-1,1]
输出：2
示例 3：

输入：nums = [7,8,9,11,12]
输出：1

提示：

1 <= nums.length <= 5 * 105
-231 <= nums[i] <= 231 - 1

class Solution {
    public int firstMissingPositive(int[] nums) {
      int n=1;
        Arrays.sort(nums);
        for(int i=0;i<nums.length;i++){

          if(n==nums[i]){
              n++;
            }
        }
        return n;
    }
}

7.(42) 接雨水

给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。

class Solution {
    public int trap(int[] height) {
  int location = 0;
        int location2 = 0;
        int rightLocation = 0;
        int leftLocation = 0;
        int max = 0;
        int rightMax = 0;
        int leftMax = 0;
        int sum = 0;
        int sub=0;
            for (int i = 0; i < height.length; i++) {
                if (max < height[i]) {
                    max = height[i];
                    location = i;
                    location2 = i;
                }
            }



        if (location < height.length - 1) {
                while (true) {
                    for (int i = location + 1; i < height.length; i++) {
                        if (rightMax <= height[i]) {
                            rightMax = height[i];
                            rightLocation = i;
                        }
                    }
                    if(rightLocation - location>1) {

                    for (int i = location+1; i <= rightLocation-1; i++) {
                        sub += height[i];
                    }
                        sum += (rightLocation - location-1) * rightMax - sub;
                   //     System.out.println("sum===="+sum+"rightLocation - location=="+(rightLocation - location)+" rightMax==="+rightMax+" sub==="+sub);
                    }
                    rightMax=0;
                    location=rightLocation;
                    sub = 0;
                    if(rightLocation==height.length-1){
                        break;
                    }


                }
            }

    

        if (location2 >0) {
            sub=0;
            while (true) {
                for (int i = location2-1; i >= 0; i--) {
                    if (leftMax <=height[i]) {
                        leftMax = height[i];
                        leftLocation = i;

                    }
                }

                if(location2 - leftLocation>1) {
                    for (int i = leftLocation+1; i < location2; i++) {
                        sub += height[i];
                    }
                    sum += (location2 - leftLocation-1) * leftMax - sub;
                }
                leftMax=0;
        
                location2=leftLocation;
                sub = 0;
                if(leftLocation==0){
                    break;
                }

            }

        }



return sum;
    }
}

8.(434)字符串中的单词数

统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。

请注意，你可以假定字符串里不包括任何不可打印的字符。

示例:

输入: "Hello, my name is John"
输出: 5
解释: 这里的单词是指连续的不是空格的字符，所以 "Hello," 算作 1 个单词

class Solution {
    public int countSegments(String s) {
    int n=0;

        if(s.length()<=0)  return 0;
        for(int i=0;i<s.length();i++){
            if(s.charAt(i)!=' '){
                if(i+1<s.length()&&s.charAt(i+1)==' '){
                    n++;
                }
            }
        }
        if(s.charAt(s.length()-1)!=' '){
            n++;
        }
        return n;
    }
}

9.(94) 二叉树的中序遍历

给定一个二叉树的根节点 root ，返回它的中序遍历。

示例 2：

输入：root = []
输出：[]

示例 3：

输入：root = [1]
输出：[1]

提示：

树中节点数目在范围 [0, 100] 内
-100 <= Node.val <= 100

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
     List<Integer> list0=new ArrayList<>();
    public List<Integer> inorderTraversal(TreeNode root) {
   if(root!=null){
            List<Integer> list=preOrder(root);
            return list;
        }
        else return list0;

    }
      public  List<Integer>  preOrder(TreeNode root){

        if(root.left!=null){
          preOrder(root.left);
        }
        list0.add(root.val);
       if(root.right!=null){
           preOrder(root.right);
       }

       return list0;

   }
}

10.（441）排列硬币

你总共有 n 枚硬币，并计划将它们按阶梯状排列。对于一个由 k 行组成的阶梯，其第 i 行必须正好有 i 枚硬币。阶梯的最后一行 可能 是不完整的。

给你一个数字 n ，计算并返回可形成 完整阶梯行 的总行数。

输出：3
解释：因为第四行不完整，所以返回 3 。

提示：

1 <= n <= 231 - 1

class Solution {
    public int arrangeCoins(int n) {
      double n1=n;
      double x1=  ((-1+Math.sqrt(1+8*n1))/2);
       return (int)x1;
    }
}

冷血～多好

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
力扣练习3（十题）

1.（1436)旅行终点站给你一份旅游线路图，该线路图中的旅行线路用数组 paths 表示，其中 paths[i] = [cityAi, cityBi] 表示该线路将会从 cityAi 直接前往 cityBi 。请你找出这次旅行的终点站，即没有任何可以通往其他城市的线路的城市。题目数据保证线路图会形成一条不存在循环的线路，因此恰有一个旅行终点站。示例 1：输入：paths = [["London","New York"],["New York","Lima"],["Lima","Sao .
复制链接

扫一扫