努力打卡 每天学习 不浪费每一天 Day40

最新推荐文章于 2024-07-25 22:24:14 发布
最新推荐文章于 2024-07-25 22:24:14 发布
阅读量101 收藏
点赞数
分类专栏： JAVA自学记录 文章标签： 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Haenu0317/article/details/126999101
版权

今天学了栈和队列  正好刷几道学校题(作为dlnu的学子真的不得不吐槽一下学校的oj平台,今天下午研究半天才发现所有的题都不能加换行操作)

D-OJ -616

题目:

从键盘读入一个字符串，其中只含有() {} [ ] ，判断该字符串中的每种括号是否成对出现。

提示：可借助栈来实现，括号必须配对出现，如()[ ]{}，这是匹配的括号，如([{])}，这是不匹配的括号（中间无空格）。
答案:

​
import java.util.Iterator;
import java.util.Scanner;

public class Temp{
    public static void main(String[] args) {
        Scanner sc=new Scanner(System.in);
        String s=sc.next();
        char[] arr=s.toCharArray();
        Stack2 <Character> stack2=new Stack2<>();
        for (int i = 0; i < arr.length; i++) {
            if(arr[i]=='<'||arr[i]=='['||arr[i]=='{'||arr[i]=='(') {
                stack2.push(arr[i]);
            }
        }
        Stack2<Character> stack3=new Stack2<>();
        for (int i = arr.length-1; i >0; i--) {
            if(arr[i]=='>'||arr[i]==']'||arr[i]=='}'||arr[i]==')') {
                stack3.push(arr[i]);
            }
        }
        if(stack2.equal(stack3))
        {
            System.out.print("yes");
        }
        else {
            System.out.println("no");
        }


    }
}

class Stack2<T> implements Iterable<T> {
    private Node head;
    private int N;

    private class Node{
        private Node next;
        private T t;

        public Node(T t,Node next) {
            this.t=t;
            this.next=next;
        }
    }

    public Stack2() {
        head=new Node(null,null);
        N=0;
    }
    public void push(T t){
        Node oldFirst=head.next;
        Node newNode=new Node(t,null);
        head.next=newNode;
        newNode.next=oldFirst;
        N++;
    }
    public T pop(){
        Node oldFirst=head.next;
        if(oldFirst!=null){
            Node popNode=head.next;
            head.next=popNode.next;
            N--;
            return popNode.t;
        }
        return null;
    }
    public boolean equal(Stack2 stack2){
        int n=0;
        if(this.N!=stack2.N){

            return false;

        }
        else {
            for (int i = 0; i < N; i++) {
                Character ch1=(Character) this.pop();
                Character ch2=(Character) stack2.pop();
                int a=(int) (ch1.charValue()+1);
                int b=(int)(ch2.charValue());
                int c=(int)(ch1.charValue()+2);
                int d=(int) (ch2.charValue());
                if(a==b||c==d)
                {
                n++;
                }
            }

        }
        if(n==N){
            return true;
        }
        return false;

    }
    @Override
    public Iterator<T> iterator() {
        return new MyIterator();
    }
    private class  MyIterator implements Iterator<T>
    {
        private Node n;

        public MyIterator() {
            this.n=head;
        }

        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public T next() {
            n=n.next;
            return n.t;

        }
    }


}

​

思路:

既然是栈  就是先进后出

于是 我定义了两个栈  第一个栈 顺着接受左符号  第二个栈 逆着接受右符号(先进后出)
然后 在栈中定义一个方法 可以对比两个栈中每个数据的ascill值 这里用到了强转 因为Character不可以强转成int  于是 先定义两个Character接受第一个栈 和第二个栈的内容 然后调用Character的charAt方法变成字符再强转int
根据Ascill  40(   41)   60<   62>   {123   }125   [91     ] 93  右符号不是大于1就是大于二

所以就很好判断了  然后根据匹配对的次数 如果两个栈中每个符号都对上了 那就是yes  只要少一次 就是no

D-OJ -458

题目:

请你定义一个链栈，可以对链栈进行 “将某个元素入栈”、“弹出栈顶元素”、“取栈顶元素（不删除）”、“判断栈是否为空”、 “清空栈”等操作。键盘输入一些命令，可以执行上述操作。本题中，栈的元素为字符。

答案:

import java.util.Iterator;
import java.util.Scanner;


public class Temp {
    public static void main(String[] args) {
        newStack<String> stack=new newStack<>();
        Scanner sc=new Scanner(System.in);
        String s;
        String item;
        while(true){
            s=sc.next();
            if(s.equals("E"))break;
            switch (s) {
                case "P":{
                    item=sc.next();
                    stack.push(item);
                    break;
                }
                case "D":{
                        item=stack.pop();
                        if(item==null)
                        {
                            System.out.print("None");
                        }
                        else {
                             System.out.print(item);
                        }

                    break;
                }
                case "G":{
                        item=stack.popItem();
                    if(item==null)
                    {
                        System.out.print("None");
                    }
                    else {
                        System.out.print(item);
                    }
                    break;
                }
                case "T":{
                    stack.deleteStack();
                    break;
                }
                case "Y":{
                    System.out.print(stack.isEmpty());
                    break;
                }

                default: {
                    System.out.print("输入错误");
                    break;
                }

            }

        }
    }

}
class newStack<T> implements Iterable<T>
{
    private Node head;
    private int N;

    private class Node
    {
        public T item;
        public Node next;

        public Node(T item, Node next) {
            this.item = item;
            this.next = next;
        }

    }

    public newStack() {
        head=new Node(null,null);
        this.N=0;
    }
    public String isEmpty() {
        return (N==0)?"Yes":"No";
    }
    public int sieze(){
        return N;
    }
    public void push(T t){
        Node oldFirst=head.next;
        Node newNode=new Node(t,null);
        head.next=newNode;
        newNode.next=oldFirst;
        N++;
    }
    public T pop()
    {
        Node oldFirst=head.next;
        if (oldFirst==null) {
            return null;
        }
        head.next=oldFirst.next;
        N--;
        return oldFirst.item;

    }
    public T popItem()
    {
        Node First=head.next;
        if (First==null) {
            return null;
        }
        return First.item;
    }

    public void deleteStack(){
        head.next=null;
        N=0;
    }
    @Override
    public Iterator<T> iterator() {
        return new SIterator();
    }
    private class SIterator implements Iterator
    {
        private Node n;

        public SIterator() {
            this.n=head;
        }

        @Override
        public boolean hasNext() {
            return n.next!=null;
        }

        @Override
        public Object next() {
            n=n.next;
            return n.item;
        }
    }

}

思路:没什么说的  学完栈的链式表达就会写

D-OJ-545

题目:

将三个十进制数分别转换成八进制数，建议使用栈来实现。

public class Temp {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        Stack3<Integer> stack2=new Stack3<>();
        int a= sc.nextInt();
        int b=sc.nextInt();
        int c= sc.nextInt();
        toEigth(a,stack2);
        toEigth(b,stack2);
        toEigth(c,stack2);

    }

    private static void toEigth(int a,Stack3<Integer> stack2) {
            String eightNum="";
            int yu;
            int chu=a;
            while(chu!=0){
                yu=chu%8;
                chu=chu/8;
                stack2.push(yu);
            }
            for (Integer integer : stack2) {

                eightNum+=stack2.pop().toString();

            }
            System.out.print(eightNum);

    }


}

    class Stack3<T> implements Iterable<T> {
        private Node head;
        private int N;

        private class Node {
            private Node next;
            private T t;

            public Node(T t, Node next) {
                this.t = t;
                this.next = next;
            }
        }

        public Stack3() {
            head = new Node(null, null);
            N = 0;
        }

        public void push(T t) {
            Node oldFirst = head.next;
            Node newNode = new Node(t, null);
            head.next = newNode;
            newNode.next = oldFirst;
            N++;
        }

        public T pop() {
            Node oldFirst = head.next;
            if (oldFirst != null) {
                Node popNode = head.next;
                head.next = popNode.next;
                N--;
                return popNode.t;
            }
            return null;
        }



        @Override
        public Iterator<T> iterator() {
            return new MyIterator();
        }

        private class MyIterator implements Iterator<T> {
            private Node n;

            public MyIterator() {
                this.n = head;
            }

            @Override
            public boolean hasNext() {
                return n.next != null;
            }

            @Override
            public T next() {
                n = n.next;
                return n.t;

            }
        }

    }

思路:完全符合栈的模式  直接写

Haenu0317
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
OJ刷题记录：线性表的存储结构与操作
英雄爱吃土豆片的博客
09-23 1026
线性表的顺序存储结构与操作 题目编号:454 题目要求： 请你定义一个顺序表，可以对顺序表进行如下操作： (1)在某个元素之前插入一些元素 (2)删除某个位置的元素 (3)查找某元素 (4)获取某个位置的元素 (5)遍历输出所有元素 键盘输入一些命令，可以执行上述操作。本题中，顺序表元素为整数，顺序表的第一个元素位置为1，顺序表的最大长度为20。 输入描述 各个命令以及相关数据的输入格式如下： 在某个位置之前插入操作的命令：I，接下来的一行是插入的元素个数n， 下面是n行数据，每行数据有两个值，分别代表插入
OJ刷题记录： 栈的存储结构与操作
英雄爱吃土豆片的博客
09-26 704
栈的链式存储结构与操作 题目编号:458 题目要求： 请你定义一个链栈，可以对链栈进行 “将某个元素入栈”、“弹出栈顶元素”、“取栈顶元素（不删除）”、“判断栈是否为空”、 “清空栈”等操作。键盘输入一些命令，可以执行上述操作。本题中，栈的元素为字符。 输入描述 各个命令以及相关数据的输入格式如下： 将某个元素入栈：P，接下来一行是要入栈的元素 弹出栈顶元素：D 取栈顶元素（不删除）：G 清空栈：T 判断栈是否为空操作：Y 当输入的命令为E时，程序结束 输出描述 当输入的命令为Y时，请输出栈是否为空，如果栈
【OJ】（二）---D---列排序
u012369143的专栏
06-28 577
 题目要求如下： ----------------------------------------------------------------------------------------------------------------------------------------------- 代码如下： 运行结果： OJ要求结果输出例样：
javascript 去除一个数组中与另一个数组中的值相同的元素
且听风吟的博客
11-27 2983
let a = [1,2,3,4,5,6,6,'a','b']; let b = [2,3,4]; let c = []; for(let i of a){ if(b.indexOf(i) === -1){ c.push(i) } } console.log(c) 运行结果： VM94:9 (6) [1, 5, 6, 6, "a", "b"] let a = [1,2,3,4,5,6,6...
[D-OJ练习] 二叉树的基本操作
☆迷茫Dog的秘密基地☆
10-12 623
设计二叉树类，能够对二叉树进行先序、中序、后序和层序遍历，遍历的操作为输出结点的值，设计主函数，输入一棵二叉树，按先序、中序、后序、层序的遍历顺序输出结点的值。二叉树的结点数不超过20。 输入描述 输入数据只有一组, 二叉树的结点均为一个数字， 数据为0代表当前结点为空。输入结点的值按照二叉树的先序遍历顺序, 比如输入： 1 2 4 0 0 5 0 0 3 0 6 0 0，0表示空，输入的数字之间由空格分隔。 输出描述 输出先序、中序、后序和层序遍历二叉树得到的序列，各占一行，同一...
汉诺塔
你就是根号四的博客
11-30 563
#include int main() {     int n;     void hanoi(int n,char one ,char two,char three);     scanf("%d",&n);     hanoi(n,'A','B','C');     return 0; } void hanoi(int n,char one,char two,char thr
小白的20天Java学习打卡day1
12-22
【小白的20天Java学习打卡day1】 学习Java编程的第一步通常是理解基本概念，包括软件的本质、操作系统、编程语言的作用以及如何在Windows系统中进行基础操作。在本篇学习笔记中，我们将探讨这些关键点。 1. **什么...
小白的20天Java学习打卡day3
01-20
太原理工大学机器人团队20天学习打卡day3 1、数据类型​ ①数据类型的作用 程序当中有很多数据，每一个数据都是有相关类型的，不同数据类型的数据占用空间大小不同。 数据类型的作用是指导JVM在运行程序的时候给该...
小白的20天Java学习打卡day2
12-22
太原理工大学机器人团队20天学习打卡day2 学习内容：Java 学习网站：b站 day02 今天的内容比昨天多很多，也更难理解，希望能坚持下去 1、打开DOS命令窗口，执行java HelloWorld,执行原理 java.exe命令会启动JVM JVM...
小白的20天Java学习打卡day8
12-22
太原理工大学机器人团队20天学习打卡day8 今天继续昨天方法基础语法的学习，主要是用通过写代码来理解和记忆，所以今天的代码会比较多 也就没有小结了，多多练习！！ 话不多说，直接献上笔记！ 实例 //public表示...
小白的20天Java学习打卡day18【完结撒花】
12-22
太原理工大学机器人团队20天学习打卡day18 今天是学习java基础的最后一天，比计划中少用了两天，由于我是因为兴趣才学java的，目前还不打算往这方面发展，所以学完java基础也不会深入下去了，我打算明天回顾一下这...
oj-D-根据日期求星座
tureful的博客
11-15 210
#include void constellation(int year,int month,int day); /*函数声明*/ int main() { int year,month,day; scanf("%d %d %d",&year,&month,&day); /*输入变量*/ constellation(year,month,day); /*
数据结构学习笔记（C++）：三大简单基本排序（小结）
有朋自远方来，不亦乐乎。
11-22 570
一、插入排序--直接插入排序 1、直接插入排序： 1、思想：依次将待排序列中的每一个记录插到已排好的序列中，直到全部记录都排好序。 实例类似于生活中打牌时，每从牌堆里摸一张牌都要与手里摆好的牌进行比较然后找到相应位置把它插入。 2、如何写代码： （1）思想：假设一组无序数列存储在一维数组当中，我们想把它们排好序，我们可以把这些无序的数想象成一组洗好的牌，现在我们就来摸第一张牌，并把它放在数组的第一个位置上设为Data[0]，因为...
[D-OJ练习] (Dijkstra溯源)使用邻接矩阵实现有向图最短路径Dijkstra算法
☆迷茫Dog的秘密基地☆
11-02 516
使用邻接矩阵实现有向图最短路径Dijkstra算法 #include <iostream> #include <cstring> #include <vector> #include <algorithm> using namespace std; typedef pair<int, int> PII; vector<PII> v; const int MaxSize = 10; const int INF = 0x3f3f3f.
《数据结构与程序设计》02-Queues
weixin_43948896的博客
11-08 141
队列（先进先出）：所有的增加在表的一端进行，所有的删除都在表的另一端进行。 队头（front）:第一个将从队列中删除的元素称为队头。 队尾（rear或tail）:队列中的最后一个元素，即最近加入的一个元素称为队尾。 队列的实现： 头文件Queue.h # include <iostream> # include <cstdio> #define MAXSIZE 10 u...
一元多项式求和
weixin_45200312的博客
02-22 2473
题目要求 已知一元多项式：A(x)=a0+a1x+a2x2+a3x3+….anxn, B(x)= b0+b1x+b2x2+b3x3+….bmxm设计算法实现C(x)=A (x)+B(x)。功能包括输入多项式A，输入多项式B，求A和B的和，显示求和后的结果等操作。本题中，链表的第 一个元素位置为1，链表的数据域包含coef和exp，其中coef为系数，exp为指数。 各个命令以及相关数据的输入格式...
第十五周项目——oj d
Dream
12-08 549
#include using namespace std; void ast(int x,int y,int *cp,int *dp) { *cp=x+y; *dp=x-y; return; } int main( ) { int a,b,c,d; cin>>a>>b; ast(a,b,&c,&d); cout<<c<<" "<<d<<endl;
南阳理工OJ_题目456 邮票分你一半
心中有道的专栏
05-14 599
//把邮票分值之和的一般作为背包的容量，尽可能的多装 #include #include using namespace std; int n; int a[1010]; int d[50010]; int S; int main() { int T; cin >>T; while(T--) { cin >> n; int
AvaloniaUI的学习
最新发布
lishuangquan1987的博客
07-25 1044
官方中文文档：https://docs.avaloniaui.net/zh-Hans/docs/welcome。
编写代码 健康打卡一天只能打卡一次
04-05
我们可以使用一个字典来存储每个用户的打卡记录。字典的键是用户的ID，值是一个布尔值，表示用户今天是否已经打卡。 下面是一个示例代码： ``` check_record = {} def health_check(user_id): if user_id in ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值