20220422java算法笔试题-----栈、队列与哈希表

已于 2022-05-01 16:42:01 修改
阅读量1.2k 收藏
点赞数 1
分类专栏： java 文章标签： 算法 散列表 数据结构
于 2022-05-01 16:40:09 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42847719/article/details/124353345
版权

1.如何实现栈

题目描述：

实现一个栈的数据结构，使其具有以下方法：压栈、弹栈、取栈顶元素、判断栈是否为空以及获取栈中元素个数。

//利用数组
class MyStack<T>{
    private ArrayList<T> arr;
    private int stackSize;

    public MyStack() {
        stackSize=0;
        arr=new ArrayList<T>();
    }
    //判断是否为空
    boolean isEmpty(){
        return stackSize==0;
    }
    //返回栈的大小
    int size(){
        return stackSize;
    }
    //返回栈顶元素
    T top(){
        if(isEmpty()){
            return null;
        }
        return arr.get(stackSize-1);
    }
    //弹栈
    T pop(){
        if(stackSize>0){
            return arr.get(--stackSize);
        }else{
            System.out.println("栈已经为空");
            return null;
        }
    }
    //压栈
    void push(T item){
        arr.add(item);
        stackSize++;
    }
}
public class ConStack {
    public static void main(String[] args) {
        MyStack<Integer> stack=new MyStack<>();
        stack.push(1);
        System.out.println("栈顶元素为："+stack.top());
        System.out.println("栈大小为："+stack.size());
        stack.pop();
        System.out.println("弹栈成功");
        stack.pop();
    }
}
//链表法
class LNode<T>{
    T data;
    LNode<T> next;
}
class myStack<T>{
    private LNode<T> pHead;
    public myStack(){
        pHead =new LNode<T>();
        pHead.data=null;
        pHead.next=null;
    }
    //判断栈是否为空
    boolean empty(){
        return pHead==null;
    }
    //获取栈中的元素个数
    int size(){
        int size=0;
        LNode<T> p=pHead.next;
        while (p!=null){
            p=p.next;
            size++;
        }
        return size;
    }
    //入栈，把e放到栈顶
    void push(T e){
        LNode <T> p=new LNode<>();
        p.data=e;
        p.next=pHead.next;
        pHead.next=p;
    }
    //出栈,同时返回栈顶元素
    T pop(){
        LNode <T> tmp=pHead.next;
        if(tmp!=null){
            pHead.next=tmp.next;
            return tmp.data;
        }
        System.out.println("栈已经为空");
        return  null;
    }
    //获取栈顶元素
    T top(){
        if(pHead.next!=null){
            return pHead.next.data;

        }
        System.out.println("栈已经为空");
        return null;
    }

}
public class ListTest {
    public static void main(String[] args) {
        myStack<Integer> stack=new myStack<>();
        stack.push(1);
        System.out.println("栈顶元素为："+stack.pop());
        System.out.println("栈大小为："+stack.size());
        stack.pop();
        System.out.println("弹栈成功");
        stack.pop();

    }

}

2.如何实现队列

题目描述：

实现一个队列的数据结构，使其具有入队列、出队列、查看队列首尾元素、查看队列大小等功能。
 

import java.util.ArrayList;

class MyQueue<T>{
    private ArrayList<T> arr=new ArrayList<>();
    private  int front;//队列头
    private  int rear;//队列尾
    public MyQueue(){
        front=0;
        rear=0;
    }
    //判断队列是否为空
    public  boolean isEmpty(){
        return  front==rear;
    }
    //返回队列的大小
    public int size(){
        return rear-front;
    }
    //返回队列首元素
    public T getFront(){
        if(isEmpty()){
            return null;
        }
        return arr.get(front);
    }
    //返回队列尾元素
    public T getRear(){
        if(isEmpty()){
            return null;
        }
        return arr.get(rear-1);
    }
    //删除队列头元素
    public void deleteQueue(){
        if(rear>front){
            front++;
        }else {
            System.out.println("队列已经为空");
        }
    }
    //把新元素加入队列尾
    public void joinQueue(T item){
        arr.add(item);
        rear++;
    }
}

public class ArrayQueue {
    public static void main(String[] args) {
        MyQueue<Integer> queue =new MyQueue<>();
        queue.joinQueue(1);
        queue.joinQueue(2);
        queue.joinQueue(3);
        System.out.println("队列头元素为："+queue.getFront());
        System.out.println("队列尾元素为："+queue.getRear());
        System.out.println("队列大小为："+queue.size());
    }
}

//利用链表实现队列
class LNode<T>{
    T data;
    LNode<T> next;
}
class MyQueue<T>{
    private LNode<T>pHead;
    private LNode<T> pEnd;
    //分配头结点
    public  MyQueue(){
        pEnd=pHead=null;
    }
    //判断队列是否为空
    boolean empty(){
        if(pHead==null){
            return true;
        }else {
            return false;
        }
    }
    //元素个数
    int size(){
        int size=0;
        LNode<T>p=pHead;
        while (p!=null){
            p=p.next;
            size++;
        }
        return size;
    }
    //添加列尾
    void enQueue(T e){
        LNode<T> p=new LNode<>();
        p.data=e;
        p.next=null;
        if(pHead==null){
            pHead=pEnd=p;
        }else {
            pEnd.next=p;
            pEnd=p;
        }
    }
    //删除队列元素
    void deQueue(){
        if(pHead==null)
            System.out.println("出队列失败，队列已经为空");
            pHead=pHead.next;
            if(pHead==null)
                pEnd=null;
        }
        //获取队列首位元素
    T getFront(){
        if(pHead==null){
            System.out.println("获取队列首元素失败，队列已经为空");
            return null;
        }
        return pHead.data;
    }
    //队列尾元素
    T getBack(){
        if(pEnd==null){
            System.out.println("获取队列尾元素失败，队列已经为空");
            return null;
        }
        return pEnd.data;
    }
}

public class QueueList {
    public static void main(String[] args) {
        MyQueue<Integer> queue=new MyQueue<>();
        queue.enQueue(1);
        queue.enQueue(2);
        System.out.println("队列头元素为："+queue.getFront());
        System.out.println("队列尾元素为："+queue.getBack());
        System.out.println("队列大小为："+queue.size());
    }
}

3.如何设计一个排序系统

题目描述：

设计一个排队系统，能够让每个进入队的用户都能看到自己在队列中所处的位置和变化，队可能随时有人加入和退出；当有人退出影响到用户的位置排名时需要及时反馈到用户。

package queue;

import java.util.LinkedList;
import java.util.Objects;
import java.util.Queue;
/*1、offer()和add()的区别
add()和offer()都是向队列中添加一个元素。但是如果想在一个满的队列中加入一个新元素，调用 add() 方法就会抛出一个 unchecked 异常，而调用 offer() 方法会返回 false。可以据此在程序中进行有效的判断！

2、peek()和element()的区别
peek()和element()都将在不移除的情况下返回队头，但是peek()方法在队列为空时返回null，调用element()方法会抛出NoSuchElementException异常。

3、poll()和remove()的区别
poll()和remove()都将移除并且返回对头，但是在poll()在队列为空时返回null，而remove()会抛出NoSuchElementException异常。
*/

/**
 * @author 龙御修
 */
class User {
    private int id;
    private String name;
    private int seq;

    public User(int id, String name) {
        this.id = id;
        this.name = name;
        this.seq = seq;
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getSeq() {
        return seq;
    }

    public void setSeq(int seq) {
        this.seq = seq;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }
        User user = (User) o;
        return id == user.id && seq == user.seq && Objects.equals(name, user.name);
    }

    @Override
    public int hashCode() {
        return Objects.hash(id, name, seq);
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", name='" + name + '\'' +
                ", seq=" + seq +
                '}';
    }

}

class MyQueue {
    private Queue<User> q = new LinkedList<>();

    //进入队列尾部
    public void enQueue(User u) {
        u.setSeq(q.size() + 1);
        q.add(u);
    }
    //对头 出队列

   void deQueue() {
        q.poll();
        updataSep();
    }

    //队列中的人随机离开
    void deQueue(User u) {
        q.remove(u);
        updataSep();
    }

    //出列后更新队列中每个人的序列
    void updataSep() {
        int i = 1;
        for (User u : q) {
            u.setSeq(i++);
        }
    }

    //打印队列的信息
    void printList() {
        for (User u : q) {
            System.out.println(q);
        }
    }
}

public class SoftSystem {
    public static void main(String[] args) {
        User u1=new User(1,"User1");
        User u2=new User(2,"User2");
        User u3=new User(3,"User3");
        User u4=new User(4,"User4");

        MyQueue queue=new MyQueue();
         //存入队列
        queue.enQueue(u1);
        queue.enQueue(u2);
        queue.enQueue(u3);
        queue.enQueue(u4);
        //删除队列头和队列u3
        queue.printList();
        queue.deQueue();
        queue.deQueue(u3);
        queue.printList();
    }


}

4.如何实现LRU缓存方案 

题目描述：

LRU是Least Recently Used 的缩写，它的意思是“最近最少使用”。LRU缓存就是使用这种原理实现，简单地说，就是缓存一定量的数据，当超过设定的阈值时就把一些过期的数据删除掉。常用于页面置换算法，是为虚拟页式存储管理中常用的算法。如何实现LRU缓存方案？ 

package queue;

import java.util.ArrayDeque;
import java.util.HashSet;

/**
 * @author tarena
 */
public class Test1 {
    public static void main(String[] args) {
        /*设置缓存大小*/
        LRU lru = new LRU(3);
        /*访问page*/
        lru.accessPage(1);
        lru.accessPage(2);


        lru.accessPage(5);
        lru.accessPage(1);
        lru.accessPage(6);
        lru.accessPage(7);
        /*通过上面的访问序列后，缓存的信息为*/
        lru.printQueue();


    }


}

class LRU {
    private int cacheSize;
    private ArrayDeque<Integer> queue = new ArrayDeque<>();//双向链
    private HashSet<Integer> hashSet = new HashSet<>();//哈希表

    public LRU(int cacheSize) {
        this.cacheSize = cacheSize;
    }

    /*判断缓存队列是否已满*/
    private boolean isQueueFull() {
        return queue.size() == cacheSize;
    }

    /*把页号为PageNum的也缓存到队列中，同时也添加都Hash表中*/
    private void enqueue(int pageNum) {
        /*如果队列满了,需要删除队尾的缓存的页*/
        if (isQueueFull()) {
            hashSet.remove(queue.getLast());
            queue.pollLast();
        }
        queue.addFirst(pageNum);
    }

    /*当访问某一个page的时候会调用这个函数，对于访问的page有两种情况：
     * 1.如果page在缓存队列中，直接把这个结点移动到队首
     * 2.如果page不在缓存队列中，把这个page缓存到队首*/
    public void accessPage(int pageNum) {
        /*page不在缓存队列中，把它缓存到队首*/
        if (!hashSet.contains(pageNum)) {
            enqueue(pageNum);
            /*page已经在缓存队列中了,移动到队首*/
        } else if (pageNum != queue.getFirst()) {
            queue.remove(pageNum);
            queue.addFirst(pageNum);
        }
    }

    public void printQueue() {
        while (!queue.isEmpty()) {
            System.out.print(queue.pop() + "");
        }
    }
}

5.如何从数组中找出满足a+b=c+d的两个数对

题目描述：

给定一个数组，找出数组中是否有两个数对（a, b）和（c, d），使得a+b=c+d，其中a、b、c和d是不同的元素。如果有多个答案，打印任意一个即可。例如，给定数组：{3, 4, 7, 10, 20, 9, 8}，可以找到两个数对（3, 8）和（4, 7），使得3+8=4+7。
 

补充：拓扑排序是对一个有向图构造拓扑序列，解决工程是否能顺利进行的问题。构造时有 2 种结果：

  1. 此图全部顶点被输出：说明说明图中无「环」存在， 是 AOV 网

  2. 没有输出全部顶点：说明图中有「环」存在，不是 AOV 网

import java.util.HashMap;

/**
 * @author 龙御修
 * @create 2022-05-01 16:23
 */
public class ArrayElements {
    boolean findPairs(int arr[]){
        /*键为数对和和，值为数对*/
        HashMap<Integer,pair> sumPair=new HashMap<>();
        int n= arr.length;
        /*遍历数组中所有可能的数对*/
        for(int i=0;i<n;i++){
            for(int j=i;j<n;++j){
                /*如果这个数对的和在map中没有，则放入map中*/
                int sum=arr[i]+arr[j];
                if(!sumPair.containsKey(sum))
                    sumPair.put(sum,new pair(i,j));
                /*map中已经存在于sum相同的数对了。找出来并打印出来*/
                else {
                    /*找出已经遍历过的并存储在map中和为sum的数对*/
                    pair p=sumPair.get(sum);
                    System.out.println("("+arr[p.first]+","+arr[p.second]+"),("+arr[i]+","+arr[j]+")");
                    return true;
                }
            }
        }
        return  false;
    }

    public static void main(String[] args) {
        int arr[]={3,4,7,10,20,9,8};
        ArrayElements a=new ArrayElements();
        a.findPairs(arr);
    }

}
/*用来存储数对*/
class pair{
    int first,second;

    public pair(int first, int second) {
        this.first = first;
        this.second = second;
    }
}

Royalreairman
关注
专栏目录
Java 关于栈的一些常见算法题的记录（代码+详细注释）
m0_38036210的博客
08-29 425
1.自定义栈（数组实现） //使用数组模拟栈 class MyStack{ private int maxSize; private int top; private int[] arr; //栈构造器 public MyStack(int maxSize) { this.maxSize=maxSize; arr=new int[maxSize]; top=-1; ...
java实现堆栈、哈希表、链表
行也思君
10-15 1280
//堆栈实现的代码 package traverse; public class Stack { Object[] data;//数据 int maxSize;//栈的最大容量 int top;//顶点 public Stack(int maxSize){ this.maxSize=maxSize; data=new Object[maxSize]; top=-1;
【Java数据结构】栈与队列笔试习题详解
耀的博客
12-31 611
栈与队列面试习题详解
Java使用数组模拟「链表、栈与队列」（笔试常用）
HC_wood的博客
02-04 614
写在前面：由于new操作比如new Node()是相当耗时的，并且笔试的时候数据量是比较大的，如果链表需要把节点都new出来可能会超时，这时候就需要使用数组来模拟。 数组模拟链表 （1）单链表常常使用邻接表来模拟，邻接表常常用来存储树和图。 （2）双链表通常是用来优化某些题。 e[N]: 某点的值是多少 ne[N]: 某个点的next指针是多少 e和ne使用下标来关联，0号点的值为e[0], next指针是ne[0], 显然ne[0] = 1，注意空节点的下标用-1来表示。 数组模拟双向链表 e[N],
Java实现栈以及栈的相关面试题
xaiobit_hl的博客
05-19 687
目录 JAVA实现栈 栈的经典题目 1.JAVA实现栈 栈是一种特殊的线性表，只允许在固定的一端进行插入和删除元素操作。简言之就是出栈和入栈都是在栈顶进行操作，因为其底层是一个数组，所以实现会非常简单，我就不多赘述了，看代码： public class MyStack<E> { public int usedSize; public E[] elem; public static final int DEFAULT_SIZE = 5; public M
2022届-JAVA开发笔试题.docx
最新发布
12-19
JAVA开发笔试题知识点总结 ...本资源摘要信息涵盖了JAVA开发笔试题的知识点，涵盖了JAVA编程语言、数据结构、算法、数据库、网络协议等方面的知识点，为JAVA开发笔试题提供了一个全面的知识框架。
初级java笔试题-Algorithms--part1:由KevinWayne和RobertSedgewick提供的算法课程
06-03
初级java笔试题教学大纲 从 描述。 基本数据类型、算法和数据结构的介绍。 我们的重点是 Java 实现的应用程序和科学性能分析。 第一部分侧重于基本数据结构、排序和搜索。 主题包括联合查找、二分搜索、堆栈、队列、...
腾讯研发工程师笔试真题-综合文档
05-22
数据结构与算法是笔试中的重头戏。链表、数组、栈、队列、树（二叉树、平衡树如AVL、红黑树）、图等基本数据结构的性质、操作及其应用需要熟练掌握。对于排序算法（如冒泡排序、快速排序、归并排序）和查找算法（如...
快手2019秋招笔试试题-算法B试卷
07-19
同时，对数据结构的理解，如数组、链表、栈、队列、树、图等，以及基础算法，如排序、查找、动态规划、贪心策略等，是必不可少的知识点。 在实际的笔试中，可能会遇到以下类型的题目： 1. **基础编程题**：这类...
各大软件公司面试--算法笔试题
10-31
在IT行业中，面试是检验求职者技能和能力的重要环节，特别是在软件公司，算法笔试题更是不可或缺的部分。这些题目旨在评估候选人的逻辑思维、问题解决能力和编程基础。以下是一些可能出现在各大软件公司面试中的算法...
面试算法题(7)--写一个java类，实现栈的功能
热门推荐
阿杜
07-19 1万+
写一个java类，实现栈的功能 之前面试碰到这个题，自己实现栈的功能。 首先我们的了解栈的特点，和栈Stack.java各个方法的含义: 1、栈是单出入口的数据结构，即出口和入口是共用的。 2、栈拥有后进先出的特点。 栈Stack.java源码方法分析： /** * @author duke * @dateTime 2018-07-19 22:24 * @description S...
java中队列算法题目_算法：栈和队列题目集合（一）
weixin_36294852的博客
02-27 414
前言栈和队列是算法的一个基本的知识点之一。这篇文章主要介绍三道有关栈和队列的算法题。因为篇幅所限，只介绍push和pop这两种方法的实现用栈实现队列用队列实现栈循环队列的实现用栈实现队列入队列的功能我们可以用栈的入栈的功能替代。但问题在于出队列的功能怎么实现。这里有一个问题，就是栈是后入先出的，队列是先进先出的，两者出入的方式不一样。那么怎么实现方向的一致呢? 我们可以使用两个栈，一个栈用于输入，...
【笔试题】Java实现队列（Queue）的方式
qq_35670694的博客
06-12 374
https://blog.csdn.net/jsc123581/article/details/81986714 https://blog.csdn.net/Hellowenpan/article/details/82781767
栈和队列相关算法题（Java）
weixin_43855930的博客
07-23 417
所用示例均出自力扣https://leetcode-cn.com/ 用队列实现栈 思路： 创建两个队列，一个用于输入in,一个用于输出out。 添加的时候将数据加到in中，然后将out中的数据都加到in中，此时in队列的头就是刚压入的数。再将in, out互换，保证压入队列为空。 对输出队列进行poll(),peek()等操作。 补：队列的相关操作 add 增加一个元索 如果队列已满，则抛出一个IIIegaISlabEepeplian异常 remove
使用java实现后进先出的堆栈功能【笔试题】
Abubu123的博客
04-18 5891
今天看到某公司的笔试题，题目如下： 1.      请编写代码实现Stack类，该类能够实现后进先出的堆栈功能，要求实现的方法包括： ------Stack(int) –实例化指定深度的栈 ------ boolean push(E item) – 向栈顶压入对象，成功返回true，栈已满返回false ------ E pop() – 从栈顶移除对象并返回，如栈为空返回null -
Java 堆 栈面试题_Java工程师面试题：Java的堆，栈，方法区你都搞清楚了吗?
weixin_36123682的博客
02-24 277
在进行学员回访的时候，碰巧提到一些Java工程师面试题：Java的堆，栈，方法区你都楚吗?这里上海Java培训班学员在面试时都这样做了回答。问题分析：Java虚拟机在执行Java程序的过程中会把它所管理的内存划分为若干个不同的数据区域。回答套路熟悉时，几个方面都会说到。程序计数器上海Java培训班：程序计数器(Program CounterRegister)是一块较小的内存空间，它可以看做是当前线...
堆栈问题的面试题【收集好题，经常更新】
SiYuanSource的博客
05-01 3339
栈(stack)又称堆栈,是限制在表的一端进行插入和删除的线性表。其限制是仅允许在表的一端进行插入和删除操作,不允许在其他任何位置进行插入、查找、删除等操作。堆（英语：heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵树的数组对象。堆总是满足下列性质：堆中某个节点的值总是不大于或不小于其父节点的值；堆总是一棵完全二叉树。堆和栈的区别问题T1.下列Java代码中的变量a、b...
Java设计模式笔试题（10~13题）
java364100的博客
06-20 370
10、谈谈 JVM 的内存结构和内存分配● Java内存模型：Java虚拟机将其管辖的内存大致分三个逻辑部分：方法区(Method Area)、Java栈和Java堆。● 方法区是静态分配的，编译器将变量绑定在某个存储位置上，而且这些绑定不会在运行时改变。常数池，源代码中的命名常量、String常量和static变量保存在方法区。● Java Stack是一个逻辑概念，特点是后进先出。一个栈的空间可能是连续的，也可能是不连续的。最典型的Stack应用是方法的调用，Java虚拟机每调用一次方法就创建一个方法帧
java堆栈面试题_深入浅出！2020年春招+秋招JVM面试题整理（附答案）
weixin_39571219的博客
02-25 347
运行时数据区是什么？虚拟机在执行 Java 程序的过程中会把它所管理的内存划分为若干不同的数据区，这些区域有各自的用途、创建和销毁时间。线程私有：程序计数器、Java 虚拟机栈、本地方法栈。线程共享：Java 堆、方法区。程序计数器是什么？程序计数器是一块较小的内存空间，可以看作当前线程所执行字节码的行号指示器。字节码解释器工作时通过改变计数器的值选取下一条执行指令。分支、循环、跳转、线程恢复等功...
微软笔试题解析：数据结构与算法面试100题（21-40）
- 哈希表：哈希冲突的处理，以及哈希函数的设计，对于快速查找和存储数据至关重要。 2. 算法： - 排序算法：快速排序、归并排序、冒泡排序、插入排序等，以及它们的时间复杂度分析。 - 搜索算法：二分查找、深度...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Royalreairman

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值