1 判断三角形形状

package day0303;

import java.util.Scanner;

/**
 * @author mk
 * @description 判断三角形形状
 * @create 2022-03-2022/3/3 11:14
 */
public class Triangle {

    public static void main(String[] args) {

        Scanner scanner = new Scanner(System.in);
        System.out.println("请输入第一个数字：");
        int a = scanner.nextInt();
        System.out.println("请输入第二个数字：");
        int b = scanner.nextInt();
        System.out.println("请输入第三个数字：");
        int c = scanner.nextInt();


        Triangle test= new Triangle();
        String resource = test.checkTriangle1(a, b, c);
        System.out.println(resource);

        System.out.println("====================================");
        test.main(args);
    }




    public String  checkTriangle(int a ,int b,int c){
        String s = null;

        if(a <= 0 || b <= 0 || c <= 0){
            s = "缺少边值，无法构成三角形~！";
//            return s;
        }
        if(a+b>c && a+c>b && b+c>a){
            if(a == b || a == c || c == b){
                if(a == b && b == c){
                    s = "等边三角形~！";
                }else {
                    s = "等腰三角形~！";
                }
//                return s;
            }else{
                s = "普通三角形~！";}

        }else{
            s = "无法构成三角形~！";
        }

        return s;

    }


    public String  checkTriangle1(int a ,int b,int c){
        String s = null;

        if(a <= 0 || b <= 0 || c <= 0){
            s = "缺少边值，无法构成三角形~！";
//            return s;
        }
        if(a+b>c && a+c>b && b+c>a){
            if((a*a + b*b < c*c) || (a*a+c*c < b*b) || (c*c + b*b < a*a)){
                if(a == b || b == c || a == c){
                    s = "等腰钝角三角形~！";
                }else {
                    s = "钝角三角形~！";
                }
//                return s;
            }
           else if(a*a + b*b == c*c || a*a + c*c == b*b || c*c + b*b == a*a){
                if(a == b || b == c || a == c){
                    s = "等腰直角三角形~！";
                }else {
                    s = "直角三角形~！";
                }
            }
           //if(a*a+b*b > c*c || a*a+c*c>b*b || c*c+b*b>a*a)
           else {
                if(a == b && b == c){
                    s = "等边三角形~！";
                }else if(a == b || b == c || a == c){
                    s = "等腰锐角三角形~！";
                }else{
                    s = "锐角三角形~！";
                }
            }

        }else{
            s = "无法构成三角形~！";
        }

        return s;

    }

}

2 按升序合并如下两个 list, 并去除重复的元素

• list1 = [2,3,5,1,3,4]
• list2 = [6,2,3,8,1,0,2]

package day0303;

import java.util.*;

/**
 * @author mk
 * @description 按升序合并如下两个 list, 并去除重复的元素
 * list1 = [2,3,5,1,3,4]
 * list2 = [6,2,3,8,1,0,2]
 * @create 2022-03-2022/3/3 15:00
 */
public class mergeDisorder {
    public static void main(String[] args) {
        int[] list1 = {2,3,5,1,3,4};
        int[] list2 = {6,2,3,8,1,0,2};


        int[] newlist = new int[list1.length + list2.length];
        for (int i = 0; i < list1.length; i++) {
            newlist[i] = list1[i];
        }
        for (int i = 0; i < list2.length; i++) {
            newlist[list1.length - 1 + i] = list2[i];
        }

        Arrays.sort(newlist);

        Set set = new HashSet();
        for (int i = 0; i < newlist.length; i++) {
            set.add(newlist[i]);
//            System.out.print(newlist[i]);
        }

        List list = new ArrayList<>(set);
        System.out.println(list);
    }
}

3 数据库乱入。

写一个 sql，查询出成绩表中，平均分数大于 80 的所有学生信息。（表里有课程名、学生名、分数几个字段）？？？

/*
* select 学生表.学号姓名等等，avg(成绩) as 平均分
* from 学生表 join 成绩表 on 学生表.学号=成绩表.学号
* group by 学生表.学号
* having avg(成绩) > 80
* */

4 用栈实现队列

示例：

输入：
["MyQueue", "push", "push", "peek", "pop", "empty"]
[[], [1], [2], [], [], []]
输出：
[null, null, null, 1, 1, false]

解释：
MyQueue myQueue = new MyQueue();
myQueue.push(1); // queue is: [1]
myQueue.push(2); // queue is: [1, 2] (leftmost is front of the queue)
myQueue.peek(); // return 1
myQueue.pop(); // return 1, queue is [2]
myQueue.empty(); // return false

class MyQueue {

    Stack<Integer> inStack;
    Stack<Integer> outStack;

    public MyQueue() {

        inStack = new Stack<Integer>();
        outStack = new Stack<Integer>();

    }
    
    
    public void push(int x) {
        inStack.push(x);
    }
    
    public int pop() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.pop();
    }
    
    public int peek() {
        if (outStack.isEmpty()) {
            in2out();
        }
        return outStack.peek();
    }
    
    public boolean empty() {
        return inStack.isEmpty() && outStack.isEmpty();
    }

    private void in2out() {
        while (!inStack.isEmpty()) {
            outStack.push(inStack.pop());
        }
    }

}

/**
 * Your MyQueue object will be instantiated and called as such:
 * MyQueue obj = new MyQueue();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.peek();
 * boolean param_4 = obj.empty();
 */
 

package day0303;

import java.util.Stack;

/**
 * @author mk
 * @description
 * @create 2022-03-2022/3/3 16:44
 */
public class StackToQueue {
    

    public static void main(String[] args) {

    }

}

class MyQueue{
    Stack<Integer> inStack;
    Stack<Integer> outStack;

    public  MyQueue() {

        inStack = new Stack<Integer>();
        outStack = new Stack<Integer>();

    }

    //如果是添加尾部，先把栈2的内容全部放到栈1中来
    public void appendTail(int value) {
        if(inStack.empty()){
            while(!outStack.empty()){
                inStack.push(outStack.pop());
            }
        }
        inStack.push(value);
    }

    //如果是删除头部，先把栈1的内容全部放到栈2中来
    public int deleteHead() {
        if(outStack.empty()){
            while(!inStack.empty()){
                outStack.push(inStack.pop());
            }
            if(outStack.empty()){
                return -1;
            }
            else{
                return outStack.pop();
            }
        }
        return outStack.pop();
    }
}

5 队列实现栈

class MyStack {
    Queue<Integer> queue1;
    Queue<Integer> queue2;

    /** Initialize your data structure here. */
    public MyStack() {
        queue1 = new LinkedList<Integer>();
        queue2 = new LinkedList<Integer>();
    }
    
    /** Push element x onto stack. */
    public void push(int x) {
        queue2.offer(x);
        while (!queue1.isEmpty()) {
            queue2.offer(queue1.poll());
        }
        Queue<Integer> temp = queue1;
        queue1 = queue2;
        queue2 = temp;
    }
    
    /** Removes the element on top of the stack and returns that element. */
    public int pop() {
        return queue1.poll();
    }
    
    /** Get the top element. */
    public int top() {
        return queue1.peek();
    }
    
    /** Returns whether the stack is empty. */
    public boolean empty() {
        return queue1.isEmpty();
    }
}


/**
 * Your MyStack object will be instantiated and called as such:
 * MyStack obj = new MyStack();
 * obj.push(x);
 * int param_2 = obj.pop();
 * int param_3 = obj.top();
 * boolean param_4 = obj.empty();
 */

6 找出数组中重复的数字。

在一个长度为 n 的数组 nums 里的所有数字都在 0～n-1 的范围内。数组中某些数字是重复的，但不知道有几个数字重复了，也不知道每个数字重复了几次。请找出数组中任意一个重复的数字。

示例 1：

输入： [2, 3, 1, 0, 2, 5, 3]

输出：2 或 3

class Solution {//差点
    public int findRepeatNumber(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        int repeat = -1;
        for (int num : nums) {
            boolean temp = set.add(num);          
            if (!temp) {
                repeat = num;
                break;
            }
            //else{
               // set.add(num);
           // }
        }
        return repeat;
    }
}

class Solution {//力扣官方
    public int findRepeatNumber(int[] nums) {
        Set<Integer> set = new HashSet<Integer>();
        int repeat = -1;
        for (int num : nums) {
            if (!set.add(num)) {
                repeat = num;
                break;
            }
        }
        return repeat;
    }
}

7 字符串里第一个出现重复的字符

package day0303;

import java.util.HashSet;
import java.util.Set;

/**
 * @author mk
 * @description 字符串里第一个出现重复的字符
 * @create 2022-03-2022/3/3 17:14
 */
public class RepeatChar {
    public static void main(String[] args) {
        String s = "dbbd";
        //错了。先出现的是d
//        for (int i = 0; i < str.length(); i++) {
//            for (int j = i+1; j < str.length(); j++) {
//                if(String.valueOf(str.charAt(i)).equals(String.valueOf(str.charAt(j)))){
//                    System.out.println(str.charAt(i));
//                    break;
//                }
//            }
//        }

        Set<Integer> set = new HashSet<Integer>();
        for (int i = 0; i < s.length(); i++) {
            if(! set.add((int) s.charAt(i))){
                System.out.println(s.charAt(i));
                break;
            }

        }
    }
}

package day0303;

/**
* @author mk
* @description 轩儿给的解答。优秀
* @create 2022-03-2022/3/3 19:30
*/
public class RepeatChar1 {
   public static void main(String[] args) {
       // 初始化数据
       String sourceStr = "dbbd";

       // 第一种情况是，
       // 找当前数据中谁有重复数据，
       // 其中第一个有重复数据的字符是谁
       // 例如字符串中有{d,d}{b,b}两组重复数据，但是第一个有重复数据的是d,那么答案为d

       for(int i = 0;i< sourceStr.length();i++) {
           for(int j=i+1;j<sourceStr.length();j++) {
               if(String.valueOf(sourceStr.charAt(i)).equals(String.valueOf(sourceStr.charAt(j)))) {
                   System.out.println(sourceStr.charAt(i));
                   return;
               }
           }
       }

       // 第二种情况是。
       // 当前数据在遍历过程中谁首先出现了重复数据
       // 例如
       // 输出：d   无重复
       // 输出：db  无重复
       // 输出：dbb 返发现bb重复，则当前重复字符为b
               for(int i=1;i<sourceStr.length();i++) {
                   for(int j = i - 1;j>=0;j--) {
                       if(String.valueOf(sourceStr.charAt(i)).equals(String.valueOf(sourceStr.charAt(j)))) {
                           System.out.println(sourceStr.charAt(i));
                           return;
                       }
                   }
               }
   }
}

8 反转字符串:qwww.baidu.com，输出com.baidu.wwwq

package day0303;

/**
 * @author mk
 * @description 反转字符串
 * 例如，输入 http://www.baidu.com，输出com.baidu.www//:http
 * @create 2022-03-2022/3/3 19:48
 */
public class ReverseIP {

    public static void main(String[] args) {
        String s = "qwww.baidu.com";
        int n = s.length();

        char[] arr = s.toCharArray();
        for (int i = 0; i <= (n-1)/2; i++) {
            reverse(arr,0,n-1);
        }
        int start = 0;
        for (int i = 0; i < n; i++) {

            if(arr[i] == '.'){
                reverse(arr,start,i-1);
                start = i+1;
            }
        }

        System.out.println(new String(arr));
    }
    public static void reverse(char[] arr, int left, int right) {
        while (left < right) {
            char temp = arr[left];
            arr[left] = arr[right];
            arr[right] = temp;
            left++;
            right--;
        }
    }

}

9 遍历二叉树

package day0303;

import java.util.ArrayList;
import java.util.List;

/**
 * @author mk
 * @description
 * @create 2022-03-2022/3/3 21:05
 */
public class TestTree {

    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;
     }
 }
 /*
 *      1
 *        \
 *          2
 *         /
 *      3
 * */


 /*
 * 输入：root = [1,null,2,3]
 * 输出：[1,2,3]
 * 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
* */
    public List<Integer> preorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        preorder(root, res);
        return res;
    }

    public void preorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        res.add(root.val);
        preorder(root.left, res);
        preorder(root.right, res);
    }


/*
 * 输入：root = [1,null,2,3]
 * 输出：[1,3,2]
 * 给你二叉树的根节点 root ，返回它节点值的 中序 遍历。
 * */
    public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        inorder(root, res);
        return res;
    }

    public void inorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        res.add(root.val);
        inorder(root.right, res);
    }

    /*
     * 输入：root = [1,null,2,3]
     * 输出：[3,2,1]
     * 给你二叉树的根节点 root ，返回它节点值的 后序 遍历。
     * */
    public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> res = new ArrayList<Integer>();
        postorder(root, res);
        return res;
    }

    public void postorder(TreeNode root, List<Integer> res) {
        if (root == null) {
            return;
        }
        inorder(root.left, res);
        inorder(root.right, res);
        res.add(root.val);
    }


}