๐Ÿ“š
TIL
  • README
  • Git
    • Basic
    • Remote Repository
    • Log & Diff
    • Rebase&Cherri-Pick
    • git-flow
  • DevOps
    • Monolithic vs MSA
    • Jenkins ์‹œ์ž‘ํ•˜๊ธฐ
    • Airflow ์‹œ์ž‘ํ•˜๊ธฐ
    • Airflow ์‹œ์ž‘ํ•˜๊ธฐ
    • Build Tools
      • maven
  • ๊ฐœ๋ฐœ ๋ฐฉ๋ฒ•๋ก 
    • TDD
  • Spring
    • IoC
    • Is Spring Bean Thread-Safe?
    • Spring Singleton
    • Component Scan
    • Spring Annotation
    • ์˜์กด ๊ด€๊ณ„ ์ฃผ์ž…(DI)
    • Lombok ํ™œ์šฉํ•˜๊ธฐ
    • Bean ์ƒ๋ช…์ฃผ๊ธฐ์™€ ์ฝœ๋ฐฑ
    • Bean Scope
    • AOP(1) - AOP๋ž€
    • AOP(2) - Aop Proxy
    • AOP(3) - Dynamic Proxy
    • AOP(4) - AspectJ
    • POJO
    • Spring ์„œ๋น„์Šค ๊ตฌ์กฐ
    • Transaction
    • JPA๋ž€?
    • JPA Entity
    • Spring Data JPA
    • Spring Data Specification
    • Model Mapping
    • Cache
    • restTemplate
    • YAML ํŒŒ์ผ ์„ค์ •
    • Spring Boot
      • H2 DB ์„ค์ •
      • ๋‹ค์ค‘ ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์„ค์ •
      • Mybatis ์—ฐ๋™ํ•˜๊ธฐ
    • Spring Batch
      • Batch ์‹œ์ž‘ํ•ด๋ณด๊ธฐ
      • Batch Job Flow
      • Job
      • Step
      • Batch Scope & Job Parameter
      • JobRepository์™€ ๋ฉ”ํƒ€ํ…Œ์ด๋ธ”
      • Chunk ์ง€ํ–ฅ ํ”„๋กœ๊ทธ๋ž˜๋ฐ
      • ItemReader
      • ItemProcessor
      • ItemWriter
      • Batch Schedular
      • Job๋ณ„ Bean๋“ฑ๋กํ•˜๊ธฐ
      • Batch ๊ตฌํ˜„์‹œ ๋ฐœ์ƒํ•œ ์˜ค๋ฅ˜ ์ •๋ฆฌ
      • Spring Batch Scaling
        • Multithread Job๊ตฌํ˜„์‹œ ์ด์Šˆ์‚ฌํ•ญ
    • Spring test
      • Junit5
        • ํ…Œ์ŠคํŠธ ์ด๋ฆ„ ํ‘œ๊ธฐ
        • ํ…Œ์ŠคํŠธ ๊ทธ๋ฃน ์‚ฌ์ด์˜ ๊ด€๊ณ„
        • ํƒœ๊ทธ์™€ ํ•„ํ„ฐ๋ง
        • ๋™์  ํ…Œ์ŠคํŠธ
        • ํ…Œ์ŠคํŠธ LifeCycle
        • ํ…Œ์ŠคํŠธ ๋ฉ”์„œ๋“œ
        • ํ…Œ์ŠคํŠธ ์ˆœ์„œ
        • AssertJ
        • ํ…Œ์ŠคํŠธ ๋ณ‘๋ ฌ ์‹คํ–‰
        • AssertJ
        • Mock
      • Spring Boot Test DB ๋ถ„๋ฆฌ
      • Spring Batch Test
  • Web Application
    • Web Server & WAS
    • ๊ด€๋ จ ๊ฐœ๋… - HTTP API, HTML, CSR, SSR
    • Servlet
    • JSP
    • Cookie And Session
    • ์˜ˆ์™ธํŽ˜์ด์ง€
    • Java Bean
    • JDBC
    • Connection Pool
    • ํŒŒ์ผ ์—…๋กœ๋“œ
    • Expression Language
    • JSTL
    • FrontControllerํŒจํ„ด Command ํŒจํ„ด
    • Forwarding
    • MVC
    • ํšŒ์›๊ฐ€์ž…์˜ˆ์ œ
    • ์ฐธ๊ณ 
      • ๊ฐœ๋ฐœํ™˜๊ฒฝ์„ค์ •
  • Java+
    • SOAP/WSDL vs REST
    • WSDL์„ JAVA๋กœ ๋ณ€ํ™˜ํ•˜๊ธฐ
    • SOAP ํ†ต์‹  OPEN API๋กœ ๊ฐœ๋ฐœํ•ด๋ณด๊ธฐ
  • Java
    • Basic
      • ๋ณ€์ˆ˜์™€ ํƒ€์ž…
      • ์—ฐ์‚ฐ์ž
      • ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ˜๋ณต๋ฌธ
      • ์ฐธ์กฐ ํƒ€์ž…
      • ํด๋ž˜์Šค
      • ์ƒ์†(Inheritance)
      • ์ธํ„ฐํŽ˜์ด์Šค(Interface)
      • ์ค‘์ฒฉ ํด๋ž˜์Šค์™€ ์ค‘์ฒฉ ์ธํ„ฐํŽ˜์ด์Šค
      • ์˜ˆ์™ธ ์ฒ˜๋ฆฌ
      • API - Object, System, Class, Math, Wrapper
      • API - String, StringBuffer, StringBuilder
      • Thread
      • Generic
      • Lambda
      • Collection - List, Set
      • Collection - Map
      • Collection - Tree
      • Collection - Stack, Queue
      • Stream
      • Reflection
      • ์ •๊ทœํ‘œํ˜„์‹
      • GUI
      • UML
      • Serializable
    • Advanced
      • OutOfMemoryError
      • AutoValue
      • meta-annotation
        • @Retention
        • @Target
        • @Repeatable
    • Effective Java 3/E
      • ITEM 1: Static Factory Method(์ •์  ๋ฉ”์†Œ๋“œ)
      • ITEM 2: Builder Pattern
      • ITEM 3: Singleton
      • ITEM 4: Private Constructor
      • ITEM 5: Dependency Injection
      • ITEM 6: Avoid Unnecessary Object
      • ITEM 7: Eliminate Object Reference
      • ITEM 8: Avoid finalizer and cleaner
      • ITEM 9: try-with-resources
      • ITEM 10: The gerneral contract when overriding equlas
      • ITEM 11: Overriding hashCode
      • ITEM 12: overriding toString
      • ITEM 13: overriding clone judiciously
      • ITEM 14: Consider implementing comparable
      • ITEM 15: ํด๋ž˜์Šค์™€ ๋ฉค๋ฒ„์˜ ์ ‘๊ทผ์„ ์ตœ์†Œํ™”ํ•ด๋ผ
      • ITEM 16: Use Accessor methods
      • ITEM 17: ๋ณ€๊ฒฝ ๊ฐ€๋Šฅ์„ฑ์„ ์ตœ์†Œํ™”ํ•ด๋ผ(๋ถˆ๋ณ€ ํด๋ž˜์Šค)
      • ITEM 18: ์ƒ์†๋ณด๋‹จ ์ปดํฌ์ง€์…˜์„ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 19: ์ƒ์†์„ ๊ณ ๋ คํ•ด ์„ค๊ณ„ํ•˜๊ณ  ๋ฌธ์„œํ™”ํ•ด๋ผ
      • ITEM 20: ์ถ”์ƒ ํด๋ž˜์Šค๋ณด๋‹ค ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์šฐ์„ ํ•˜๋ผ
      • ITEM 21: ์ธํ„ฐํŽ˜์ด์Šค๋Š” ๊ตฌํ˜„ํ•˜๋Š” ์ชฝ์„ ์ƒ๊ฐํ•ด ์„ค๊ณ„ํ•ด๋ผ.
      • ITEM 22: ์ธํ„ฐํŽ˜์ด์Šค๋Š” ํƒ€์ž…์„ ์ •์˜ํ•˜๋Š” ์šฉ๋„๋กœ๋งŒ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 23: ํƒœ๊ทธ ๋‹ฌ๋ฆฐ ํด๋ž˜์Šค๋ณด๋‹ค ํด๋ž˜์Šค ๊ณ„์ธต๊ตฌ์กฐ๋ฅผ ํ™œ์šฉํ•ด๋ผ
      • ITEM 24: ๋ฉค๋ฒ„ ํด๋ž˜์Šค๋Š” ๋˜๋„๋ก static์œผ๋กœ ๊ตฌํ˜„ํ•ด๋ผ
      • ITEM 25: ํ†ฑ๋ ˆ๋ฒจ ํด๋ž˜์Šค๋Š” ํ•œ ํŒŒ์ผ์— ํ•˜๋‚˜๋งŒ ์ƒ์„ฑํ•ด๋ผ.
      • ITEM 26: Raw type์€ ์‚ฌ์šฉํ•˜์ง€ ๋งˆ๋ผ
      • ITEM 27: ๋น„๊ฒ€์‚ฌ ๊ฒฝ๊ณ ๋ฅผ ์ œ๊ฑฐํ•ด๋ผ
      • ITEM 28: ๋ฐฐ์—ด๋ณด๋‹ค๋Š” ๋ฆฌ์ŠคํŠธ๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 29: ์ด์™•์ด๋ฉด ์ œ๋„ค๋ฆญ ํƒ€์ž…์œผ๋กœ ๋งŒ๋“ค์–ด๋ผ
      • ITEM 30: ์ด์™•์ด๋ฉด ์ œ๋„ค๋ฆญ ๋ฉ”์„œ๋“œ๋กœ ๋งŒ๋“ค์–ด๋ผ
      • ITEM 31 : ํ•œ์ •์  ์™€์ผ๋“œ์นด๋“œ๋ฅผ ์‚ฌ์šฉํ•ด API ์œ ์—ฐ์„ฑ์„ ๋†’์—ฌ๋ผ
      • ITEM 32: ์ œ๋„ค๋ฆญ๊ณผ ๊ฐ€๋ณ€์ธ์ˆ˜๋ฅผ ํ•จ๊ป˜ ์“ธ ๋•Œ๋Š” ์‹ ์ค‘ํ•ด๋ผ
      • ITEM 33: ํƒ€์ž… ์•ˆ์ „ ์ด์ข… ์ปจํ…Œ์ด๋„ˆ๋ฅผ ๊ณ ๋ คํ•ด๋ผ
      • ITEM 34: int ์ƒ์ˆ˜ ๋Œ€์‹  ์—ด๊ฑฐ ํƒ€์ž…์„ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 35: ordinal ๋ฉ”์„œ๋“œ ๋Œ€์‹  ์ธ์Šคํ„ด์Šค ํ•„๋“œ๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 36: ๋น„ํŠธ ํ•„๋“œ ๋Œ€์‹  EnumSet์„ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 37: ordinal ์ธ๋ฑ์‹ฑ ๋Œ€์‹  EnumMap์„ ์‚ฌ์šฉํ•ด๋ผ
      • TEM 38 : ํ™•์žฅํ•  ์ˆ˜ ์žˆ๋Š” ์—ด๊ฑฐํƒ€์ž…์ด ํ•„์š”ํ•˜๋ฉด ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 39: ๋ช…๋ช… ํŒจํ„ด๋ณด๋‹ค ์• ๋„ˆํ…Œ์ด์…˜์„ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 40: @Override ์–ด๋…ธํ…Œ์ด์…˜์„ ์ผ๊ด€๋˜๊ฒŒ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 41: ์ •์˜ํ•˜๋ ค๋Š” ๊ฒƒ์ด ํƒ€์ž…์ด๋ผ๋ฉด ๋งˆ์ปค ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 42: ์ต๋ช… ํด๋ž˜์Šค๋ณด๋‹ค๋Š” ๋žŒ๋‹ค๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 43: ๋žŒ๋‹ค๋ณด๋‹ค๋Š” ๋ฉ”์„œ๋“œ ์ฐธ์กฐ๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 44: ํ‘œ์ค€ ํ•จ์ˆ˜ํ˜• ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 45: ์ŠคํŠธ๋ฆผ์€ ์ฃผ์˜ํ•ด์„œ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 46: ์ŠคํŠธ๋ฆผ์—์„œ ๋ถ€์ž‘์šฉ ์—†๋Š” ํ•จ์ˆ˜๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 47: ๋ฐ˜ํ™˜ ํƒ€์ž…์œผ๋กœ๋Š” ์ŠคํŠธ๋ฆผ๋ณด๋‹ค ์ปฌ๋ ‰์…˜์ด ๋‚ซ๋‹ค.
      • ITEM 48: ์ŠคํŠธ๋ฆผ ๋ณ‘๋ ฌํ™”๋Š” ์ฃผ์˜ํ•ด์„œ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 49: ๋งค๊ฐœ๋ณ€์ˆ˜๊ฐ€ ์œ ํšจํ•œ์ง€ ๊ฒ€์‚ฌํ•ด๋ผ
      • ITEM 50: ์ ์‹œ์— ๋ฐฉ์–ด์  ๋ณต์‚ฌ๋ณธ์„ ๋งŒ๋“ค์–ด๋ผ
      • ITEM 51: ๋ฉ”์„œ๋“œ ์‹œ๊ทธ๋‹ˆ์ฒ˜๋ฅผ ์‹ ์ค‘ํžˆ ์„ค๊ณ„ํ•ด๋ผ
      • ITEM 52: ๋‹ค์ค‘์ •์˜๋Š” ์‹ ์ค‘ํžˆ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 53: ๊ฐ€๋ณ€์ธ์ˆ˜๋Š” ์‹ ์ค‘ํžˆ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 54: null์ด ์•„๋‹Œ, ๋นˆ ์ปฌ๋ ‰์…˜์ด๋‚˜ ๋ฐฐ์—ด์„ ๋ฐ˜ํ™˜ํ•ด๋ผ
      • ITEM 55: Optional ๋ฐ˜ํ™˜์€ ์‹ ์ค‘ํ•˜๊ฒŒ ํ•ด๋ผ
      • ITEM 56: ๊ณต๊ฐœ๋œ API ์š”์†Œ์—๋Š” ํ•ญ์ƒ ์ฃผ์„์„ ์ž‘์„ฑํ•ด๋ผ
      • ITEM 57: ์ง€์—ญ๋ณ€์ˆ˜์˜ ๋ฒ”์œ„๋ฅผ ์ตœ์†Œํ™”ํ•ด๋ผ
      • ITEM 58: ์ „ํ†ต์ ์ธ for ๋ฌธ๋ณด๋‹ค๋Š” for-each๋ฌธ์„ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 59: ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์ตํžˆ๊ณ  ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 60: ์ •ํ™•ํ•œ ๋‹ต์ด ํ•„์š”ํ•˜๋‹ค๋ฉด float์™€ double์€ ํ”ผํ•ด๋ผ
      • ITEM 61: ๋ฐ•์‹ฑ๋œ ๊ธฐ๋ณธ ํƒ€์ž…๋ณด๋‹ค๋Š” ๊ธฐ๋ณธ ํƒ€์ž…์„ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 62: ๋‹ค๋ฅธ ํƒ€์ž…์ด ์ ์ ˆํ•˜๋‹ค๋ฉด ๋ฌธ์ž์—ด ์‚ฌ์šฉ์„ ํ”ผํ•ด๋ผ
      • ITEM 63: ๋ฌธ์ž์—ด ์—ฐ๊ฒฐ์€ ๋А๋ฆฌ๋‹ˆ ์ฃผ์˜ํ•ด๋ผ
      • ITEM 64: ๊ฐ์ฒด๋Š” ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์‚ฌ์šฉํ•ด ์ฐธ์กฐํ•ด๋ผ
      • ITEM 65: ๋ฆฌํ”Œ๋ ‰์…˜๋ณด๋‹ค๋Š” ์ธํ„ฐํŽ˜์ด์Šค๋ฅผ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 66: ๋„ค์ดํ‹ฐ๋ธŒ ๋ฉ”์„œ๋“œ๋Š” ์‹ ์ค‘ํžˆ ์‚ฌ์šฉํ•ด๋ผ
      • ITEM 67: ์ตœ์ ํ™”๋Š” ์‹ ์ค‘ํžˆ ํ•ด๋ผ
      • ITEM 68: ์ผ๋ฐ˜์ ์œผ๋กœ ํ†ต์šฉ๋˜๋Š” ๋ช…๋ช… ๊ทœ์น™์„ ๋”ฐ๋ผ๋ผ
    • ๊ฐ์ฒด์ง€ํ–ฅ ์„ค๊ณ„ ์›์น™(SOLID)
    • ๋””์ž์ธํŒจํ„ด
      • Strategy Pattern
      • Template Method Pattern
      • Factory Method Pattern
      • Singleton
      • Delegation
      • Proxy
      • Adapter Pattern
    • ์‹ค์Šต
      • ์ธํ„ฐํŽ˜์ด์Šค ์‹ค์Šต - Vehicle
      • ์ธํ„ฐํŽ˜์ด์Šค ์‹ค์Šต - Remote
      • GUI ์‹ค์Šต - Calculator
      • GUI ์‹ค์Šต - button
      • GUI ์‹ค์Šต - lotto
      • Thread ์‹ค์Šต - ์ขŒ์„์˜ˆ์•ฝ, ๋ฉ”์„ธ์ง€๋ณด๋‚ด๊ธฐ
    • Jar vs War
  • ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค
    • KEY
    • Index
    • Transaction
    • Trigger
    • Procedure / Function
    • Package
    • ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ๋ฐฐ์›€ํ„ฐ
      • ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์‹œ์Šคํ…œ
      • ๊ด€๊ณ„๋ฐ์ดํ„ฐ ๋ชจ๋ธ
      • ๊ด€๊ณ„๋Œ€์ˆ˜์™€ SQL
    • MySQL
      • Database๋ž€
      • MySQL ์‹œ์ž‘ํ•˜๊ธฐ
      • MySQL Database
      • MySQL Table
      • CRUD
      • ๊ด€๊ณ„ํ˜• ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค
      • Server์™€ Client
    • PostgreSQL
    • NoSQL
      • Install Cassandra on mac
      • Cassandra๋ž€?
      • NiFi๋ž€
  • Algorithm
    • String
    • Recursion
    • Dynamic Programming
    • Array, Struct, Pointer
    • Math
    • Sort
    • List
    • Stack
    • Queue
    • Graph
    • Tree
    • Maze
    • AVL
    • ์ด์ง„ํƒ์ƒ‰ํŠธ๋ฆฌ(Binary Search Tree)
    • DFS์™€ BFS
    • ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜(Dijkstra's Algorithm)
    • Red-Black ํŠธ๋ฆฌ
    • A* ์•Œ๊ณ ๋ฆฌ์ฆ˜
    • Heap
    • Huffman Coding
    • Priority Queue
    • Bellman-Ford ์•Œ๊ณ ๋ฆฌ์ฆ˜
    • C++
      • Class
      • STL
        • STL pair
        • STL Container - Associate Container
        • STL Container - Sequence Container
        • STL Container - Container Adapter
  • JavaScript
    • JABASCRIPT BASIC
    • Shallow Copy vs Deep Copy
    • OBJECT MODEL
    • NODE
    • ๋™๊ธฐ ์ฒ˜๋ฆฌ vs ๋น„๋™๊ธฐ ์ฒ˜๋ฆฌ
    • AJAX
    • CALLBACK
    • PROMISE
    • DEFERRER
    • UNDERSCORE
    • WEBPACK
    • SCOPE
    • EXECUTION CONTEXT
    • Image Object
    • BFCache๋ž€?
    • history.scrollRestoration
    • Intersection Observer
    • JWT - JSON Web Token
    • HTML vs JSON
  • Vue.js
    • ํ™˜๊ฒฝ์„ค์ •
    • Vue.js๋ž€?
    • Vue Instance
    • Vue Component
    • Vue Router
    • HTTP ํ†ต์‹ 
    • Template
    • Single File Component
    • Vue Animation
    • Vuex
    • Djnago์™€ ์—ฐ๋™ํ•˜๊ธฐ
  • Backbone.js
    • Model
    • Collection
    • Sync
    • view
  • Node.js
    • Doit! - ๋…ธ๋“œ๋กœ ๋งŒ๋“ค ์ˆ˜ ์žˆ๋Š” ๋Œ€ํ‘œ์ ์ธ ์„œ๋ฒ„์™€ ์šฉ๋„
    • Doit! - ๋…ธ๋“œ์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๊ณ  ๊ฐœ๋ฐœ ๋„๊ตฌ ์„ค์น˜ํ•˜๊ธฐ
    • Doit! - ๋…ธ๋“œ ๊ฐ„๋‹จํ•˜๊ฒŒ ์‚ดํŽด๋ณด๊ธฐ
    • Doit! - ๋…ธ๋“œ์˜ ์ž๋ฐ”์Šคํฌ๋ฆฝํŠธ์™€ ์นœํ•ด์ง€๊ธฐ
    • Doit! - ๋…ธ๋“œ์˜ ๊ธฐ๋ณธ ๊ธฐ๋Šฅ ์•Œ์•„๋ณด๊ธฐ
    • Doit! - ์›น ์„œ๋ฒ„ ๋งŒ๋“ค๊ธฐ
    • Doit! - ๋ฐ์ดํ„ฐ๋ฒ ์ด์Šค ์‚ฌ์šฉํ•˜๊ธฐ
    • Doit! - ์ต์Šคํ”„๋ ˆ์Šค ํ”„๋กœ์ ํŠธ๋ฅผ ๋ชจ๋“ˆํ™”ํ•˜๊ธฐ
    • Doit! - ๋ทฐ ํ…œํ”Œ๋ฆฟ ์ ์šฉํ•˜๊ธฐ
    • Doit! - ํŒจ์ŠคํฌํŠธ๋กœ ์‚ฌ์šฉ์ž ์ธ์ฆํ•˜๊ธฐ
    • Doit! - ์ฑ„ํŒ…์„œ๋ฒ„ ๋งŒ๋“ค๊ธฐ
    • Doit! - JSON-RPC ์„œ๋ฒ„ ๋งŒ๋“ค๊ธฐ
  • Python
    • Warning-Could not import the lzma module
    • Pandas
      • Pandas ์ž๋ฃŒ๊ตฌ์กฐ
      • Pandas ๋ฐ์ดํ„ฐ ์ž…์ถœ๋ ฅ
      • DataFrame Data ์‚ดํŽด๋ณด๊ธฐ
      • ์‹œ๊ฐํ™” ๋„๊ตฌ - Matplotlib
  • ML
    • ์ถ”์ฒœ ์‹œ์Šคํ…œ
      • Collaborative Filtering
      • Matrix Factorization
  • Django
    • Basic
      • ํ™˜๊ฒฝ์„ค์ •
      • About Django
      • Start Django Project
      • Secret Key ๊ด€๋ฆฌํ•˜๊ธฐ
      • Settings ๋ถ„๋ฆฌํ•˜๊ธฐ
      • Django App
      • Django View & URL (1)
      • Django Model
        • MySQL ์—ฐ๋™
      • Django Admin
      • Django View & URL (2)
      • Django Template
      • Django Template & View & URL
      • Django Static
      • Django form
    • Advanced
      • Django Generic View
      • Django Automated Testing
      • Django Extenstion Template
      • Django Model Package
      • Django OpenSSL setting
    • REST framework
      • Rest API
      • Serializers
      • ViewSet
    • Error
      • ํ™˜๊ฒฝ์„ค์ • zlib ์˜ค๋ฅ˜๋ฐœ์ƒ
      • ModuleNotFoundError
    • ํŒจํ‚ค์ง€
      • django-debug-toolbar
    • Vue.js ์—ฐ๋™ํ•˜๊ธฐ
  • Ruby
    • variable & input/output
    • ์กฐ๊ฑด๋ฌธ
    • ๋ฐ˜๋ณต๋ฌธ
    • Array & Hash
    • Method
    • Proc&Lamda
    • Class
  • Ruby on Rails
    • Scaffolding
    • Controller
    • Model
    • Model-M:N relation
    • Model Validation
    • ๋ฉ‹์‚ฌ 10์ฃผ์ฐจ ์ˆ˜์—…(Tip)
  • HTML/CSS
    • Udacity - Intro to HTML/CSS
    • Udacity - Responsive Web Design
    • Udacity - Responsive Images
    • HTML Basic
    • CSS Basic
    • HTML5 Sementic Tag
    • HTML ํ…์ŠคํŠธ ๊ด€๋ จ ํƒœ๊ทธ๋“ค
    • HTML5 ๋ฉ€ํ‹ฐ๋ฏธ๋””์–ด
    • HTML ํผ ๊ด€๋ จ ํƒœ๊ทธ๋“ค
    • ํ…์ŠคํŠธ ๊ด€๋ จ ์Šคํƒ€์ผ
    • ์ƒ‰์ƒ๊ณผ ๋ฐฐ๊ฒฝ์„ ์œ„ํ•œ ์Šคํƒ€์ผ
    • ๋ ˆ์ด์•„์›ƒ์„ ์œ„ํ•œ ์Šคํƒ€์ผ
    • CSS ํฌ์ง€์…”๋‹
    • ๋‹ค์žฌ๋‹ค๋Šฅํ•œ CSS3 ์„ ํƒ์ž
    • CSS์™€ ์• ๋‹ˆ๋ฉ”์ด์…˜
    • ๋ฐ˜์‘ํ˜• ์›น์ด๋ž€?
  • OS(์šด์˜์ฒด์ œ)
    • Linux
      • Daemon
      • Cron
      • ํ”„๋กœ์„ธ์Šค ๊ด€๋ จ ๋ช…๋ น์–ด
      • ํ…์ŠคํŠธ ํŒŒ์ผ ๋ช…๋ น์–ด
  • Network
    • ๋„คํŠธ์›Œํฌ ๊ธฐ๋ณธ ๊ฐœ๋…
    • ๋„คํŠธ์›Œํฌ ๊ธฐ๋ณธ ๊ทœ์น™
    • ๋ฌผ๋ฆฌ ๊ณ„์ธต
    • ๋ฐ์ดํ„ฐ ๋งํฌ ๊ณ„์ธต
    • ๋„คํŠธ์›Œํฌ ๊ณ„์ธต
    • ์ „์†ก ๊ณ„์ธต
    • ์‘์šฉ ๊ณ„์ธต
    • ๋„คํŠธ์›Œํฌ ์ „์ฒด ํ๋ฆ„
    • ๋ฌด์„  ๋žœ
  • IT ๊ธฐํƒ€์ง€์‹
    • NAS๋ž€
Powered by GitBook
On this page
  • ์Šคํƒ์˜ ๊ตฌํ˜„
  • ๋ฐฐ์—ด
  • ์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ
  • ์‹ค์Šต
  • ๊ด„ํ˜ธ(VPS)
  • ๊ด„ํ˜ธ ์šฐ์„ ์ˆœ์œ„
  • ์‡ ๋ง‰๋Œ€๊ธฐ
  • ์—๋””ํ„ฐ
  • ํ›„์œ„ ํ‘œ๊ธฐ์‹
  • ์ค‘์œ„ ํ‘œ๊ธฐ์‹ โ†’ ํ›„์œ„ ํ‘œ๊ธฐ์‹

Was this helpful?

  1. Algorithm

Stack

PreviousListNextQueue

Last updated 4 years ago

Was this helpful?

์Šคํƒ์€ ํ•œ์ชฝ ๋์—์„œ๋งŒ ์ž๋ฃŒ๋ฅผ ๋„ฃ๊ณ  ๋บ„ ์ˆ˜ ์žˆ๋Š” ์ž๋ฃŒ๊ตฌ์กฐ์ด๋‹ค.

  • LIFO(Last In First Out) ๋งˆ์ง€๋ง‰์œผ๋กœ ๋„ฃ์€ ๊ฒƒ์ด ๊ฐ€์žฅ ๋จผ์ € ๋‚˜์˜จ๋‹ค. ์ฆ‰, ์ž…๋ ฅ์ˆœ์„œ์™€ ์—ญ์ˆœ์˜ ์ถœ๋ ฅ์ด ํ•„์š”ํ•œ ๊ฒฝ์šฐ์— ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ข‹๋‹ค.

    • ์—๋””ํ„ฐ์—์„œ ๋˜๋Œ๋ฆฌ๊ธฐ(undo) ๊ธฐ๋Šฅ

    • ํ•จ์ˆ˜ ํ˜ธ์ถœ ์‹œ ๋ณต๊ท€์ฃผ์†Œ ๊ธฐ์–ต

์—ฐ์‚ฐ

์„ค๋ช…

push

์Šคํƒ์— ์ž๋ฃŒ๋ฅผ ๋„ฃ๋Š” ์—ฐ์‚ฐ

pop

์Šคํƒ์—์„œ ์ž๋ฃŒ๋ฅผ ๋นผ๋Š” ์—ฐ์‚ฐ

top / peak

์Šคํƒ์˜ ๊ฐ€์žฅ ์œ„์— ์žˆ๋Š” ์ž๋ฃŒ๋ฅผ ๋ณด๋Š” ์—ฐ์‚ฐ

empty

์Šคํƒ์ด ๋น„์–ด์žˆ๋Š”์ง€ ์•„๋‹Œ์ง€๋ฅผ ์•Œ์•„๋ณด๋Š” ์—ฐ์‚ฐ

full

์Šคํƒ์ด ํฌํ™”์ƒํƒœ์ธ์ง€ ๊ฒ€์‚ฌํ•˜๋Š” ์—ฐ์‚ฐ

size

์Šคํƒ์— ์ €์žฅ๋˜์–ด์žˆ๋Š” ์ž๋ฃŒ์˜ ๊ฐœ์ˆ˜๋ฅผ ์•Œ์•„๋ณด๋Š” ์—ฐ์‚ฐ

์Šคํƒ์˜ ๊ตฌํ˜„

๋ฐฐ์—ด

  • ์žฅ์  : 1์ฐจ์› ๋ฐฐ์—ด๋กœ ์‰ฝ๊ฒŒ ๊ตฌํ˜„ํ•  ์ˆ˜ ์žˆ๋‹ค.

  • ๋‹จ์  : ๋ฌผ๋ฆฌ์ ์œผ๋กœ ํฌ๊ธฐ๊ฐ€ ๊ณ ์ •๋œ ๋ฐฐ์—ด์„ ์‚ฌ์šฉํ•˜๋ฏ€๋กœ ์Šคํƒ์˜ ํฌ๊ธฐ ๋ณ€๊ฒฝ์ด ์–ด๋ ต๋‹ค.

#include <stdio.h>
#define MAX 20

typedef struct{
    int stack[MAX];
    int top;    //stack์ด ๋น„์–ด์žˆ์„ ๊ฒฝ์šฐ -1
}StackType;

void init(StackType *s);
int is_full(StackType *s);
int is_empty(StackType *s);
int peak(StackType *s);
void push(StackType *s, int );
int pop(StackType *s);
//์Šคํƒ ์ดˆ๊ธฐํ™”
void init(StackType *s){
    s->top = -1;
}

int is_empty(StackType *s){
    return (s->top == -1);
}

int is_full(StackType *s){
    return (s->top == MAX-1);
}

int peak(StackType *s){
    if(is_empty(s)){
        printf("์Šคํƒ์ด ๋น„์–ด์žˆ์Šต๋‹ˆ๋‹ค.");
        return -1;
    }else return s->stack[s->top];
}

void push(StackType *s, int data){
    if(is_full(s)){
        printf("์Šคํƒ์— ๊ณต๊ฐ„์ด ์—†์Šต๋‹ˆ๋‹ค.");
    }else{
        s->stack[++s->top]=data;
    }
}

int pop(StackType *s){
    if(is_empty(s)){
        printf("์Šคํƒ์ด ๋น„์–ด์žˆ์Šต๋‹ˆ๋‹ค.");
        return -1;
    }else{
        return s->stack[s->top--];
    }
}
#include <iostream>
#include <string>
using namespace std;
struct Stack {
    int data[10000];
    int size;
    Stack() {
        size = 0;
    }
    void push(int num) {
        data[size] = num;
        size += 1;
    }
    bool empty() {
        if (size == 0) {
            return true;
        } else {
            return false;
        }
    }
    int pop() {
        if (empty()) {
            return -1;
        } else {
            size -= 1;
            return data[size];
        }
    }
    int top() {
        if (empty()) {
            return -1;
        } else {
            return data[size-1];
        }
    }
};
int main() {
    int n;
    cin >> n;

    Stack s;

    while (n--) {
        string cmd;
        cin >> cmd;
        if (cmd == "push") {
            int num;
            cin >> num;
            s.push(num);
        } else if (cmd == "top") {
            cout << (s.empty() ? -1 : s.top()) << '\n';
        } else if (cmd == "size") {
            cout << s.size << '\n';
        } else if (cmd == "empty") {
            cout << s.empty() << '\n';
        } else if (cmd == "pop") {
            cout << (s.empty() ? -1 : s.top()) << '\n';
            if (!s.empty()) {
                s.pop();
            }
        }
    }
    return 0;
}
# ํŒŒ์ด์ฌ์—์„œ๋Š” ์Šคํƒ์„ ์ด์šฉํ•  ๋•Œ ๋ณ„๋„์˜ ๋ผ์ด๋ธŒ๋Ÿฌ๋ฆฌ๋ฅผ ์‚ฌ์šฉํ•  ํ•„์š” ์—†์Œ.
# ๊ธฐ๋ณธ ๋ฆฌ์ŠคํŠธ์—์„œ append(), pop() ๋ฉ”์„œ๋“œ๋ฅผ ์ด์šฉํ•˜๋ฉด ์Šคํƒ๊ณผ ๋™์ผํ•˜๊ฒŒ ๋™์ž‘

stack = []

stack.append(1)
stack.appned(5)
stack.pop()

์—ฐ๊ฒฐ ๋ฆฌ์ŠคํŠธ

  • ์žฅ์  : ํฌ๊ธฐ๊ฐ€ ์ œํ•œ๋˜์ง€ ์•Š๋Š”๋‹ค.

  • ๋‹จ์  : ๊ตฌํ˜„์ด ๋ณต์žกํ•˜๊ณ  ์‚ฝ์ž…์ด๋‚˜ ์‚ญ์ œ ์‹œ๊ฐ„์ด ์˜ค๋ž˜๊ฑธ๋ฆฐ๋‹ค.

#include <stdio.h>
#include <stdlib.h>

typedef struct stack{
    int data;
    struct stack * next;
}Stack;

void init(Stack *s);
int is_empty(Stack *s);
int peak(Stack *s);
void push(Stack **,Stack **, int );
void pop(Stack **,Stack **);
#include "stack_list.h"

Node * new_node(int data){
    Node * new = (Node *)malloc(sizeof(Node));
    new->next=NULL;
    new->data = data;
    return new;
}

//์Šคํƒ ์ดˆ๊ธฐํ™”
void init(Stack *s){
    s = NULL;
}

int is_empty(Stack *s){
    return (s == NULL);
}

int peak(Stack *s){
    if(is_empty(s)){
        printf("์Šคํƒ์ด ๋น„์–ด์žˆ์Šต๋‹ˆ๋‹ค.");
        return -1;
    }else return s->data;
}

void push(Stack **top, int data){
    Stack * new;
    if(is_empty(*top)){
        new=new_node(data);
    }
    else{
        new = new_node(data);
        new->next = *top;
    }
    *top=new;
}

void pop(Stack **top){

    Node * p = *top;

    if(is_empty(p)){
        printf("์Šคํƒ์ด ๋น„์–ด์žˆ์Šต๋‹ˆ๋‹ค.\n");
        return ;
    }
    *top = p->next;
    free(p);
}

๊ตฌํ˜„ํ•˜๋Š” ๊ฒƒ๋ณด๋‹ค ์งœ์—ฌ์ ธ ์žˆ๋Š” ๊ฒƒ์„ ์“ฐ๋Š”๊ฒŒ ์ข‹๋‹ค.

#include <iostream>
#include <stack>
#include <string>
using namespace std;


int main ()
{
    stack<int> mystack;
    int n;
    scanf("%d",&n);

    while(n--){
        string ss;
        cin >> ss;

        if(ss=="push"){
            int num;
            scanf("%d",&num);
            mystack.push(num);
        } else if(ss=="top"){
            cout << (mystack.empty() ? -1 : mystack.top())<<"\n";
        } else if(ss=="size"){
            cout << mystack.size()<<"\n";
        } else if(ss=="empty"){
            cout << mystack.empty()<<"\n";
        } else if(ss=="pop"){
            cout << (mystack.empty() ? -1 : mystack.top())<<"\n";
            if(!mystack.empty()){
                mystack.pop();
            }
        }
    }
}

์‹ค์Šต

๊ด„ํ˜ธ(VPS)

  • ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์˜ ์˜ˆ์‹œ

    • ()

    • (())()

    • ((()))

  • ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ด ์•„๋‹Œ ์˜ˆ

    • (()(

    • (()()))

    • (()

์Šคํƒ์„ ์ด์šฉํ•ด์„œ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ธ์ง€ ์•„๋‹Œ์ง€ ์•Œ ์ˆ˜ ์žˆ๋‹ค. 1. (๊ฐ€ ๋‚˜์˜ค๋ฉด ์Šคํƒ์— ๋„ฃ๋Š”๋‹ค. 2. )๊ฐ€ ๋‚˜์˜ค๋ฉด ์Šคํƒ์—์„œ ํ•˜๋‚˜๋ฅผ ๋นผ์„œ (์ธ์ง€ ํ™•์ธํ•œ๋‹ค.

์‹œ๊ฐ„๋ณต์žก๋„ O(N^2)

=> ์Šคํƒ์„ ์ด์šฉํ•ด์„œ O(N)์„ O(1)๋กœ ์ค„์ผ ์ˆ˜ ์žˆ๋‹ค.

[์˜ˆ์‹œ]

  • (())()

    ์Šคํƒ: (

  • (())()

    ์Šคํƒ: ((

  • (())()

    ์Šคํƒ: (

  • (())()

    ์Šคํƒ:

  • (())()

    ์Šคํƒ: (

  • (())()

    ์Šคํƒ:

๋ชจ๋“  ๊ณผ์ •์ด ๋๋‚œ ํ›„ ์Šคํƒ์ด ๋น„์–ด์žˆ์œผ๋ฏ€๋กœ ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ด๋‹ค. ๋งŒ์•ฝ ๋ชจ๋“  ๊ณผ์ •์ด ๋๋‚œ ํ›„ ์Šคํƒ์ด ๋น„์–ด์žˆ์ง€ ์•Š์œผ๋ฉด ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ด ์•„๋‹ˆ๋‹ค.

๊ทธ๋Ÿฌ๋ฏ€๋กœ ์Šคํƒ์— ๋ช‡๊ฐœ(size)๊ฐ€ ๋“ค์–ด๊ฐ€ ์žˆ๋Š”์ง€๊ฐ€ ์ค‘์š”ํ•˜๋‹ค!

#include <iostream>
#include <stack>
#include <string>
using namespace std;

string valid(string s){
    int cnt=0;
    for(int i=0;i<=s.size();i++){
        if(s[i]=='('){
            cnt += 1;
        }else if(s[i]==')'){
            cnt -= 1;
        }
        if (cnt < 0) {
            return "NO";
        }
    }
    if (cnt == 0) {
        return "YES";
    }else{
        return "NO";
    }
}
int main(){
    int t;
    cin >> t;

    while(t--){
        string ps;
        cin >> ps;

        cout<<valid(ps)<<"\n";
    }
}

๊ด„ํ˜ธ ์šฐ์„ ์ˆœ์œ„

  • ๊ทœ์น™

    1. ๋Œ€๊ด„ํ˜ธ'[]'๋Š” ์ค‘๊ด„ํ˜ธ'{}', ์†Œ๊ด„ํ˜ธ'()' ์•ˆ์— ์˜ฌ ์ˆ˜ ์—†๋‹ค.

    2. ์ค‘๊ด„ํ˜ธ๋Š” ์†Œ๊ด„ํ˜ธ ์•ˆ์— ์˜ฌ ์ˆ˜ ์—†๋‹ค.

    3. ์—ฌ๋Š” ๊ด„ํ˜ธโ€™(โ€˜,โ€™{โ€˜,โ€™[โ€˜๊ฐ€ ๋‚˜์˜ค๋ฉด ์Šคํƒ์— ๋„ฃ๋Š”๋‹ค.

    4. ๋‹ซํžŒ ๊ด„ํ˜ธ โ€˜)โ€™,โ€™}โ€™,โ€™]โ€™๊ฐ€ ๋‚˜์˜ค๋ฉด ์Šคํƒ์—์„œ ๋บ€๋‹ค. pop() ์ด๋•Œ, ์Šคํƒ์˜ top์ด ๊ด„ํ˜ธ ์ง์ด ๋งž์•„์•ผํ•œ๋‹ค.

    5. ๋‹ซํžŒ ๊ด„ํ˜ธ๊ฐ€ ๋‚˜์™”์„ ๋•Œ ์Šคํƒ์ด ๋น„์–ด์žˆ๋‹ค๋ฉด ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ด ์•„๋‹ˆ๋‹ค.

    6. ๋ชจ๋“  ๊ณผ์ •์ด ๋๋‚œ ํ›„ ์Šคํƒ์ด ๋น„์–ด์žˆ์œผ๋ฏ€๋กœ ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ด๋‹ค. ๋งŒ์•ฝ ๋ชจ๋“  ๊ณผ์ •์ด ๋๋‚œ ํ›„ ์Šคํƒ์ด ๋น„์–ด์žˆ์ง€ ์•Š์œผ๋ฉด ์˜ฌ๋ฐ”๋ฅธ ๊ด„ํ˜ธ ๋ฌธ์ž์—ด์ด ์•„๋‹ˆ๋‹ค.

int check(char c,Node **top){
    switch (c) {
        case '(':
            push(top, 2);
            break;
        case '{':
            if(is_empty(*top))push(top, 1);
            else{
                if(peak(*top)==2){
                    printf("[๊ทœ์น™2]์‹คํŒจ\n");
                    return -1;
                }
                push(top, 1);
            }
            break;
        case '[':
            if(is_empty(*top))push(top, 0);
            else{
                if(peak(*top)!=0){
                    printf("[๊ทœ์น™1]์‹คํŒจ\n");
                    return -1;
                }
                push(top, 0);
            }
            break;
        case ')':
            if(is_empty(*top)){
                printf("[๊ทœ์น™5]์‹คํŒจ\n");
                return -1;
            }else if(peak(*top)!=2){
                printf("[๊ทœ์น™4]์‹คํŒจ\n");
                return -1;
            }
            pop(top);
            break;
        case '}':
            if(is_empty(*top)){
                printf("[๊ทœ์น™5]์‹คํŒจ\n");
            }else if(peak(*top)!=1){
                printf("[๊ทœ์น™4]์‹คํŒจ\n");
                return -1;
            }
            pop(top);
            break;
        case ']':
            if(is_empty(*top)){
                printf("[๊ทœ์น™5]์‹คํŒจ\n");
            }else if(peak(*top)!=0){
                printf("[๊ทœ์น™4]์‹คํŒจ\n");
                return -1;
            }
            pop(top);
            break;
        default:
            printf("์ž˜๋ชป ์ž…๋ ฅ ํ–ˆ์Šต๋‹ˆ๋‹ค.\n");
            break;
    }
    return 1;
}

int main(int argc, const char * argv[]) {

    Stack * top = NULL;
    int res = 0;
    char c;

    printf("๊ฐ’์„ ์ž…๋ ฅํ•ด์ฃผ์„ธ์š”. : ");
    while ((c = getchar()) && c != EOF && c!='\n') {
        res = check(c, &top);
        if(res==-1)break;
        if(peak(top)!=-1)printf("์Šคํƒ top : %c\n",bracket[peak(top)]);
    }

    if(res!=-1){
        if (is_empty(top)) {
            printf("\n==๊ด„ํ˜ธ ๊ฒ€์‚ฌ ์„ฑ๊ณต==\n");
        }else{
            printf("\n==[๊ทœ์น™6]์‹คํŒจ==\n");
        }
    }
}

์‡ ๋ง‰๋Œ€๊ธฐ

  • ๋ ˆ์ด์ €๋Š” ์—ฌ๋Š” ๊ด„ํ˜ธ์™€ ๋‹ซ๋Š” ๊ด„ํ˜ธ์˜ ์ธ์ ‘ํ•œ(์ธ๋ฑ์Šค ์ค‘์š”) ์Œ ()์œผ๋กœ ํ‘œํ˜„ํ•œ๋‹ค. ๋˜ํ•œ, ๋ชจ๋“  ()๋Š” ๋ฐ˜๋“œ์‹œ ๋ ˆ์ด์ €๋ฅผ ํ‘œํ˜„ํ•œ๋‹ค.

  • ์‡ ๋ง‰๋Œ€๊ธฐ์˜ ์™ผ์ชฝ ๋์€ (๋กœ, ์˜ค๋ฅธ์ชฝ ๋์€ ๋‹ซํžŒ ๊ด„ํ˜ธ)๋กœ ํ‘œํ˜„ํ•œ๋‹ค.

  • ()๊ฐ€ ๋‚˜์˜ฌ ๋•Œ๋งˆ๋‹ค ์Šคํƒ์— ๋“ค์–ด ์žˆ๋Š” (์˜ ๊ฐœ์ˆ˜๋ฅผ ์„ธ์–ด์ค€๋‹ค.

  • )๊ฐ€ ๋‚˜์™”์„ ๋•Œ๋Š” ๋ ˆ์ด์ €์ธ์ง€ ์‡ ๋ง‰๋Œ€๊ธฐ ์ธ์ง€ ๊ตฌ๋ถ„์„ ํ•ด์ค€๋‹ค.

  • ๋ ˆ์ด์ €๋Š” ํ•ญ์ƒ ๋ถ™์–ด์ง„ ์ƒํƒœ๋กœ ๋‚˜์˜ค๋ฏ€๋กœ ์Šคํƒ์˜ (์˜ ์ธ๋ฑ์Šค์™€ 1์ฐจ์ด๊ฐ€ ๋‚˜๋Š”์ง€ ํ™•์ธํ•ด์•ผํ•œ๋‹ค.

#include <iostream>
#include <stack>
#include <string>
using namespace std;

int main(){
    stack<int> s;

    int cnt=0;
    string ps;
    cin >> ps;

    for(int i=0;i<=ps.size();i++){
        if(ps[i]=='('){
            s.push(i);
        }else if(ps[i]==')'){
            if(i==s.top()+1){
                s.pop();
                cnt+=s.size();
            }else{
                s.pop();
                cnt+=1;
            }
        }
    }
    cout << cnt << "\n";
}

์—๋””ํ„ฐ

  • ์ปค์„œ๋Š” ๋ฌธ์žฅ์˜ ๋งจ ์•ž, ๋งจ ๋’ค, ์ค‘๊ฐ„ ์ž„์˜์˜ ๊ณณ์— ์œ„์ฐจํ•  ์ˆ˜ ์žˆ๋‹ค.

  • L : ์ปค์„œ๋ฅผ ์™ผ์ชฝ์œผ๋กœ ํ•œ์นธ ์˜ฎ๊น€

  • D : ์ปค์„œ๋ฅผ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ํ•œ์นธ ์˜ฎ๊น€

  • B : ์ปค์„œ ์™ผ์ชฝ์— ์žˆ๋Š” ๋ฌธ์ž๋ฅผ ์‚ญ์ œ

  • P $ : $๋ผ๋Š” ๋ฌธ์ž๋ฅผ ์ปค์„œ ์˜ค๋ฅธ์ชฝ์— ์ถ”๊ฐ€

  • ์ปค์„œ๋ฅผ ๊ธฐ์ค€์œผ๋กœ ์™ผ์ชฝ ์Šคํƒ๊ณผ ์˜ค๋ฅธ์ชฝ ์Šคํƒ์œผ๋กœ ๋‚˜๋ˆ ์„œ ๋ฌธ์ œ๋ฅผ ํ’€ ์ˆ˜ ์žˆ๋‹ค.

    abc|xyz
    (|๋Š” ์ปค์„œ)
  • L ์™ผ์ชฝ์œผ๋กœ ์˜ฎ๊น€

    ab|cxyz
  • D ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์˜ฎ๊น€

    abcx|yz
  • B ์™ผ์ชฝ ๋ฌธ์ž ์‚ญ์ œ

    ab|xyz
  • P$ $๋ฅผ ์ปค์„œ ์™ผ์ชฝ์— ์ถ”๊ฐ€ํ•˜๊ณ  ์ปค์„œ๋Š” $์˜ ์˜ค๋ฅธ์ชฝ์— ์œ„์น˜

    abcd|xyz

O(N^2)์—์„œ ์Šคํƒ์„ ์‚ฌ์šฉํ•˜๋ฉด O(N)์œผ๋กœ ์‹œ๊ฐ„๋ณต์žก๋„๊ฐ€ ์ค„์–ด๋“ ๋‹ค.

#include <cstdio>
#include <cstring>
#include <stack>
using namespace std;
char a[600000];
int main() {
    scanf("%s",a);
    stack<char> left, right;
    int n = strlen(a);
    for (int i=0; i<n; i++) {
        left.push(a[i]);
    }
    int m;
    scanf("%d",&m);
    while (m--) {
        char what;
        scanf(" %c",&what);
        if (what == 'L') {
            if (!left.empty()) {
                right.push(left.top());
                left.pop();
            }
        } else if (what == 'D') {
            if (!right.empty()) {
                left.push(right.top());
                right.pop();
            }
        } else if (what == 'B') {
            if (!left.empty()) {
                left.pop();
            }
        } else if (what == 'P') {
            char c;
            scanf(" %c",&c);
            left.push(c);
        }
    }
    while (!left.empty()) {
        right.push(left.top());
        left.pop();
    }
    while (!right.empty()) {
        printf("%c",right.top());
        right.pop();
    }
    printf("\n");
    return 0;
}

ํ›„์œ„ ํ‘œ๊ธฐ์‹

์ˆ˜์‹์˜ ํ‘œ๊ธฐ๋ฐฉ๋ฒ•

  • ์ „์œ„ ํ‘œ๊ธฐ๋ฒ• : ์—ฐ์‚ฐ์ž๋ฅผ ํ”ผ์—ฐ์‚ฐ์ž ์•ž์— ํ‘œ๊ธฐํ•˜๋Š” ๋ฐฉ๋ฒ• (+AB)

  • ์ค‘์œ„ ํ‘œ๊ธฐ๋ฒ• : ์—ฐ์‚ฐ์ž๋ฅผ ํ”ผ์—ฐ์‚ฐ์ž ์ค‘๊ฐ„์— ํ‘œ๊ธฐํ•˜๋Š” ๋ฐฉ๋ฒ• (A+B)

  • ํ›„์œ„ํ‘œ๊ธฐ๋ฒ• : ์—ฐ์‚ฐ์ž๋ฅผ ํ”ผ์—ฐ์‚ฐ์ž ๋’ค์— ํ‘œ๊ธฐํ•˜๋Š” ๋ฐฉ๋ฒ• (AB+)

์ˆ˜์‹์„ ์™ผ์ชฝ์—์„œ ์˜ค๋ฅธ์ชฝ์œผ๋กœ ์Šค์บ”ํ•˜์—ฌ

  1. ํ”ผ์—ฐ์‚ฐ์ž์ด๋ฉด ์Šคํƒ์— ์ €์žฅ

  2. ์—ฐ์‚ฐ์ž์ด๋ฉด ํ•„์š”ํ•œ ์ˆ˜๋งŒํผ์˜ ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ์Šคํƒ์—์„œ pop

  3. ์—ฐ์‚ฐ์˜ ๊ฒฐ๊ณผ๋ฅผ ๋‹ค์‹œ ์Šคํƒ์— ์ €์žฅ

์˜ˆ์ œ)82/3-32*+
01. push(8) ์Šคํƒ : 8
02. push(2) ์Šคํƒ : 8 2
03. second<-pop(2) first<-pop(8) push(first/second) ์Šคํƒ : 4
05. push(3) ์Šคํƒ : 4 3
06. second<-pop(3) first<-pop(4) push(first-second) ์Šคํƒ : 1
07. push(3) ์Šคํƒ : 1 3
08. push(2) ์Šคํƒ : 1 3 2
09. second<-pop(2) first<-pop(3) push(first*second) ์Šคํƒ : 1 6
10. second<-pop(6) first<-pop(1) push(first+second) ์Šคํƒ : 7

๊ตฌํ˜„์‹œ ์—ฐ์‚ฐ์ž๊ฐ€ ๋‚˜์™”์„ ๋•Œ pop์„ ๋‘๋ฒˆํ•  ์ˆ˜ ์žˆ๋Š”์ง€์™€ ๊ฐ™์€ ์กฐ๊ฑด์„ ๋”ฐ์ ธ์•ผํ•œ๋‹ค.

#include <stdio.h>
#include "stack_list.h"

int check(char c,  Stack **top){

    int a,b;
    if('0'<=c&& c<='9'){
        push(top, c-'0');
    }else{
        a = peak(*top);
        if(a==-1){
            printf("ํ”ผ์—ฐ์‚ฐ์ž์˜ ์ˆ˜๊ฐ€ ๋ถ€์กฑํ•ฉ๋‹ˆ๋‹ค.\n");
            return -1;
        }
        pop(top);
        b = peak(*top);
        if(b==-1){
            printf("ํ”ผ์—ฐ์‚ฐ์ž์˜ ์ˆ˜๊ฐ€ ๋ถ€์กฑํ•ฉ๋‹ˆ๋‹ค.\n");
            return -1;
        }
        pop(top);

        if(c=='+'){
            push(top, b+a);
        }else if(c=='/'){
            push(top, b/a);
        }else if(c=='*'){
            push(top, b*a);
        }else if(c=='-'){
            push(top, b-a);
        }else{
            push(top, b%a);
        }
    }
    return peak(*top);
}

int main(int argc, const char * argv[]) {
    Stack * head=NULL;
    char c;
    int result=0;
    while ((c = getchar()) && c != EOF && c!='\n') {
        result=check2(c,&head);
        if(result==-1)break;
    }
    if(result!=-1)printf("%d\n",result);
    else printf("์‹คํŒจ\n");
    return 0;
}

์ค‘์œ„ ํ‘œ๊ธฐ์‹ โ†’ ํ›„์œ„ ํ‘œ๊ธฐ์‹

  1. ์ˆ˜์‹์˜ ๊ฐ ์—ฐ์‚ฐ์ž์— ๋Œ€ํ•ด์„œ ์šฐ์„ ์ˆœ์œ„์— ๋”ฐ๋ผ ๊ด„ํ˜ธ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‹ค์‹œ ํ‘œํ˜„ํ•œ๋‹ค. ((A*B)-(C/D))

  2. ๊ฐ ์—ฐ์‚ฐ์ž๋ฅผ ๊ทธ์— ๋Œ€์‘ํ•˜๋Š” ์˜ค๋ฅธ์ชฝ ๊ด„ํ˜ธ์˜ ๋’ค๋กœ ์ด๋™์‹œํ‚จ๋‹ค.((A B)* (C D)/)-

  3. ๊ด„ํ˜ธ ์ œ๊ฑฐ AB*CD/-

์•Œ๊ณ ๋ฆฌ์ฆ˜ ๊ฐœ์š”

  1. ์™ผ์ชฝ ๊ด„ํ˜ธ๋ฅผ ๋งŒ๋‚˜๋ฉด ๋ฌด์‹œ

  2. ํ”ผ์—ฐ์‚ฐ์ž๋ฅผ ๋งŒ๋‚˜๋ฉด ์ถœ๋ ฅ

  3. ์—ฐ์‚ฐ์ž๋ฅผ ๋งŒ๋‚˜๋ฉด ์Šคํƒ์— ์‚ฝ์ž…

  4. ์˜ค๋ฅธ์ชฝ ๊ด„ํ˜ธ๋ฅผ ๋งŒ๋‚˜๋ฉด ์Šคํƒ pop

  5. ์ˆ˜์‹์ด ๋๋‚˜๋ฉด ์Šคํƒ์ด ๊ณต๋ฐฑ์ด ๋  ๋•Œ๊นŒ์ง€ pop

#include <stdio.h>
#include "stack_array.h"

void convert(char c,StackType *s){
    if(c=='(')return;
    if('0'<=c&&c<='9')printf("%d",c-'0');
    else if(c==')')printf("%c",pop(s));
    else push(s, c);
}

int main(int argc, const char * argv[]) {
    char c;
    Stack s;
    init(&s);
    while ((c = getchar()) && c != EOF) {
        if(c=='\n')break;
        convert(c, &s);
    }
    while((&s)->top!=-1){
        printf("%c",pop(&s));
    }

    return 0;
}