JAVA面试寿司ACM模式链表和树

最新推荐文章于 2024-07-20 02:59:06 发布

怪痞子

最新推荐文章于 2024-07-20 02:59:06 发布

阅读量359

点赞数 5

文章标签：面试链表职场和发展

本文链接：https://blog.csdn.net/weixin_48773854/article/details/137435235

版权

文章展示了如何在Java中实现单链表反转和二叉树的前、中、后序遍历，包括输入输出样例和相关函数实现。

摘要由CSDN通过智能技术生成

1.构建链表并反转

单链表反转

时间限制：10.000S 空间限制：128MB

题目描述

根据一个整数序列构造一个单链表，然后将其反转。

例如：原单链表为 2 3 4 5 ，反转之后为5 4 3 2

输入描述

输入包括多组测试数据，每组测试数据占一行，第一个为大于等于0的整数n，表示该单链表的长度，后面跟着n个整数，表示链表的每一个元素。整数之间用空格隔开

输出描述

针对每组测试数据，输出包括两行，分别是反转前和反转后的链表元素，用空格隔开

如果链表为空，则只输出一行，list is empty

输入示例

5 1 2 3 4 5 
0

输出示例

1 2 3 4 5 
5 4 3 2 1 
list is empty

import java.util.*;
public class Main{
    static class ListNode{
        int val;
        ListNode next;
        public ListNode(int val){
            this.val=val;
        }
    }
    public static void main (String[] args) {
        /* code */
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            int nums=sc.nextInt();
        if(nums==0){
            System.out.println();
        System.out.println("list is empty");
        } 
        
        else{
            int[] nodes=new int[nums];
            for (int i=0;i<nums ;i++ ){
                nodes[i]=sc.nextInt();
                //System.out.println(nodes[i]);
            } 
        
        ListNode head= initnode(nodes);
        ListNode head2= initnode(nodes);
        while(head!=null){
                System.out.print(head.val+" ");
                head=head.next;
            }
            System.out.println();
        ListNode res= reverse(head2);
        while(res!=null){
            System.out.print(res.val+" ");
            res=res.next;
        }   
        
    }
        }
        
}
    public static ListNode initnode(int[] num){
        
        ListNode ans=new ListNode(0);
        ListNode dumhead=ans;
        if (num.length==0){
            return null;
        } 
        for (int i=0;i<num.length ;i++ ){
            
            ListNode temp=new ListNode(num[i]);
            dumhead.next=temp;
            dumhead=dumhead.next;
        } 
        return ans.next;
        
    }
    public static ListNode reverse(ListNode head){
     
        ListNode pre=null;
        ListNode cur=head;
        while(cur!=null){
            ListNode next=cur.next;
            cur.next=pre;
            pre=cur;
            cur=next;
        }
        return pre;
    }
}

2.构建树1

构造二叉树

时间限制：1.000S 空间限制：32MB

题目描述

给你一棵二叉树的前序遍历和中序遍历结果，要求你写出这棵二叉树的后序遍历结果。

输入描述

输入包含多组测试数据。每组输入包含两个字符串，分别表示二叉树的前序遍历和中序遍历结果。每个字符串由不重复的大写字母组成。

输出描述

对于每组输入，输出对应的二叉树的后续遍历结果。

输入示例

DBACEGF ABCDEFG
BCAD CBAD

输出示例

ACBFGED
CDAB

import java.util.*;

class TreeNode{
    char val;
    TreeNode left;
    TreeNode right;
    public TreeNode(char val){
        this.val=val;
    }
}
public class Main{
    
    
    static HashMap<Character,Integer> map=new HashMap<>();
    
    public static void main (String[] args) {
        /* code */
        Scanner sc=new Scanner(System.in);
        while(sc.hasNext()){
            String pre=sc.next();
            String in=sc.next();
        char[] preorder= pre.toCharArray();
            char[] inoder=in.toCharArray();
            TreeNode root=buildTree(preorder,inoder);
            postorder(root);
            map=new HashMap<>();
            System.out.println();
            continue;
        }
 
    }
  //  static HashMap<Character,Integer> map=new HashMap<>();
    public static TreeNode buildTree(char[] preorder,char[] inoder){
        
        for (int i=0;i< preorder.length;i++ ){
            map.put(inoder[i],i);
            
        } 
        
        return build(preorder,inoder,0,preorder.length-1,0,inoder.length-1);
        
    }
    
    public static TreeNode build(char[] preorder,char[] inoder,int preleft,int preright,int inleft,int inright){
        if(preleft>preright||inleft>inright)
			return null;
        int inroot=map.get(preorder[preleft]);
        TreeNode root=new TreeNode(preorder[preleft]);
        int leftlen=inroot-inleft;
        root.left=build(preorder,inoder,preleft+1,preleft+leftlen,inleft,inroot-1);
        root.right=build(preorder,inoder,preleft+leftlen+1,preright,inroot+1,inright);
        return root;
    }
    
    
    public static void postorder(TreeNode root){
        if(root==null)
            return;
            
            postorder(root.left);
             
            postorder(root.right);
            
            System.out.print(root.val);
    }
    
    
}

3.构建树2

二叉树的遍历

时间限制：1.000S 空间限制：128MB

题目描述

给出一个n个节点的二叉树，请求出二叉树的前序遍历，中序遍历和后序遍历。

输入描述

题目包含多行输入，第一行为一个整数 N，表示二叉树的节点总数，后面将有 N 行对应于二叉树的 N 个节点的信息。

每行的数据格式遵循如下规则：

每行开始是该节点的标识符，代表二叉树中具体的一个节点。

节点标识符之后是两个数字，分别表示该节点的左孩子和右孩子的序号。序号根据输入顺序从 1 开始自动分配，即第一个输入的节点序号为 1，第二个为 2，以此类推。

若某个节点的左孩子或右孩子序号为 0，则表示该节点不存在相应的左孩子或右孩子。

输出描述

共三行，第一行为二叉树的前序遍历，第二行为中序遍历，第三行为后序遍历

输入示例

输出示例

FCADBEG
ACBDFEG
ABDCGEF

提示信息

样例输入解释如下：首行数字 7 表示二叉树共有 7 个节点。接下来的行按序提供每个节点的信息，

格式为：标识符左孩子序号右孩子序号。节点序号自动从 1 依次递增，对应输入的行顺序。

例如：

F 2 3 表示标识符为 F 的节点（序号为 1）有左孩子（序号为 2）和右孩子（序号为 3）；

E 0 6 表示标识符为 E 的节点（序号为 3）无左孩子，有右孩子（序号为 6）。

由于 F 的右孩子是序号为 3 的节点，而 E 的序号刚好为 3，所以 F 的右孩子就是 E。

import java.util.*;

class TreeNode{
    char val;
    TreeNode left;
    TreeNode right;
    public TreeNode(char val){
        this.val=val;
    }
}
public class Main{
    
    public static void main (String[] args) {
        /* code */
        
        Scanner sc=new Scanner(System.in);
        int nums=sc.nextInt();
        //System.out.println(nums);
        sc.nextLine();
        List<List<String>> nodes=new ArrayList<>();
        while(sc.hasNextLine()){
            //System.out.println(sc.nextLine());
            String[] strs=sc.nextLine().split(" ");
            nodes.add(Arrays.asList(strs));
        }
        TreeNode root=buildTree(nodes);
        preorder(root);
        System.out.println();
        inorder(root);
        System.out.println();
        postorder(root);
        //System.out.println(nodes);

    }
    
    public static TreeNode buildTree(List<List<String>> list){
        if(list==null) return null;
        List<TreeNode> nodelist=new ArrayList<>();
        for(int i=0;i<list.size();i++){
            TreeNode node=new TreeNode(list.get(i).get(0).charAt(0));
            nodelist.add(node);     
        }
        for(int i=0;i<nodelist.size();i++){
            int leftnum=Integer.parseInt(list.get(i).get(1));
            int rightnum=Integer.parseInt(list.get(i).get(2));
            if(leftnum!=0)
                nodelist.get(i).left=nodelist.get(leftnum-1);
            if(rightnum!=0)
                nodelist.get(i).right=nodelist.get(rightnum-1);
        }
        return nodelist.get(0);
    }
    
    public static void preorder(TreeNode root){
        if(root!=null){
            System.out.print(root.val);
            preorder(root.left);
            preorder(root.right);
        }
    }
        public static void inorder(TreeNode root){
        if(root!=null){  
            inorder(root.left);
            System.out.print(root.val);
            inorder(root.right);
        }
        
        }
        public static void postorder(TreeNode root){
        if(root!=null){
            
            postorder(root.left);
           
            postorder(root.right);
             System.out.print(root.val);
        }
        
    }
    
}

题目来源卡玛网：卡码网KamaCoder