力扣练习3（十题）
Posted 冷血～多好
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了力扣练习3（十题）相关的知识，希望对你有一定的参考价值。
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;
}
}以上是关于力扣练习3（十题）的主要内容，如果未能解决你的问题，请参考以下文章