2021.4.18刷题

臭弟弟码农

于 2021-04-18 22:20:54 发布

阅读量94

点赞数

本文链接：https://blog.csdn.net/yyyyyy12133463/article/details/115830859

版权

1.反转链表

输入一个链表，反转链表后，输出新链表的表头。

1.记录下个指向

2.改当前指向

3.获取当前位置

4.修改cur

public class Solution {
    public ListNode ReverseList(ListNode head) {

          ListNode prev=null;
          ListNode cur=head;
          while(cur!=null){
              ListNode next=cur.next;
              cur.next=prev;
              prev=cur;
              cur=next;
          }
        return prev;
    }
}

2.合并两个排序的链表

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

public class Solution {
    public ListNode Merge(ListNode list1,ListNode list2) {
        ListNode res = new ListNode(0);
        ListNode tmp = res;
        while(list1!=null&&list2!=null){
            if(list1.val>=list2.val){
                tmp.next=list2;
                list2=list2.next;
            }else{
                tmp.next=list1;
                list1=list1.next;
            }
            tmp=tmp.next;
        }
        if(list1!=null){
            tmp.next=list1;
        }
        if(list2!=null){
            tmp.next=list2;
        }
        return res.next;
    }
}

3.树的子结构

题目描述

输入两棵二叉树A，B，判断B是不是A的子结构。（ps：我们约定空树不是任意一个树的子结构）

1.首先需要判断A,B的根节点是否一样。

2.如果不一样，判断A的左孩子和B的根节点是否一样，同理可判断A的右孩子和B的根节点是否一样。依次找下去

如果上述情况都不满足则说明不包含

1.如果找到了A中有值和B中的根节点相同，则比较左右子树是否相同。

2.如果B为空了，则说明包含

3.如果A为空了，则说明不包含

public class Solution {
    public boolean HasSubtree(TreeNode root1,TreeNode root2) {
        if(root1==null || root2==null)
            return false;
        //判断root1和root2是否是子结构||判断root1.left和root2是否是子结构
        //    ||判断root1.right和root2是否是子结构
        return dfs(root1,root2)||HasSubtree(root1.left,root2)||HasSubtree(root1.right,root2);
    }
    private boolean dfs(TreeNode root1,TreeNode root2){
        if(root2==null){//如果root2是空直接是子结构
            return true;
        }
        //如果root1为空，root1和root2的值不等，则不是子结构
        if(root1==null||root1.val!=root2.val){
            return false;
        }
        //以上条件不满足，则判断root1和root2左右结构是否相等，使用递归
        return dfs(root1.left,root2.left)&&dfs(root1.right,root2.right);
    }
}

4.二叉树的镜像

题目描述

操作给定的二叉树，将其变换为源二叉树的镜像。

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    public TreeNode Mirror (TreeNode pRoot) {
        // write code here
        TreeNode tmp;
        if(pRoot==null)return pRoot;
        tmp = pRoot.right;
        pRoot.right=pRoot.left;
        pRoot.left=tmp;
        Mirror(pRoot.left);
        Mirror(pRoot.right);
        return pRoot;
    }
}

5.顺时针打印矩阵

题目描述

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字，例如，如果输入如下4 X 4矩阵： 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 则依次打印出数字1,2,3,4,8,12,16,15,14,13,9,5,6,7,11,10.

import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printMatrix(int [][] matrix) {
        ArrayList<Integer> list = new ArrayList<Integer>();
        int up=0;
        int down = matrix.length-1;
        int left=0;
        int right=matrix[0].length-1;
        while(true){
            //最上
            for(int col=left;col<=right;col++){
                list.add(matrix[up][col]);
            }
            up++;
            if(up>down){
                break;
            }
            //最右
            for(int row=up;row<=down;row++){
                list.add(matrix[row][right]);
            }
            right--;
            if(right<left){
                break;
            }
            //下
            for(int col=right;col>=left;col--){
                list.add(matrix[down][col]);
            }
            down--;
            if(up>down){
                break;
            }
            //左
            for(int row=down;row>=up;row--){
                list.add(matrix[row][left]);
            }
            left++;
            if(left>right){
                break;
            }
        }
        return list;
    }
}

6.包含min函数的栈

题目描述

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数（时间复杂度应为O（1））。

import java.util.Stack;

public class Solution {

    Stack<Integer> data = new Stack<>();
    Stack<Integer> min = new Stack<>();
    public void push(int node) {
        if(min.isEmpty()){
            min.push(node);
        }else{
            if(min.peek()<node){//java里Stack的peek方法是返回栈顶的元素但不移除它。
                min.push(min.peek());
            }else{
                min.push(node);
            }
        }
        data.push(node);
    }
    
    public void pop() {
        data.pop();
        min.pop();
    }
    
    public int top() {
        return data.peek();
    }
    
    public int min() {
        return min.peek();
    }
}

7.栈的压入、弹出序列

题目描述

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

初始化：用指针i指向pushA的第一个位置，指针j指向popA的第一个位置
如果pushA[i] != popA[j]，那么应该将pushA[i]放入栈中，i++
否则，pushA[i]==popA[j], 说明这个元素是放入栈中立马弹出，所以，i++, j++，然后应该检查popA[j]与栈顶元素是否相等，如果相等，j++, 并且弹出栈顶元素
重复2，3，如果i==pushA.size(), 说明入栈序列访问完，此时检查栈是否为空，如果为空，说明匹配，否则不匹配。

import java.util.ArrayList;
import java.util.Stack;
public class Solution {
    public boolean IsPopOrder(int [] pushA,int [] popA) {
        if (pushA.length == 0 || popA.length == 0 || popA.length != pushA.length)
            return false;
        Stack<Integer> stack = new Stack<>();
        int j = 0;
        for (int i  = 0;i<pushA.length;i++){
            stack.push(pushA[i]);
            while(!stack.isEmpty()&&stack.peek()==popA[j]){
                j++;
                stack.pop();
            }
        }
        return stack.isEmpty();
    }
}

8.从上往下打印二叉树

题目描述

从上往下打印出二叉树的每个节点，同层节点从左至右打印。

规律：每一次打印一个节点的时候，如果该节点有子节点，则把该节点的子节点放到一个队列的尾部。接下来到对队列的头部取出最早进入队列的节点放到ArrayList 中，重复前面的操作，直至队列中所有的节点都存到ArrayList中。

public class Solution {
    public ArrayList<Integer> PrintFromTopToBottom(TreeNode root) {
        ArrayList<Integer> list = new ArrayList<>();
        ArrayList<TreeNode> queue = new ArrayList<>();
        if(root==null){
            return list;
        }
        queue.add(root);
        while(queue.size()!=0){
            TreeNode tmp = queue.remove(0);
            if(tmp.left!=null){
                queue.add(tmp.left);
            }
            if(tmp.right!=null){
                queue.add(tmp.right);
            }
            list.add(tmp.val);
        }
        return list;
    }
}

9.二叉搜索树的后序遍历序列

题目描述

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。（ps：我们约定空树不是二叉搜素树）

二叉搜索树或者是一棵空树，或者是具有下列性质的二叉树：若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值。

特点：最后一个数为树的根节点，第一个大于根节点的点是右子树，从该点到根节点的数都大于根节点，同时搜索二叉树的左子树和右子树都是搜索二叉树。

import java.util.Arrays;
public class Solution {
    public boolean VerifySquenceOfBST(int [] sequence) {
       if(sequence==null||sequence.length==0)return false;
        return Judge(sequence,0,sequence.length-1);
    }
    public boolean Judge(int[] sequence,int start,int end){
        if(start>=end)
            return true;
        int i;
        for(i=start;i<end;i++){
            if(sequence[i]>sequence[end])
                break;
        }
        for(int j=i;j<=end-1;j++){
            if(sequence[j]<sequence[end])
                return false;
        }
        return Judge(sequence,start,i-1)&&Judge(sequence,i,end-1);//保证左子树和右子树也是搜收二叉树
    }
}

臭弟弟码农

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
2021.4.18刷题

1.反转链表输入一个链表，反转链表后，输出新链表的表头。1.记录下个指向2.改当前指向3.获取当前位置4.修改curpublic class Solution { public ListNode ReverseList(ListNode head) { ListNode prev=null; ListNode cur=head; while(cur!=null){ ListNode next=c
复制链接

扫一扫