├── .DS_Store ├── JongManBookStudy ├── JongManBookStudy.xcodeproj │ ├── project.pbxproj │ ├── project.xcworkspace │ │ ├── contents.xcworkspacedata │ │ ├── xcshareddata │ │ │ └── IDEWorkspaceChecks.plist │ │ └── xcuserdata │ │ │ └── applebuddy.xcuserdatad │ │ │ └── UserInterfaceState.xcuserstate │ └── xcuserdata │ │ └── applebuddy.xcuserdatad │ │ ├── xcdebugger │ │ └── Breakpoints_v2.xcbkptlist │ │ └── xcschemes │ │ └── xcschememanagement.plist └── JongManBookStudy │ ├── FESTIVAL.cpp │ ├── JongManBookStudy-Bridging-Header.h │ └── mainc.swift ├── README.md ├── Structures ├── .DS_Store ├── Structures.xcodeproj │ ├── project.pbxproj │ ├── project.xcworkspace │ │ ├── contents.xcworkspacedata │ │ ├── xcshareddata │ │ │ └── IDEWorkspaceChecks.plist │ │ └── xcuserdata │ │ │ └── applebuddy.xcuserdatad │ │ │ └── UserInterfaceState.xcuserstate │ └── xcuserdata │ │ └── applebuddy.xcuserdatad │ │ ├── xcdebugger │ │ └── Breakpoints_v2.xcbkptlist │ │ └── xcschemes │ │ └── xcschememanagement.plist └── Structures │ ├── Heap │ └── Heap.cpp │ ├── LinkedList.swift │ ├── LinkedList2.swift │ ├── LinkedList3.swift │ ├── Queue │ ├── Queue.swift │ └── QueueArray.swift │ ├── Stack │ └── DoubleStack.swift │ ├── Structures-Bridging-Header.h │ ├── Tree │ ├── BinaryTree.cpp │ └── BinaryTree.swift │ └── mainc.swift └── SwiftAlgorithmStudy.playground ├── Contents.swift ├── contents.xcplayground └── playground.xcworkspace ├── contents.xcworkspacedata ├── xcshareddata └── IDEWorkspaceChecks.plist └── xcuserdata └── applebuddy.xcuserdatad └── UserInterfaceState.xcuserstate /.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/applebuddy/AlgorithmMemo/6ffe9a92468d1b14a71e6f78e695ec6af96f531b/.DS_Store -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 50; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | 07C42DBE233B6E0500072722 /* mainc.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07C42DBD233B6E0500072722 /* mainc.swift */; }; 11 | 07C42DC6233B6E1700072722 /* FESTIVAL.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 07C42DC5233B6E1700072722 /* FESTIVAL.cpp */; }; 12 | /* End PBXBuildFile section */ 13 | 14 | /* Begin PBXCopyFilesBuildPhase section */ 15 | 07C42DB8233B6E0500072722 /* CopyFiles */ = { 16 | isa = PBXCopyFilesBuildPhase; 17 | buildActionMask = 2147483647; 18 | dstPath = /usr/share/man/man1/; 19 | dstSubfolderSpec = 0; 20 | files = ( 21 | ); 22 | runOnlyForDeploymentPostprocessing = 1; 23 | }; 24 | /* End PBXCopyFilesBuildPhase section */ 25 | 26 | /* Begin PBXFileReference section */ 27 | 07C42DBA233B6E0500072722 /* JongManBookStudy */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = JongManBookStudy; sourceTree = BUILT_PRODUCTS_DIR; }; 28 | 07C42DBD233B6E0500072722 /* mainc.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = mainc.swift; sourceTree = ""; }; 29 | 07C42DC4233B6E1700072722 /* JongManBookStudy-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "JongManBookStudy-Bridging-Header.h"; sourceTree = ""; }; 30 | 07C42DC5233B6E1700072722 /* FESTIVAL.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = FESTIVAL.cpp; sourceTree = ""; }; 31 | /* End PBXFileReference section */ 32 | 33 | /* Begin PBXFrameworksBuildPhase section */ 34 | 07C42DB7233B6E0500072722 /* Frameworks */ = { 35 | isa = PBXFrameworksBuildPhase; 36 | buildActionMask = 2147483647; 37 | files = ( 38 | ); 39 | runOnlyForDeploymentPostprocessing = 0; 40 | }; 41 | /* End PBXFrameworksBuildPhase section */ 42 | 43 | /* Begin PBXGroup section */ 44 | 07C42DB1233B6E0500072722 = { 45 | isa = PBXGroup; 46 | children = ( 47 | 07C42DBC233B6E0500072722 /* JongManBookStudy */, 48 | 07C42DBB233B6E0500072722 /* Products */, 49 | ); 50 | sourceTree = ""; 51 | }; 52 | 07C42DBB233B6E0500072722 /* Products */ = { 53 | isa = PBXGroup; 54 | children = ( 55 | 07C42DBA233B6E0500072722 /* JongManBookStudy */, 56 | ); 57 | name = Products; 58 | sourceTree = ""; 59 | }; 60 | 07C42DBC233B6E0500072722 /* JongManBookStudy */ = { 61 | isa = PBXGroup; 62 | children = ( 63 | 07C42DBD233B6E0500072722 /* mainc.swift */, 64 | 07C42DC5233B6E1700072722 /* FESTIVAL.cpp */, 65 | 07C42DC4233B6E1700072722 /* JongManBookStudy-Bridging-Header.h */, 66 | ); 67 | path = JongManBookStudy; 68 | sourceTree = ""; 69 | }; 70 | /* End PBXGroup section */ 71 | 72 | /* Begin PBXNativeTarget section */ 73 | 07C42DB9233B6E0500072722 /* JongManBookStudy */ = { 74 | isa = PBXNativeTarget; 75 | buildConfigurationList = 07C42DC1233B6E0500072722 /* Build configuration list for PBXNativeTarget "JongManBookStudy" */; 76 | buildPhases = ( 77 | 07C42DB6233B6E0500072722 /* Sources */, 78 | 07C42DB7233B6E0500072722 /* Frameworks */, 79 | 07C42DB8233B6E0500072722 /* CopyFiles */, 80 | ); 81 | buildRules = ( 82 | ); 83 | dependencies = ( 84 | ); 85 | name = JongManBookStudy; 86 | productName = JongManBookStudy; 87 | productReference = 07C42DBA233B6E0500072722 /* JongManBookStudy */; 88 | productType = "com.apple.product-type.tool"; 89 | }; 90 | /* End PBXNativeTarget section */ 91 | 92 | /* Begin PBXProject section */ 93 | 07C42DB2233B6E0500072722 /* Project object */ = { 94 | isa = PBXProject; 95 | attributes = { 96 | LastSwiftUpdateCheck = 1100; 97 | LastUpgradeCheck = 1100; 98 | ORGANIZATIONNAME = MinKyeongTae; 99 | TargetAttributes = { 100 | 07C42DB9233B6E0500072722 = { 101 | CreatedOnToolsVersion = 11.0; 102 | LastSwiftMigration = 1100; 103 | }; 104 | }; 105 | }; 106 | buildConfigurationList = 07C42DB5233B6E0500072722 /* Build configuration list for PBXProject "JongManBookStudy" */; 107 | compatibilityVersion = "Xcode 9.3"; 108 | developmentRegion = en; 109 | hasScannedForEncodings = 0; 110 | knownRegions = ( 111 | en, 112 | Base, 113 | ); 114 | mainGroup = 07C42DB1233B6E0500072722; 115 | productRefGroup = 07C42DBB233B6E0500072722 /* Products */; 116 | projectDirPath = ""; 117 | projectRoot = ""; 118 | targets = ( 119 | 07C42DB9233B6E0500072722 /* JongManBookStudy */, 120 | ); 121 | }; 122 | /* End PBXProject section */ 123 | 124 | /* Begin PBXSourcesBuildPhase section */ 125 | 07C42DB6233B6E0500072722 /* Sources */ = { 126 | isa = PBXSourcesBuildPhase; 127 | buildActionMask = 2147483647; 128 | files = ( 129 | 07C42DBE233B6E0500072722 /* mainc.swift in Sources */, 130 | 07C42DC6233B6E1700072722 /* FESTIVAL.cpp in Sources */, 131 | ); 132 | runOnlyForDeploymentPostprocessing = 0; 133 | }; 134 | /* End PBXSourcesBuildPhase section */ 135 | 136 | /* Begin XCBuildConfiguration section */ 137 | 07C42DBF233B6E0500072722 /* Debug */ = { 138 | isa = XCBuildConfiguration; 139 | buildSettings = { 140 | ALWAYS_SEARCH_USER_PATHS = NO; 141 | CLANG_ANALYZER_NONNULL = YES; 142 | CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; 143 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; 144 | CLANG_CXX_LIBRARY = "libc++"; 145 | CLANG_ENABLE_MODULES = YES; 146 | CLANG_ENABLE_OBJC_ARC = YES; 147 | CLANG_ENABLE_OBJC_WEAK = YES; 148 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; 149 | CLANG_WARN_BOOL_CONVERSION = YES; 150 | CLANG_WARN_COMMA = YES; 151 | CLANG_WARN_CONSTANT_CONVERSION = YES; 152 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; 153 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 154 | CLANG_WARN_DOCUMENTATION_COMMENTS = YES; 155 | CLANG_WARN_EMPTY_BODY = YES; 156 | CLANG_WARN_ENUM_CONVERSION = YES; 157 | CLANG_WARN_INFINITE_RECURSION = YES; 158 | CLANG_WARN_INT_CONVERSION = YES; 159 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; 160 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; 161 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; 162 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 163 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; 164 | CLANG_WARN_STRICT_PROTOTYPES = YES; 165 | CLANG_WARN_SUSPICIOUS_MOVE = YES; 166 | CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; 167 | CLANG_WARN_UNREACHABLE_CODE = YES; 168 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 169 | COPY_PHASE_STRIP = NO; 170 | DEBUG_INFORMATION_FORMAT = dwarf; 171 | ENABLE_STRICT_OBJC_MSGSEND = YES; 172 | ENABLE_TESTABILITY = YES; 173 | GCC_C_LANGUAGE_STANDARD = gnu11; 174 | GCC_DYNAMIC_NO_PIC = NO; 175 | GCC_NO_COMMON_BLOCKS = YES; 176 | GCC_OPTIMIZATION_LEVEL = 0; 177 | GCC_PREPROCESSOR_DEFINITIONS = ( 178 | "DEBUG=1", 179 | "$(inherited)", 180 | ); 181 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 182 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 183 | GCC_WARN_UNDECLARED_SELECTOR = YES; 184 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 185 | GCC_WARN_UNUSED_FUNCTION = YES; 186 | GCC_WARN_UNUSED_VARIABLE = YES; 187 | MACOSX_DEPLOYMENT_TARGET = 10.14; 188 | MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; 189 | MTL_FAST_MATH = YES; 190 | ONLY_ACTIVE_ARCH = YES; 191 | SDKROOT = macosx; 192 | SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; 193 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 194 | }; 195 | name = Debug; 196 | }; 197 | 07C42DC0233B6E0500072722 /* Release */ = { 198 | isa = XCBuildConfiguration; 199 | buildSettings = { 200 | ALWAYS_SEARCH_USER_PATHS = NO; 201 | CLANG_ANALYZER_NONNULL = YES; 202 | CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; 203 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; 204 | CLANG_CXX_LIBRARY = "libc++"; 205 | CLANG_ENABLE_MODULES = YES; 206 | CLANG_ENABLE_OBJC_ARC = YES; 207 | CLANG_ENABLE_OBJC_WEAK = YES; 208 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; 209 | CLANG_WARN_BOOL_CONVERSION = YES; 210 | CLANG_WARN_COMMA = YES; 211 | CLANG_WARN_CONSTANT_CONVERSION = YES; 212 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; 213 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 214 | CLANG_WARN_DOCUMENTATION_COMMENTS = YES; 215 | CLANG_WARN_EMPTY_BODY = YES; 216 | CLANG_WARN_ENUM_CONVERSION = YES; 217 | CLANG_WARN_INFINITE_RECURSION = YES; 218 | CLANG_WARN_INT_CONVERSION = YES; 219 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; 220 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; 221 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; 222 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 223 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; 224 | CLANG_WARN_STRICT_PROTOTYPES = YES; 225 | CLANG_WARN_SUSPICIOUS_MOVE = YES; 226 | CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; 227 | CLANG_WARN_UNREACHABLE_CODE = YES; 228 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 229 | COPY_PHASE_STRIP = NO; 230 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 231 | ENABLE_NS_ASSERTIONS = NO; 232 | ENABLE_STRICT_OBJC_MSGSEND = YES; 233 | GCC_C_LANGUAGE_STANDARD = gnu11; 234 | GCC_NO_COMMON_BLOCKS = YES; 235 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 236 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 237 | GCC_WARN_UNDECLARED_SELECTOR = YES; 238 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 239 | GCC_WARN_UNUSED_FUNCTION = YES; 240 | GCC_WARN_UNUSED_VARIABLE = YES; 241 | MACOSX_DEPLOYMENT_TARGET = 10.14; 242 | MTL_ENABLE_DEBUG_INFO = NO; 243 | MTL_FAST_MATH = YES; 244 | SDKROOT = macosx; 245 | SWIFT_COMPILATION_MODE = wholemodule; 246 | SWIFT_OPTIMIZATION_LEVEL = "-O"; 247 | }; 248 | name = Release; 249 | }; 250 | 07C42DC2233B6E0500072722 /* Debug */ = { 251 | isa = XCBuildConfiguration; 252 | buildSettings = { 253 | CLANG_ENABLE_MODULES = YES; 254 | CODE_SIGN_STYLE = Automatic; 255 | DEVELOPMENT_TEAM = NF9G85TZ2T; 256 | ENABLE_HARDENED_RUNTIME = YES; 257 | LD_RUNPATH_SEARCH_PATHS = ( 258 | "$(inherited)", 259 | "@executable_path/../Frameworks", 260 | "@loader_path/../Frameworks", 261 | ); 262 | PRODUCT_NAME = "$(TARGET_NAME)"; 263 | SWIFT_OBJC_BRIDGING_HEADER = "JongManBookStudy/JongManBookStudy-Bridging-Header.h"; 264 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 265 | SWIFT_VERSION = 5.0; 266 | }; 267 | name = Debug; 268 | }; 269 | 07C42DC3233B6E0500072722 /* Release */ = { 270 | isa = XCBuildConfiguration; 271 | buildSettings = { 272 | CLANG_ENABLE_MODULES = YES; 273 | CODE_SIGN_STYLE = Automatic; 274 | DEVELOPMENT_TEAM = NF9G85TZ2T; 275 | ENABLE_HARDENED_RUNTIME = YES; 276 | LD_RUNPATH_SEARCH_PATHS = ( 277 | "$(inherited)", 278 | "@executable_path/../Frameworks", 279 | "@loader_path/../Frameworks", 280 | ); 281 | PRODUCT_NAME = "$(TARGET_NAME)"; 282 | SWIFT_OBJC_BRIDGING_HEADER = "JongManBookStudy/JongManBookStudy-Bridging-Header.h"; 283 | SWIFT_VERSION = 5.0; 284 | }; 285 | name = Release; 286 | }; 287 | /* End XCBuildConfiguration section */ 288 | 289 | /* Begin XCConfigurationList section */ 290 | 07C42DB5233B6E0500072722 /* Build configuration list for PBXProject "JongManBookStudy" */ = { 291 | isa = XCConfigurationList; 292 | buildConfigurations = ( 293 | 07C42DBF233B6E0500072722 /* Debug */, 294 | 07C42DC0233B6E0500072722 /* Release */, 295 | ); 296 | defaultConfigurationIsVisible = 0; 297 | defaultConfigurationName = Release; 298 | }; 299 | 07C42DC1233B6E0500072722 /* Build configuration list for PBXNativeTarget "JongManBookStudy" */ = { 300 | isa = XCConfigurationList; 301 | buildConfigurations = ( 302 | 07C42DC2233B6E0500072722 /* Debug */, 303 | 07C42DC3233B6E0500072722 /* Release */, 304 | ); 305 | defaultConfigurationIsVisible = 0; 306 | defaultConfigurationName = Release; 307 | }; 308 | /* End XCConfigurationList section */ 309 | }; 310 | rootObject = 07C42DB2233B6E0500072722 /* Project object */; 311 | } 312 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | IDEDidComputeMac32BitWarning 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy.xcodeproj/project.xcworkspace/xcuserdata/applebuddy.xcuserdatad/UserInterfaceState.xcuserstate: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/applebuddy/AlgorithmMemo/6ffe9a92468d1b14a71e6f78e695ec6af96f531b/JongManBookStudy/JongManBookStudy.xcodeproj/project.xcworkspace/xcuserdata/applebuddy.xcuserdatad/UserInterfaceState.xcuserstate -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy.xcodeproj/xcuserdata/applebuddy.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | 9 | 21 | 22 | 23 | 25 | 37 | 38 | 39 | 41 | 53 | 54 | 55 | 56 | 57 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy.xcodeproj/xcuserdata/applebuddy.xcuserdatad/xcschemes/xcschememanagement.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | SchemeUserState 6 | 7 | JongManBookStudy.xcscheme_^#shared#^_ 8 | 9 | orderHint 10 | 0 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy/FESTIVAL.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // FESTIVAL.cpp 3 | // JongManBookStudy 4 | // 5 | // Created by MinKyeongTae on 25/09/2019. 6 | // Copyright © 2019 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | /// MARK: - 종만북 입문 문제, FESTIVAL 10 | /// L일 이상의 연속 스케쥴을 잡으로 한다. 이떄의 최소 평균 비용을 출력하라!! 11 | 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | 18 | using namespace std; 19 | 20 | typedef pair Pair; 21 | 22 | int main() { 23 | ios_base :: sync_with_stdio(0); cin.tie(0); 24 | int T; 25 | cin >> T; 26 | while(T--) { 27 | int N, L; 28 | cin >> N >> L; 29 | vector V(N,0); 30 | Pair MIN = make_pair(2100000000,1.0); 31 | 32 | /// 입력을 받는다. 초기 성립되는 sum 값을 설정한다. 33 | for(int i=0; i> V[i]; 34 | 35 | for(int i=0; i double(sum)/cnt) { 44 | MIN.first = sum; 45 | MIN.second = cnt; 46 | } 47 | } 48 | } 49 | } 50 | printf("%.10f\n",MIN.first/MIN.second); 51 | } 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy/JongManBookStudy-Bridging-Header.h: -------------------------------------------------------------------------------- 1 | // 2 | // Use this file to import your target's public headers that you would like to expose to Swift. 3 | // 4 | 5 | -------------------------------------------------------------------------------- /JongManBookStudy/JongManBookStudy/mainc.swift: -------------------------------------------------------------------------------- 1 | // 2 | // main.swift 3 | // JongManBookStudy 4 | // 5 | // Created by MinKyeongTae on 25/09/2019. 6 | // Copyright © 2019 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | import Foundation 10 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | 2 |
3 |
4 | 5 | # 알고리즘 스터디 메모, 일기장 6 | 7 |
8 |
9 | 10 | # 개요 11 | - ✯ Swift, C++언어를 활용한 알고리즘 기능 & Tip을 정리해갑니다. 12 | 13 |
14 |
15 | 16 | # 목차 17 | 18 | ## ✤ [공통](https://github.com/applebuddy/AlgorithmMemo/blob/master/README.md#공통_알고리즘) 19 | ### - [정렬 알고리즘](https://github.com/applebuddy/AlgorithmMemo#-_알고리즘) 20 | ### - [수학 알고리즘](https://github.com/applebuddy/AlgorithmMemo#-수학_알고리즘) 21 | ### - [수학 함수](https://github.com/applebuddy/AlgorithmMemo#-수학_함수) 22 | 23 | 24 |
25 | 26 | ## ✤ [C++](https://github.com/applebuddy/AlgorithmMemo/blob/master/README.md#c_알고리즘) 27 | ### - [타입](https://github.com/applebuddy/AlgorithmMemo/blob/master/README.md#c_) 28 | ### - [자료구조](https://github.com/applebuddy/AlgorithmMemo#C++_자료구조) 29 | - [Array](https://github.com/applebuddy/AlgorithmMemo#-Array) 30 | - [Vector](https://github.com/applebuddy/AlgorithmMemo#-Vector) 31 | - [Set](https://github.com/applebuddy/AlgorithmMemo#-Set) 32 | - [Pair](https://github.com/applebuddy/AlgorithmMemo#-Pair) 33 | - [Tuple](https://github.com/applebuddy/AlgorithmMemo#-Tuple) 34 | - [Stack](https://github.com/applebuddy/AlgorithmMemo#-Stack) 35 | - [Queue](https://github.com/applebuddy/AlgorithmMemo#-Queue) 36 | - [Priority_Queue](https://github.com/applebuddy/AlgorithmMemo#-Priority_Queue) 37 | - [Deque](https://github.com/applebuddy/AlgorithmMemo#-Deque) 38 | - [Map](https://github.com/applebuddy/AlgorithmMemo#-Map) 39 | - [Unordered_Map](https://github.com/applebuddy/AlgorithmMemo#-Unordered_Map) 40 | - [MultiMap](https://github.com/applebuddy/AlgorithmMemo#-MultiMap) 41 | ### - [문자열](https://github.com/applebuddy/AlgorithmMemo#-c_문자열) 42 | ### - [주요 헤더](https://github.com/applebuddy/AlgorithmMemo#%EC%9E%90%EC%A3%BC-%EC%82%AC%EC%9A%A9%EB%90%98%EB%8A%94-%ED%97%A4%EB%8D%94header) 43 | - [iostream](https://github.com/applebuddy/AlgorithmMemo#iostream) 44 | - [Algorithm](https://github.com/applebuddy/AlgorithmMemo#algorithm) 45 | - [bits/stdc++.h](https://github.com/applebuddy/AlgorithmMemo#bitsstdch) 46 | - [string](https://github.com/applebuddy/AlgorithmMemo#string) 47 | - [sstream](https://github.com/applebuddy/AlgorithmMemo#sstream) 48 | 49 | ### - [입출력](https://github.com/applebuddy/AlgorithmMemo#C_입출력) 50 | ### - [주요 함수](https://github.com/applebuddy/AlgorithmMemo#%EC%9E%90%EC%A3%BC-%EC%82%AC%EC%9A%A9%EB%90%98%EB%8A%94-%ED%95%A8%EC%88%98) 51 | 52 |
53 | 54 | ## ✤ [Swift](https://github.com/applebuddy/AlgorithmMemo/blob/master/README.md#swift_알고리즘) 55 | ### - [자료구조](https://github.com/applebuddy/AlgorithmMemo#Swift_자료구조) 56 | - [Array](https://github.com/applebuddy/AlgorithmMemo#-Array-1) 57 | - [Dictionary](https://github.com/applebuddy/AlgorithmMemo#-dictionary) 58 | - [Set](https://github.com/applebuddy/AlgorithmMemo#-Set-1) 59 | - [Queue](https://github.com/applebuddy/AlgorithmMemo#-Queue-1) 60 | - [QueueArray](https://github.com/applebuddy/AlgorithmMemo#-QueueArray) 61 | - [Stack](https://github.com/applebuddy/AlgorithmMemo#-Stack-1) 62 | - [DoubleStack](https://github.com/applebuddy/AlgorithmMemo#-DoubleStack) 63 | ### - [문자열](https://github.com/applebuddy/AlgorithmMemo/blob/master/README.md#문자열) 64 | - [String](https://github.com/applebuddy/AlgorithmMemo#-string) 65 | - [Character](https://github.com/applebuddy/AlgorithmMemo#-character) 66 | ### - [반복문](https://github.com/applebuddy/AlgorithmMemo#%EB%B0%98%EB%B3%B5%EB%AC%B8) 67 | ### - [문자열 메서드](https://github.com/applebuddy/AlgorithmMemo#-string-%EB%AC%B8%EC%9E%90%EC%97%B4-%EA%B8%B0%EB%8A%A5-%EB%A9%94%EC%84%9C%EB%93%9C) 68 | ### - [콘솔 입출력](https://github.com/applebuddy/AlgorithmMemo#-%EC%BD%98%EC%86%94-%EC%B6%9C%EB%A0%A5-%EB%A9%94%EC%84%9C%EB%93%9C) 69 | ### - [주요 클로저함수](https://github.com/applebuddy/AlgorithmMemo#-%EC%9C%A0%EC%9A%A9%ED%95%9C-%ED%81%B4%EB%A1%9C%EC%A0%B8-%ED%95%A8%EC%88%98%EA%B3%A0%EC%B0%A8%ED%95%A8%EC%88%98) 70 | 71 | 72 |
73 |
74 |
75 | 76 | # 공통_알고리즘 77 | 78 |
79 |
80 | 81 | ## ✓ 정렬_알고리즘 82 | 83 | ### 내장 정렬함수 84 | 85 |
86 | 87 | - C++ 구현 예시 ▼ 88 | ~~~ C++ 89 | // 내림차순 정렬 {최댓값....최솟값} 90 | sort(prices.begin(), prices.end()); 91 | 92 | // 내림차순 정렬 (위와 동일) 93 | sort(prices.begin(), prices.end(), greater()); 94 | 95 | // 오름차순 정렬 {최솟값....최댓값} 96 | sort(prices.begin(), prices.end(), less()); 97 | 98 | // 3번째 인자로 사용자정의 정렬 함수를 적용할 수 있다. (두개의 인자값, 하나의 Bool 리턴값 형태의 함수) 99 | sort(prices.begin(), prices.end(), compare()); 100 | ~~~ 101 | 102 |
103 | 104 | - 정렬 방식을 재정의 하여 사용할 수 도 있다. 105 | ~~~ C++ 106 | // 사용자 정의함수, compare 정의 예시) 107 | bool compareName(string s, string s2) { 108 | for(int i=0; i s2.length()) { 119 | return true; 120 | } else { 121 | return false; 122 | } 123 | } 124 | ~~~ 125 | 126 | ~~~ C++ 127 | // 익명함수로 바로 정렬 재정의 방식 적용하는 방법 128 | sort(contests.begin(), contests.end(), 129 | [](vector con1, vector con2) { 130 | return con1[0] > con2[0]; 131 | }); 132 | ~~~ 133 |
134 | 135 | ### 퀵정렬 알고리즘(QuickSort Algorithm) 136 | - 분할정복 알고리즘, O(nlogn)의 복잡도를 가진다. 137 | - swift, C++ 전부 sorting 메서드를 지원한다. 138 | - swift : sorted()로 정렬 지원 139 | - C++ : sort(시작주소,끝주소,정렬방식)으로 지원 140 | - 퀵소트 + 힙소트 방식의 정렬함수 141 | - 메서드 기본 기능은 오름차순 정렬이다. 142 | 143 | - Swift 퀵소트(QuickSort)구현 예시 ▼ 144 | ~~~ swift 145 | // MARK: QuickSort Implementation 146 | 147 | import Foundation 148 | 149 | extension Array where Element == Int { 150 | mutating func quickSort(_ start: Int, _ end: Int) { 151 | if start >= end { return } 152 | let pivot = start 153 | var left = pivot + 1 154 | var right = end 155 | while left <= right { 156 | while left <= end && self[left] <= self[pivot] { 157 | left += 1 158 | } 159 | 160 | while right > 0 && self[right] > self[pivot] { 161 | right -= 1 162 | } 163 | 164 | if left <= right { 165 | let temp = self[left] 166 | self[left] = self[right] 167 | self[right] = temp 168 | } else { 169 | let temp = self[right] 170 | self[right] = self[pivot] 171 | self[pivot] = temp 172 | } 173 | } 174 | 175 | quickSort(start, right-1) 176 | quickSort(right+1, end) 177 | } 178 | } 179 | 180 | var arr = [1,3,2,4,5,7,6,9,8,0,2,3,5,1,0,21,0] 181 | arr.quickSort(0, arr.count-1) 182 | print(arr) 183 | ~~~ 184 | 185 |
186 | 187 | 188 | ### 버블정렬 알고리즘 189 | - 양옆 값들을 차례로 비교해가며 정렬해가는 알고리즘 190 | 191 | - Swift 구현 예시 ▼ 192 | ~~~ swift 193 | // swift 예시 194 | func countSwaps(a: [Int]) { 195 | var arr = a 196 | var cnt = 0 197 | for i in arr.indices { 198 | for j in 0 ..< arr.count - 1 { 199 | if arr[j] > arr[j + 1] { arr.swapAt(j, j + 1); cnt += 1 } 200 | } 201 | } 202 | print("Array is sorted in \(cnt) swaps.") 203 | print("First Element: \(arr[0])") 204 | print("Last Element: \(arr[arr.count - 1])", terminator: "") 205 | } 206 | ~~~ 207 | 208 |
209 | 210 | - C++ 구현 예시 ▼ 211 | ~~~ C++ 212 | // C++ 예시 213 | void countSwaps(vector a) { 214 | int cnt = 0; 215 | for(int i=0; ia[j+1]) { 218 | int temp = a[j]; 219 | a[j] = a[j+1]; 220 | a[j+1] = temp; 221 | cnt++; 222 | } 223 | } 224 | } 225 | printf("Array is sorted in %d swaps.\n",cnt); 226 | printf("First Element: %d\n",a[0]); 227 | printf("Last Element: %d\n",a[a.size()-1]); 228 | } 229 | ~~~ 230 | 231 |
232 |
233 | 234 | ## ✓ 파인만 알고리즘 235 | - 문제해결과정을 단계벼로 나누어 푸는 알고리즘 236 | - **"문제해결과정을 단계별로 나눈다" 라는 아이디어는 단순할지 모르지만 굉장히 강력하다.** 237 | - 파인만 알고리즘 순서(3단계 ver.) 238 | - 1) 칠판에 문제를 적는다. 239 | - 2) 골똘히 생각한다. 240 | - 3) 칠판에 답안을 적는다. 241 | 242 |
243 | 244 | - 파인만 알고리즘 순서(4단계 ver.) 245 | - 1) **문제를 이해**한다. 246 | - 2) 어떻게 풀지 **계획을 세운다.** 247 | - 3) **계획을 수행해서 문제를 해결**한다. 248 | - 4) 어떻게 풀었는지 돌아보고, 개선할 방법이 있는지 찾아본다. 249 | 250 | - 파인만 알고리즘 계획 세부뷴류(6단계 ver.) 251 | - 1) 문제를 읽고 이해한다. 252 | - 2) 문제를 익숙한 용어로 재정의한다. 253 | - 3) 어떻게 해결할지 계획을 세운다. 254 | - 4) 계획을 검증한다. 255 | - 5) 프로그램으로 구현한다. 256 | - 6) 어떻게 풀었는지 돌아보고, 개선할 방법잉 있는지 찾아본다. 257 | * ✓ 프로그래밍 대회를 위한 여섯단계 문제 해결 알고리즘 (출처, 종만북) 258 | 259 |
260 |
261 | 262 | ## ✓ 그래프_알고리즘 263 | 264 | ### MST 알고리즘 265 | - Kruskal Algorithm, Prim Algorithm이 있다. 266 | - 1) Kruskal Algorithm 267 | - 간선의 가중치를 오름차순, 내림차순 정렬 후 차례대로 간선을 적용해보며 최선의 간선 루트를 구한다. (순환하지 않는 간선 경로를 구한다.) 268 | ~~~ C++ 269 | /// MARK: - Kruskal Algorithm : MST Algorithm 270 | 271 | #include 272 | #include 273 | #include 274 | using namespace std; 275 | 276 | /// MARK: 크루스칼 알고리즘은 순환이 최소신장트리가 순환이 되면 안되므로, Union Find(서로소집합) 알고리즘을 결합하여 사용한다. 277 | /// MARK: Adjusting Union Find Algorithm 278 | // - getParentNode(int node[], int x) 279 | // - unionParent(int node[], int a, int b) 280 | // - checkParent 281 | int getParentNode(int node[], int x) { 282 | if(node[x]==x) return x; 283 | return getParentNode(node, node[x]); 284 | } 285 | 286 | void unionParent(int node[], int a, int b) { 287 | a = getParentNode(node,a); 288 | b = getParentNode(node,b); 289 | if(anode[0] = x; 307 | this->node[1] = y; 308 | this->weight = w; 309 | } 310 | }; 311 | 312 | int main() { 313 | 314 | int N = 7; // 노드 갯수 315 | int M = 11; // 간선 갯수 316 | vector V; 317 | V.push_back(Edge(1, 7, 12)); 318 | V.push_back(Edge(4, 7, 13)); 319 | V.push_back(Edge(1, 4, 18)); 320 | V.push_back(Edge(1, 2, 67)); 321 | V.push_back(Edge(1, 5, 17)); 322 | V.push_back(Edge(2, 4, 24)); 323 | V.push_back(Edge(2, 5, 62)); 324 | V.push_back(Edge(3, 5, 20)); 325 | V.push_back(Edge(3, 6, 37)); 326 | V.push_back(Edge(5, 6, 45)); 327 | V.push_back(Edge(5, 7, 73)); 328 | 329 | // 간선 노드의 오름차순 정렬 후, 가장 적은 비용의 노드를 연결하는 경우를 찾는다. 330 | sort(V.begin(), V.end(), [](Edge &a, Edge &b) { 331 | return a.weight < b.weight; 332 | }); 333 | 334 | int C[N]; 335 | for(int i=0; i 356 | 357 | ### 위상정렬 알고리즘 358 | - 유향그래프의 꼭짓점들을 변의 방향을 거스르지 않고 나열하는 것. 359 | - 줄세우기 등의 방향성을 거스르지 않게 정렬 하는 경우 사용할 수 있다. 360 | ~~~ C++ 361 | /// MARK: - 위상정렬 알고리즘 예시) 362 | #include 363 | #include 364 | #include 365 | using namespace std; 366 | 367 | // C: 방향 체크 배열 368 | // G: 위상정렬에 사용하는 유향그래프 369 | int C[32001] = {0,}; 370 | vector G[32001]; 371 | 372 | void theLiningSorting() { 373 | int N,M; cin>>N>>M; 374 | queue Q; 375 | for(int i=0; i>A>>B; 377 | // 목표 지즘의 노드 C 인덱스를 증가 378 | C[B]++; 379 | // A->B 방향으로 유향 그래프를 그려준다. 380 | G[A].push_back(B); 381 | } 382 | 383 | // 0 일경우(지표가 없는 노드 순서의 경우) 그대로 큐에 삽입한다. 384 | for(int i=1; i<=N; i++) if(C[i]==0) Q.push(i); 385 | 386 | // 큐가 텅 빌 때까지 유향그래프를 순회하며 줄세우기를 실시한다. 387 | while(!Q.empty()) { 388 | // 현재 순서가 정해 진 큐의 front 노드를 출력하고 pop() 처리한다. 389 | int node = Q.front(); 390 | printf("%d",node); 391 | Q.pop(); 392 | for(int i=0; i 405 | 406 | ### 최단경로 알고리즘 407 | #### 다익스트라 알고리즘 408 | - **단일 시작점 기준, 모든 목적지의 최단경로를 구하는 알고리즘** 409 | - 우선순위큐(Heap)을 사용하여 최단거리를 구한다. 410 | - **시간 복잡도 약 O(NlogN)** 411 | 412 | #### 플로이드 와셜 알고리즘 413 | - **모든 쌍 최단경로 알고리즘** 414 | - 3중 포문을 사용해 특정 노드를 경유한 경우 vs 노드 간 다이렉트 이동경우 를 체크하여 모든 노드 이동 간 최단거리를 구한다. 415 | - **시간 복잡도 약 O(N^3)** 416 | 417 | #### 벨만-포드 알고리즘 418 | - **음의 가중치가 존재할때도 사용가능 한 최단경로 알고리즘** 419 | - 모든 간선의 가중치를 V(노드의 갯수) 번 순회하며 체크한다. 420 | - 보통 N 순회시마다 N번 이동시의 최단경로가 구해진다. 421 | - 간선을 갱신 시 전부 변동사항이 없게 될 경우 연산을 종료하고 결과를 도출한다. 422 | - 음의폐로(음의가중치에 의한 무한 순환)을 확인할 수 있다. 423 | - 벨만포드 알고리즘 순회가 V(노드의갯수) 번 이상 돌아가면 음의폐로가 존재함을 의미 424 | - **시간복잡도 약 O(V^3)** 로 느리지만, 대신 다익스트라알고리즘이 못하는 음의 가중치 연산이 가능한 장점이 있다. 425 | 426 | #### SPFA 알고리즘(Shortest Path Faster Algorithm) 427 | - **벨만-포드의 비효율성을 해결한 벨만-포드 최적화 기법 알고리즘** 428 | - 벨만-포드 알고리즘과 동일하게 음의폐로 확인가능, 음의가중치 연산이 가능하다. 429 | - queue를 사용하며 노드간 가중치를 비교연산하며 최단경로를 구한다. 430 | - **시간복잡도 O(V*E)지만 실제로는 기존 벨만-포드 알고리즘에 비해 매우 빠른 O(V+E) || O(E)의 성능을 보인다** 431 | 432 | - 포드-폴커슨 알고리즘 433 | - 최대 유량 알고리즘 434 | 435 | 436 |
437 | 438 | ### 최소 스패닝 트리 알고리즘 439 | - Minimum Spanning tree Algorithm 440 | - 노드 간 최소한의 간선을 사용한 최적의 가중치 트리를 찾는 알고리즘 441 | 442 | #### Kruskal Algorithm 443 | - 그리디 특성을 가진 간선 기준 최소 스패팅 트리 알고리즘 444 | - 간선을 가중치 기준 정렬하여 스패닝 트리를 구한다. 445 | - 이때 순환이 일어나지 않도록 UnionFind(서로소집합) 알고리즘을 사용한다. 446 | - V-1 개의 간선만을 이용해 최적의 스패닝트리를 구한다. 447 | - * UnionFind 알고리즘 : 연결된 노드 간 부모노드를 통합시킴으로서 간선이 이어질 시의 순환여부를 체크하는데 사용할 수 있다. 448 | 449 |
450 | 451 | #### Prim Algorithm 452 | - 노드 기준으로 최소 스패닝 트리를 구하는 알고리즘 453 | 454 |
455 |
456 | 457 | ## ✓ 수학_알고리즘 458 | ### 약수의 갯수가 홀수개인 숫자인지 판별하는 방법 459 | - **해당 수 N의 제곱근, A을 구한다. N == A*A ? true : false** 460 | 461 |
462 | 463 | ### 에라토스 테네스의 체 464 | - 소수를 가벼운 복잡도로 구할 수 있는 알고리즘 465 | - 2부터 시작하여 소수의 배수 값들은 소수아님 처리하며 체로 소수가 아닌 값들을 걸러낸다. 466 | - 에라토스 테네스의 체 사용 예시) ▼ 467 | 468 | ~~~ swift 469 | // swift 에라토스테네스의 체 사용 예시 470 | func findPrime(_ n:Int) -> Int { 471 | var chk = [Bool](repeating: true, count: n+1) 472 | var Ans = 0 473 | 474 | // 에라토스 테네스의 체 구현 예시) 475 | for i in stride(from: 2, through: Int(sqrt(Double(n))), by: 1) { 476 | if chk[i] == true { 477 | for j in stride(from: i+i, through: n, by: i) { 478 | chk[j] = false 479 | } 480 | } 481 | } 482 | 483 | for i in 2...n { 484 | if chk[i] == true { Ans += 1 } 485 | } 486 | return Ans 487 | } 488 | ~~~ 489 | 490 |
491 | 492 | ### **카탈린 수** 493 | - **함수, y=x 그래프를 넘지않는 최단거리 구하기** 494 | - Catalan number, 카탈랑 수 495 | - 동일한 완전 쌍의 조합의 갯수 496 | - ex) 올바른 괄호 갯수 찾기 497 | - 카탈린 수 연산 예시) ▼ 498 | 499 | ~~~ C++ 500 | /// MARK: - 올바른 괄호의 갯수 : 카탈린 알고리즘 501 | /// '{', '}' 각각 n개를 갖고 있는 올바른 괄호의 갯수 경우의 수를 출력하라!! 502 | 503 | // * 경우의 수 + 괄호내용 출력 버전) 504 | #include 505 | #include 506 | 507 | using namespace std; 508 | 509 | int Ans = 0; 510 | char str[30]; 511 | void getBrace(int idx, int open, int close) { 512 | /// open Brace '{'가 n개 전부 사용되었다면, 더이상 '{'은 사용 불가, 나머지 사용하지 않은 '}'를 추가 513 | /// 처음 getBrace 함수에서 받은 인자, open, close값만 사용, 514 | /// -> open Brace < close Brace일때만 close Brace를 사용하기때문에 올바른 괄호만 출력된다. 515 | if(open == 0) { 516 | while(close--) str[idx++] = '}'; 517 | Ans++; 518 | printf("%s\n",str); 519 | return; 520 | } 521 | 522 | // open Brace '{' 사용 523 | str[idx] = '{'; 524 | // open Brace 사용 후 open-1 재귀함수 실행 525 | getBrace(idx+1, open-1, close); 526 | 527 | // open Brace가 Close 보다 작은경우 528 | if(open < close) { 529 | /// close Brace '}' 사용 530 | str[idx] = '}'; 531 | // close Brace 사용 후 close-1 재귀함수 실행 532 | getBrace(idx+1, open, close-1); 533 | } 534 | } 535 | ~~~ 536 | 537 |
538 |
539 | 540 | ### LIS : 가장 긴 증가하는 수열 알고리즘 541 | - , lower_bound() 기능을 활용한다. 542 | - 수열의 증가하는 긴 수열을 구할때 사용한다. 543 | - LIS 알고리즘 활용 예시 ▼ 544 | ~~~ C++ 545 | #include 546 | #include 547 | #include 548 | using namespace std; 549 | void effectiveBandoChaeDesign() { 550 | ios_base::sync_with_stdio(0); cin.tie(0); 551 | int N; 552 | cin >> N; 553 | vector V(40001,0); 554 | vector Ans; 555 | for(int i=0; i> V[i]; 556 | for(int i=0; i 566 |
567 | 568 | ### Prefix Sum 알고리즘 569 | - 미지 특정 인덱스 까지의 합을 기록하려 구간합을 구하는 알고리즘 570 | - Prefix Sum Algorithm Example) 571 | ~~~ C++ 572 | /// MARK: - 합 구하기_11441 : Prefix Sum Problems 573 | 574 | #include 575 | #include 576 | using namespace std; 577 | 578 | void solveTheSumOfNumber() { 579 | int N; cin>>N; 580 | int arr[N]; 581 | memset(arr,0,sizeof(arr)); 582 | 583 | /// 1) 미리 배열 arr에 구간값을 기록한다. 584 | for(int i=0; i>arr[i]; 586 | if(i!=0) arr[i]+=arr[i-1]; 587 | } 588 | 589 | int T; cin>>T; 590 | for(int i=0; i>s>>e; 592 | 593 | /// 2) e번째까지의 구간합 - s번째까지의 구간합을 계산하여 s ~ e 구간의 부분합을 구할 수 있다. 594 | printf("%d\n",arr[e-1]-((s!=1) ? arr[s-2] : 0)); 595 | } 596 | return; 597 | } 598 | ~~~ 599 | 600 | ### Manacher's Algorithm 601 | - 가장 긴 펠린드롬(좌우 대칭 문자열) 문자열을 O(N) 복잡도로 구할 수 있는 특수한 알고리즘 602 | - Manacher's Algorithm(마나커 알고리즘)은 A[i]가 존재할때, i-A[i] ~ A[i]+i 범위의 팰린드롬문자열이 존재하면, i-A[i]-1 ~ A[i]+i+1 의 팰린드롬 문자열은 없음을 이용하는 O(N) 복잡도의 특수 알고리즘 기법이다. 603 | ~~~ C++ 604 | /// MARK: - 가장 긴 펠린드롬 부분 문자열 문제 예시 : Manacher's Algorithm Problem 605 | 606 | #include 607 | #include 608 | using namespace std; 609 | 610 | vector A(1000000,0); 611 | class LongestPalindromicSubstring { 612 | public: 613 | /// MARK: manacherAlgorithm 614 | string manacherAlgorithm(string S) { 615 | // r : 가장 큰 팰린드롬 문자열의 우측 범위를 저장 -> 해당 값이 줄어드는 경우는 없으므로 S 문자열을 순회하며 O(N)의 복잡도를 가진 후 종료 616 | // p : 가장 큰 팰린드롬 문자열의 중심 축을 저장 617 | int r=0,p=0; 618 | int sum=0,mxIdx=0; 619 | string Ans = ""; 620 | for(int i=0; i= 0 && i+A[i]+1 673 | 674 | ## ✓ 수학_함수 675 | 676 |
677 | 678 | ### 올림, 내림, 반올림 679 | - C++, Swift 680 | - ceil(<값>) : 올림 함수 681 | - floor(<값>) : 내림 함수 682 | ~~~ swift 683 | /// Swift 소수럼 1자리 제외 버리기 -> floor(<값>) 사용 예시 684 | let input = 1.123456789 685 | let output = floor(input * 10) / 10 686 | // output == 10.1 687 | ~~~ 688 | 689 |
690 | 691 | - round(<값>) : 반올림 함수 692 | - ✓ floor(value + 0.5)를 통한 반올림 기법 예시 693 | ~~~ C++ 694 | int getRound() { 695 | double N; 696 | cin >> N; 697 | for(int i=10; i<100000000; i*=10) { 698 | if(N>i) { 699 | /// * floor(value+0.5)를 통해 반올림과 같은 연산을 할 수 있다. 700 | int temp = floor(N/i+0.5); 701 | N = temp*i; 702 | } 703 | } 704 | return N; 705 | } 706 | ~~~ 707 | 708 |
709 | 710 | ### 제곱근 (Square Root) 711 | - 어떤 수, x를 두개 곱했을때 a가 된다면 x를 a의 제곱근이라 한다. 712 | - a에 root를 씌우면 제곱근이 나온다. 713 | - 제곱근 (Square Root) 사용예시 ▼ 714 | 715 | ~~~ C++ 716 | #include 717 | int n = 64; 718 | int main() { 719 | int num = sqrt(n); 720 | return 0; 721 | } 722 | ~~~ 723 | ~~~ swift 724 | import foundation 725 | 726 | func makeSqut(_ num: Int) -> Int { 727 | // swift는 강타입 언어로, Int로 직접 형변환을 해준 뒤 값을 처리할 수 있다. 728 | // 1번째 sqrt 처리 방법 729 | var sqt = Int(sqrt(Double(num))) 730 | 731 | // 2번째 sqrt 처리 방법 732 | var sqt2 = Int(Double(n).squareRoot()) 733 | 734 | return sqt 735 | } 736 | 737 | ~~~ 738 | 739 |
740 | 741 | ### 비트연산자 ^, XOR 742 | - 배타적 논리합 743 | - 두개의 값이 다르면 1, 같으면 0 744 | 745 |
746 | 747 | ### 비트연산자 &, AND 748 | - 논리곱 749 | - 두개의 값이 1이어야 1, 하나라도 0이면 0 750 | 751 |
752 | 753 | ### 비트연산자 |, OR 754 | - 논리합 755 | - 두개의 값 중 하나라도 1이면 1, 둘다 0일때만 0 756 | 757 |
758 | 759 | ### 비트연산자 ~, NOT 760 | - NOT 연산자 761 | - 1->0, 0->1 762 | - NOT 사용 예시 ▼ 763 | ~~~ C++ 764 | #include 765 | 766 | long flippingBits(long n) { 767 | // NOT(~) 연산자 적용 768 | // 1) ~n의 값이 -값이라는 것은 32비트의 맨 앞자리가 1이라는 것, 맨 앞은 부호로 취급하므로 추가로 2^32값을 더해준다. 769 | // 2) ~n의 값으 +값이라는 것은 32비트의 맨 앞자리가 0이라는 것으로 부호취급과 상관없이 그대로 ~n의 값을 출력하면 된다. 770 | return ~n<0 ? (long)pow(2,32)+~n:~n; 771 | } 772 | ~~~ 773 | 774 |
775 | 776 | ### min(<값1>, <값2>), max(<값1>,<값2>) 777 | - 두 수 사이의 최솟값, 최댓값을 구해준다. 778 | 779 |
780 | 781 | ### abs() 782 | - 절대값을 구해준다. 783 | - Swift, C++ 동일 지원 784 | 785 |
786 | 787 | ### pow(<값1>,<값2>) 788 | - <값1>을 <값2>번 곱해준다. 789 | - Swift의 경우 두개의 정수값 허용이 안된다. 790 | - 두개의 인자 중 하나는 실수형 변환 처리 후 계산 -> Int형 변환하여 Int형 값을 반환받을 수 있다. 791 | - Swift의 pow(: lhs, : rhs)는 Decimal 구조체 타입을 반환하므로 필요시 Int() 등으로 형변환을 해주어야한다. 792 | ~~~ swift 793 | // Swift 내 pow 활용 예시) 794 | // Int(pow(Double(2),32)) -> 2^32(2의 32승)을 수행하는 과정이다. 795 | func flippingBits(n: Int) -> Int { 796 | return ~n < 0 ? ~n + Int(pow(Double(2),32)) : ~n 797 | } 798 | 799 | ~~~ 800 | 801 |
802 |
803 |
804 | 805 | # C++_알고리즘 806 | 807 |
808 |
809 | 810 | ## C++_타입 811 | 812 |
813 | 814 | ### 타입 최댓값 출력방법 815 | - 816 | - 사용 예시 ▼ 817 | ~~~ C++ 818 | #include 819 | #include 820 | using namespace std; 821 | 822 | int main() { 823 | 824 | unsigned int us = UINT_MAX; 825 | int is = INT_MAX; 826 | long ls = LONG_MAX; 827 | long long lls = LONG_LONG_MAX; 828 | printf("unsigned int range: %u\n",us); 829 | printf("int range: %d\n",is); 830 | printf("long range: %ld\n",ls); 831 | printf("long long range: %lld\n",lls); 832 | 833 | return 0; 834 | } 835 | ~~~ 836 | 837 |
838 | 839 |
840 |
841 | 842 |
843 |
844 | 845 | ## C++_자료구조 846 | 847 |
848 | 849 | ## ✓ Array 850 | - 기본적으로 사용하는 컨네이너 851 | 852 | ~~~ C++ 853 | // 배열 초기화 방법 1) 854 | array arr = {0,}; 855 | // 배열 초기화 방법 2) 856 | int arr[26] = {0,}; 857 | ~~~ 858 | - Array 초기화 방법 859 | - fill_in 860 | - memset 861 | 862 |
863 |
864 | 865 | ## ✓ Vector 866 | - 배열 외로 사용할 수 있는 자료구조, vector 867 | - C++에서 쉽게 사용 가능한 Sequence Container, 배열과 유사하다. 868 | - 벡터 내 원소는 하나의 메모리 블록에 연속적으로 저장이 된다. 869 | - 임의 접근 반복자(Random Access Iterator)를 지원하는 Container 870 | 871 | - **탐색속도는 느리나, 삽입속도가 빠른 자료구조** 872 | - push_back() 등 으로 값을 넣을 수 있다. 873 | 874 | ~~~ C++ 875 | // vector 사용 예) 876 | // * vector + pair의 사용 예 : 7개의 pair값을 갖는 벡터 정의 예시이다. 877 | vector> chk = {{0,0}, {0,1}, {0,2}, {1,1}, {2,0}, {2,1}, {2,2}}; 878 | ~~~ 879 | 880 |
881 | 882 | ### Vector 초기화 방법 883 | ~~~ C++ 884 | vector vec; // 텅 빈 vector 컨테이너 885 | vector vec2(5); // 5개의 기본값으로 초기화된 원소를 갖는 컨테이너 886 | vector vec3(n,x) // n개의 x값으로 초기화 된 원소를 갖는 벡터 컨테이너 887 | ~~~ 888 | 889 |
890 | 891 | ### Vector 기능 892 | - assign(<시작 주소>,<끝 주소>), assign(<할당갯수>,<초기화값>) 893 | - 벡터에 특정 크기의 테이터를 할당한다. 894 | ~~~ C++ 895 | vector vec; 896 | vector vec2; 897 | vec.assign(3,5); // {5,5,5} 898 | vec2.assign(vec.begin(),vec.end()); // {5,5,5} 899 | ~~~ 900 | 901 |
902 | 903 | - push_back(<값>) 904 | - 벡터에 값을 추가한다. 905 | ~~~ C++ 906 | vector vec; 907 | vec.push_back(1); // {1} 908 | vec.push_back(2); // {1,2} 909 | ~~~ 910 | 911 |
912 | 913 | - pop_back() 914 | - 벡터의 마지막 값을 제거한다 . 915 | ~~~ C++ 916 | vector vec; 917 | vec.push_back(1); // {1} 918 | vec.pop_back(); // {} 919 | ~~~ 920 | 921 |
922 | 923 | - insert(<시작주소>, <값>), insert(<시작주소>, <추가갯수>, <값>) 924 | - 특정 위치에 값을 추가한다. 925 | ~~~ C++ 926 | // initialising the vector 927 | vector vec = { 10, 20, 30, 40 }; 928 | 929 | // inserts 3 at front 930 | auto it = vec.insert(vec.begin(), 3); // {3, 10, 20, 30, 40} 931 | 932 | // inserts 2 at front 933 | vec.insert(it, 2); // {2, 3, 10, 20, 30, 40} 934 | 935 | // inserts 5 at front three times in a row 936 | vec.insert(it, 3, 5); // {5, 5, 5, 2, 3, 10, 20, 30, 40} 937 | ~~~ 938 | 939 |
940 | 941 | - insert를 활용한 벡터 합치기 942 | ~~~ C++ 943 | vector answer = {1,2,3}; 944 | vector temp(3,6); 945 | answer.insert(answer.end(),temp.begin(),temp.end()); // 1 2 3 6 6 6 946 | ~~~ 947 | 948 |
949 | 950 | - erase(<값 주소>), erase(<값 시작주소>, <값 끝주소>) 951 | - 1) <특정주소>의 값 제거 952 | - 2) <시작주소> ..< <끝주소> 영역의 값 제거 953 | 954 |
955 | 956 | - vec.at(i), vec.[i] 957 | - i 번째 원소를 반환한다. 958 | 959 |
960 | 961 | - vec.front() 962 | - 벡터의 첫 원소를 반환한다. 963 | 964 |
965 | 966 | - vec.back() 967 | - 벡터의 마지막 원소를 반환한다. 968 | 969 |
970 | 971 | - vec.swap(vec2) 972 | - 벡터(vec, vec2) 간 스왑 973 | 974 | 975 |
976 | 977 | - vec.clear() 978 | - 벡터의 모든 원소를 제거한다. 979 | 980 |
981 | 982 | - vec.empty() 983 | - 벡터가 비었는지를 boolean 값으로 반환 984 | 985 |
986 | 987 | - vec.size() 988 | - 벡터의 원소갯수 반환 989 | 990 |
991 | 992 | - vec.resize(<공간크기>), vec.resize(<공간크기>, <초기화 값>) 993 | - 벡터 크기를 재조정한다. 994 | 995 |
996 | 997 | - vec.max_size() 998 | - 벡터가 담을 수 있는 최대 원소 갯수 반환 999 | 1000 |
1001 | 1002 | - capacity() 1003 | - 메모리 할당크기 확인 가능 1004 | 1005 |
1006 | 1007 | - unique(<시작주소>,<끝주소>) 1008 | - 특정 범위의 중복값을 제거 후 컨테이너 뒤로 처박아 둔다. 1009 | * 완벽한 중복값 제거를 위해 erase 함께 활용 필요 1010 | ~~~ C++ 1011 | /// unique 사용예시 1) 1012 | #include 1013 | #include 1014 | int main() { 1015 | vector v = {1,1,1,2,2,2,3,3,3,4,5,6}; 1016 | v.erase(unique(s.begin(),s.end()),s.end()) // 1 2 3 4 5 6 1017 | return 0; 1018 | } 1019 | ~~~ 1020 | 1021 | ~~~ C++ 1022 | /// unique 사용예시 2) 1023 | #include 1024 | #include 1025 | #include 1026 | using namespace std; 1027 | 1028 | void removeTheDuplicate() { 1029 | while(1) { 1030 | int N; cin>>N; 1031 | vector V(N,0); 1032 | if(N==0) break; 1033 | for(int i=0; i>V[i]; 1034 | V.erase(unique(V.begin(), V.end()),V.end()); 1035 | for(auto v: V) printf("%d ",v); 1036 | printf("$\n"); 1037 | } 1038 | return; 1039 | } 1040 | ~~~ 1041 | 1042 |
1043 | 1044 | - reverse(<시작주소>,<끝주소>) 1045 | - Algorithm 헤더로 사용 가능 1046 | - **특정 영역의 요소를 역순으로 뒤집는다.** 1047 | - **시간복잡도 : O(n)** 1048 | ~~~ C++ 1049 | /// reverse() 사용 예시) 1050 | #include 1051 | #include 1052 | #include 1053 | 1054 | using namespace std; 1055 | 1056 | 1057 | int arrayReverseExample() { 1058 | int n; 1059 | cin >> n; 1060 | vector arr(n,0); 1061 | for(int i=0; i> arr[i]; 1063 | } 1064 | /// * 벡터 arr의 전체영역을 역순으로 뒤집는다. 1065 | reverse(arr.begin(), arr.end()); 1066 | for(auto v : arr) printf("%d ",v); // 역순으로 뒤집어진 vector Element 출력 1067 | 1068 | return 0; 1069 | } 1070 | ~~~ 1071 | 1072 | - lower_bound(<주소시작>,<주소끝>,<타겟값>), upper_bound(<주소시작>,<주소끝>,<타겟값>) 1073 | - <타겟값> 이상 / 이하의 값이 있는 주소를 반환한다. 1074 | - 이진탐색으로 작동하기 때문에 사용되는 컨테이너 내 요소는 정렬되어있어야 사용 가능하다. 1075 | - **시간복잡도, logN** 1076 | 1077 | ~~~ C++ 1078 | // lower_bound 사용 예시) 1079 | #include 1080 | #include 1081 | #include 1082 | using namespace std; 1083 | 1084 | int main() { 1085 | int T; cin>>T; 1086 | vector V(T,0); 1087 | vector Ans; 1088 | for(int i=0; i>V[i]; 1089 | for(int i=0; i 1105 |
1106 | 1107 | ## ✓ Set 1108 | - 집합구조, 중복요소가 들어가지 않는다. 1109 | ~~~ C++ 1110 | // Set 사용 방법 1111 | #include 1112 | set noteSet; 1113 | // magazine 벡터요소에 중복문자가 있을시 중복문자는 단 하나씩만 들어간다. 1114 | for(auto v : magazine) { 1115 | magaSet.insert(v); // set 자료구조에 요소 삽입 1116 | } 1117 | ~~~ 1118 | 1119 | ~~~ C++ 1120 | #include 1121 | #include 1122 | using namespace std; 1123 | 1124 | int frogRiverOne(int X, vector &A) { 1125 | 1126 | set setV; 1127 | for(int i=0; i 1136 |
1137 | 1138 | ## ✓ Pair 1139 | - 두개의 값을 가지며, 두개의 값의 타입은 다를 수 있다. 1140 | 1141 | ~~~ C++ 1142 | // pair 사용 예) 1143 | pair p; 1144 | printf("%d",p.first); 1145 | printf("%d",p.second); 1146 | 1147 | // Vecter에 pair 넣는 방법 1148 | vec.push_back(make_pair(mp.first, mp.second)); 1149 | ~~~ 1150 | 1151 |
1152 |
1153 | 1154 | ## ✓ Tuple 1155 | - 세개 이상의 값을 가지는 자료구조 1156 | 1157 | ~~~ C++ 1158 | // tuple 사용 예) 1159 | queue> q; 1160 | 1161 | // tuple 값 읽어오기 예시) 1162 | // get<'tuple인덱스'> 1163 | int nx=get<2>(q.front()); 1164 | int ny=get<1>(q.front()); 1165 | int nz=get<0>(q.front()); 1166 | 1167 | // tuple 값 쓰기 예시) 1168 | // make_tuple(<값1>,<값2>,<값3>) 형식으로 사용 가능 1169 | q.push(make_tuple(mz,ny,nx)); 1170 | ~~~ 1171 | 1172 |
1173 |
1174 | 1175 | ## ✓ Stack 1176 | - FILO (First In Last Out) 방식의 자료구조 1177 | 1178 | ### ✤ 선언방식 1179 | 1180 | ~~~ C++ 1181 | stack q; 1182 | ~~~ 1183 |
1184 | 1185 |
1186 | 1187 | ### ✤ stack 기능 1188 | - push(<값>) : 요소를 한개 삽입한다. 1189 | - pop() : 요소를 한개 빼낸다. 1190 | - top() : 가장 먼저 pop() 될 요소를 반환한다. 1191 | - empty() : 스택 내 요소가 비었는지 체크한 뒤 Bool값을 반환한다. 1192 | - size() : 스택 내 들어간 원소의 갯수를 반환한다. 1193 | 1194 |
1195 |
1196 | 1197 | ## ✓ Queue 1198 | - FIFO (First In First Out) 방식의 자료구조 1199 | 1200 | ### ✤ 선언방식 1201 | 1202 | ~~~ C++ 1203 | queue q; 1204 | ~~~ 1205 | 1206 |
1207 | 1208 | ### ✤ queue 기능 1209 | - push(<값>) : 요소를 한개 삽입한다. 1210 | - pop() : 요소를 한개 빼낸다. 1211 | - top() : 가장 먼저 pop() 될 요소를 반환한다. 1212 | - empty() : 큐 내 요소가 비었는지 체크한 뒤 Bool값을 반환한다. 1213 | - front() : 큐에 가장 먼저 들어관 원소를 반환한다. 1214 | - back() : 큐에 가장 늦게 들어간 원소를 반환한다. 1215 | - size() : 큐 내 들어간 원소의 갯수를 반환한다. 1216 | 1217 |
1218 |
1219 | 1220 | ## ✓ Priority_Queue 1221 | - **우선순위 큐(Heap 자료구조 중 하나)** 1222 | - 일반 Queue와 달리 비선형 자료구조 1223 | - 기존 큐와 달리 항시 큐의 top은 최소 or 최댓값이 위치하게 된다. 1224 | - **컬렉션 내 최솟값, 최댓값을 자주 사용해야할 때 유용**하다. 1225 | - **push, pop 시간 복잡도는 logN** 1226 | 1227 |
1228 | 1229 | ### 선언방식 1230 | 1231 | ~~~ C++ 1232 | priority_queue, greater> q; // q.top은 queue 내의 가장 작은 값 1233 | priority_queue, less> q; // q.top은 queue 내의 가장 큰 값 1234 | ~~~ 1235 | 1236 |
1237 | 1238 | ~~~ C++ 1239 | // 우선순위 큐 사용 예시 1240 | // greter 설정 시 항상 q.top()에는 queue 내 최솟값이 위치하게 된다. 1241 | priority_queue, greater> q; 1242 | 1243 | for(auto v : element) 1244 | q.push(v); 1245 | 1246 | while(q.top() 1260 | 1261 | ### ✭ 우선순위큐 정렬방식 설정하기 1262 | - **priority_queue의 세번째 인자값을 지정하여 설정** 가능 1263 | 1264 |
1265 | 1266 | - **MIN 힙(Heap)** 1267 | - priority_queue 세번째 인자 값 -> greater 지정 1268 | 1269 | ~~~ C++ 1270 | // q.top은 queue 내의 가장 작은 값 1271 | priority_queue, greater> q; 1272 | ~~~ 1273 | 1274 |
1275 | 1276 | - **MAX 힙(Heap)** 1277 | - priority_queue 세번째 인자 값 -> less 지정 1278 | 1279 | ~~~ C++ 1280 | // q.top은 queue 내의 가장 큰 값 1281 | priority_queue, less> q; 1282 | ~~~ 1283 | 1284 |
1285 | 1286 | - **커스텀 정렬 힙(Heap)** 1287 | - 커스텀 정렬을 위한 compare구조체를 지정하여 priority_queue의 세번째 인자값으로 지정한다. 1288 | ~~~ C++ 1289 | #include 1290 | #include 1291 | #include 1292 | #include 1293 | 1294 | using namespace std; 1295 | typedef pair Pair; 1296 | 1297 | /// 우선순위큐 커스텀 정렬 구조체 1298 | struct compare{ 1299 | /// p1, p2의 첫번째 값 내림차순 정렬 1300 | /// -> 만약 p1, p2의 첫번쨰 값이 같다면 두번째 값 오름차순 정렬 1301 | bool operator()(const Pair &p1, const Pair &p2){ 1302 | if(p1.first < p2.first) return true; 1303 | else if(p1.first == p2.first) { 1304 | if(p1.second > p2.second) return true; 1305 | } 1306 | return false; 1307 | } 1308 | }; 1309 | 1310 | vector solution(vector genres, vector plays) { 1311 | vector Ans; 1312 | 1313 | // priority_queue,compare>> : 커스텀 정렬 힙 1314 | map,compare>> mp; 1315 | map totMp; 1316 | map> totMpr; 1317 | 1318 | for(int i=0; i 1329 | 1330 | ### Deque 기능 1331 | - **시간복잡도** 1332 | - **원소추가 N(1), 원소제거 N(1)** 1333 | - push_back() 1334 | - 뒤에 요소를 추가한다. 1335 | - push_front() 1336 | - 앞에 요소를 추가한다. 1337 | - pop_back() 1338 | - 뒤의 요소를 제거한다. 1339 | - pop_front() 1340 | - 앞의 요소를 제거한다. 1341 | - size() 1342 | - 현재 크기 반환 1343 | - empty() 1344 | - 컨테이너가 비었는지 Boolean 값 반환 1345 | 1346 | ~~~ C++ 1347 | /// MARK: - Deque_10866 : Deque Structure Implementation Problem 1348 | // 덱(deque) 사용 예시) 1349 | #include 1350 | #include 1351 | using namespace std; 1352 | 1353 | void theDequeImplementation() { 1354 | deque DQ; 1355 | int T; cin>>T; 1356 | while(T--) { 1357 | string S; cin>>S; 1358 | if(S=="push_back") { 1359 | int N; cin>>N; 1360 | DQ.push_back(N); 1361 | } else if(S=="push_front") { 1362 | int N; cin>>N; 1363 | DQ.push_front(N); 1364 | } else if(S=="front") { 1365 | if(DQ.empty()) printf("%d\n",-1); 1366 | else { 1367 | printf("%d\n",DQ.front()); 1368 | } 1369 | } else if(S=="back") { 1370 | if(DQ.empty()) printf("%d\n",-1); 1371 | else { 1372 | printf("%d\n",DQ.back()); 1373 | } 1374 | } else if(S=="size") { 1375 | printf("%d\n",(int)DQ.size()); 1376 | } else if(S=="pop_front") { 1377 | if(DQ.empty()) printf("%d\n",-1); 1378 | else { 1379 | printf("%d\n",DQ.front()); 1380 | DQ.pop_front(); 1381 | } 1382 | } else if(S=="pop_back") { 1383 | if(DQ.empty()) printf("%d\n",-1); 1384 | else { 1385 | printf("%d\n",DQ.back()); 1386 | DQ.pop_back(); 1387 | } 1388 | } else if(S=="empty") { 1389 | printf("%d\n",DQ.empty()); 1390 | } 1391 | } 1392 | return; 1393 | } 1394 | ~~~ 1395 | 1396 |
1397 |
1398 | 1399 | ## ✓ Map 1400 | 1401 |
1402 | 1403 | ### 선언방식 1404 | ~~~ C++ 1405 | /// MARK: map 기본 설정 1406 | map m; 1407 | 1408 | /// MARK: map 값 사전 설정 방법, {<키>,<값>}... 1409 | unordered_map MP = {{"i",-1},{"pa",-1},{"te",-1},{"ni",-1},{"niti",-1},{"a",-1},{"ali",-1},{"nego",-1},{"no",-1},{"ili",-1}}; 1410 | ~~~ 1411 | 1412 | 1413 |
1414 |
1415 | 1416 | - **해쉬 형태의 키,값으로 이루어진 자료구조** 1417 | - **삽입은 느리나, 탐색속도가 빠르다.** 1418 | - sort() 함수 적용이 불가능하다. 1419 | 1420 | ### ✱ map 기능 1421 | - find(<키값>) 1422 | ~~~ C++ 1423 | // map find() 사용 예시) 1424 | // 키값이 있는지 확인 후 있으면 해당 주소값을 없다면 map m.end() 반환 1425 | map::iterator iter = m.find(abs(money-chk)); 1426 | if(iter != m.end() && i+1 != (*iter).second+1) { 1427 | printf("%d %d\n",i+1,(*iter).second+1); 1428 | return; 1429 | } 1430 | ~~~ 1431 | 1432 |
1433 | 1434 | ### ✭ 맵 정렬방식 설정하기 1435 | 1436 | ~~~ C++ 1437 | #include 1438 | #include 1439 | 1440 | using namespace std; 1441 | 1442 | void sortingMapStructure() 1443 | { 1444 | // 1) 오름차순으로 map 요소 확인 1445 | // map sorted_map; 1446 | // 2) 내림차순 으로 map 요소 확인을 위해서는 map 세번째 인자값으로 greater를 추가한다. 1447 | map> sorted_map; 1448 | 1449 | // map 요소 추가 1450 | sorted_map.insert(make_pair(0.3829, "Mercury")); 1451 | sorted_map.insert(make_pair(0.9499, "Venus")); 1452 | sorted_map.insert(make_pair(1, "Earth")); 1453 | sorted_map.insert(make_pair(0.532, "Mars")); 1454 | sorted_map.insert(make_pair(10.97, "Jupiter")); 1455 | sorted_map.insert(make_pair(9.14, "Saturn")); 1456 | sorted_map.insert(make_pair(3.981, "Uranus")); 1457 | sorted_map.insert(make_pair(3.865, "Neptune")); 1458 | 1459 | // map 내 요소 오름차순/내림차순 출력 1460 | for (auto const& entry: sorted_map) { 1461 | std::cout << entry.second << " (" << entry.first << " of Earth's radius)" << '\n'; 1462 | } 1463 | } 1464 | 1465 | /// * 출처 : https://riptutorial.com/ko/cplusplus/example/13316/std----map--오름차순-및-내림차순--정렬 1466 | ~~~ 1467 | 1468 |
1469 |
1470 | 1471 | ## ✓ Unordered_Map 1472 | - **데이터 양 n > 32 일 경우, map보다 전체적인 성능이 좋다고 한다.** 1473 | - map과 기본적인 동작, 선언, 초기화 방법 등 유사하다. 1474 | 1475 |
1476 | 1477 | ### 선언방법 1478 | 1479 | ~~~ C++ 1480 | #include 1481 | unordered_map m; 1482 | ~~~ 1483 | 1484 |
1485 |
1486 | 1487 | 1488 | ## ✓ MultiMap 1489 | - 일반 map과 달리 중복된 키값을 가질 수 있는 자료구조 1490 | - key값이 동일하면서 각각 다른 값을 갖는 데이터를 저장할 수 있다. 1491 | 1492 |
1493 | 1494 | ### 선언방법 1495 | 1496 | ~~~ C++ 1497 | #include 1498 | multimap m; 1499 | ~~~ 1500 | 1501 |
1502 |
1503 | 1504 | ## C++_문자열 1505 | - string Type 1506 | - , 헤더를 통해 string 문자열 타입을 사용 가능 1507 | - string 초기화 방법 1508 | ~~~ C++ 1509 | string str = ""; 1510 | string str2(3,'T'); // TTT 1511 | ~~~ 1512 | 1513 | ### 문자열 반복 문자 얻기 1514 | - std::string(<반복횟수>,<반복시킬문자>) 1515 | - 특정 문자 반복 문자열 활용 예시 ▼) 1516 | ~~~ C++ 1517 | for(int i=0; i>before; 1519 | SV.push_back(before); 1520 | 1521 | /// ansStr 문자열 변수에 SV[i][j] 문자가 2번 반복된 문자열을 추가한다. 1522 | for(int j=0; j 1530 | 1531 | ### char[] 문자열 -> string 문자열로 변환하기 1532 | ~~~ C++ 1533 | 1534 | /// 1) char[] 배열 문자열, str을 초기화 인자로 하여 초기화 하면 1535 | char str[11]; memset(str,' ',sizeof(str)); 1536 | 1537 | /// 2) 쉽게 char[] to string 문자열 변환이 가능하다. 1538 | string Str(str); 1539 | ~~~ 1540 | 1541 |
1542 | 1543 | ### string 문자열 -> char[] 문자열로 변환하기 1544 | - char 배열에 string 변수를 할당 + 맨 뒤에 '\0' 추가한다. 1545 | ~~~ C++ 1546 | 1547 | #include 1548 | #include 1549 | #include 1550 | 1551 | int main() { 1552 | /// string을 한줄 입력받는다. 1553 | getline(cin,str,'\n'); 1554 | 1555 | /// char형 배열에 string 값 할당 1556 | vector S(str.begin(), str.end()); 1557 | 1558 | /// 맨 끝 '\0' 추가 1559 | S.push _back('\0'); 1560 | 1561 | /// char 포인터에 char 배열 맨 앞의 값 주소를 할당 1562 | /// -> string to char 변환 완료 1563 | ch = &S[0]; 1564 | vector V; 1565 | if(str.length()==1 && S[0]=='0') break; 1566 | 1567 | /// 변환된 char 문자열의 활용 1568 | char *tok; 1569 | tok = strtok(ch," "); 1570 | while(tok!=NULL) { 1571 | V.push_back(stoi(tok)); 1572 | tok = strtok(NULL, " "); 1573 | } 1574 | } 1575 | ~~~ 1576 | 1577 |
1578 | 1579 | ### 문자열 기능 함수 `mutating` 1580 | - reverse(string.begin(), string.end()) 1581 | - 문자열을 뒤집어준다. 접근한 문자열 자체 함수 내에서 변경된다. 1582 | ~~~ C++ 1583 | /// MARK: - reverse() 사용 예시) 1584 | #include 1585 | #include 1586 | #include 1587 | #include 1588 | using namespace std; 1589 | 1590 | int calcReversedNumber(const int &a, const int &b) { 1591 | string aStr = to_string(a); 1592 | string bStr = to_string(b); 1593 | /// 1) aStr, bStr을 뒤집는다. 1594 | reverse(aStr.begin(), aStr.end()); 1595 | reverse(bStr.begin(), bStr.end()); 1596 | 1597 | /// 2) 뒤집은 문자열을 숫자로 변환 후 계산한 결과를 다시 문자열 변환 후 reversedResult에 넣는다. 1598 | string reversedResult = to_string(stoi(aStr) + stoi(bStr)); 1599 | 1600 | /// 3) 연산 결과를 다시 뒤집어 숫자로 변환 -> 값을 반환한다. 1601 | reverse(reversedResult.begin(), reversedResult.end()); 1602 | return stoi(reversedResult); 1603 | } 1604 | 1605 | int main() { 1606 | ios_base :: sync_with_stdio(0); cin.tie(0); 1607 | int T; cin >> T; 1608 | while(T--) { 1609 | int a,b; cin >> a >> b; 1610 | int Ans = calcReversedNumber(a,b); 1611 | printf("%d\n",Ans); 1612 | } 1613 | return 0; 1614 | } 1615 | ~~~ 1616 | 1617 |
1618 | 1619 | - tolower(), toupper() 1620 | - 문자 or 문자열의 대소문자 변환 함수 1621 | ~~~ C++ 1622 | /// 문자열 대소문자 변환 예시) 1623 | int main() { 1624 | ios_base :: sync_with_stdio(0); cin.tie(0); 1625 | string S; cin>>S; 1626 | /// * 만약 대문자면 tolower(), 소문자면 toupper()를 사용하면 대소문자를 변환 시킨다. 1627 | for(int i=0; i 1634 | 1635 | - strtol 1636 | - 문자열의 진법표현을 다른 진법표현으로 변환할 수 있다. 1637 | - 기능 1638 | ~~~ C++ 1639 | // 8진법은 oct, 16진법은 hex 1640 | // 8진법 0, 16진법 0x 1641 | #include 1642 | void convertHexCode() { 1643 | string S; 1644 | int cnt=0; 1645 | while(cnt<=1000) { 1646 | cin>>S; 1647 | cnt+=S.length(); 1648 | string Ans=""; 1649 | while(S.length()!=0) { 1650 | string temp = "0x" + S.substr(0,2); 1651 | /// * strtol() 함수를 사용해 16진수를 10진수로 변환한다. 1652 | long num = strtol(temp.c_str(),NULL,16); 1653 | Ans += char(num); 1654 | S = S.substr(2); 1655 | } 1656 | printf("%s\n",Ans.c_str()); 1657 | } 1658 | return; 1659 | } 1660 | ~~~ 1661 | 1662 |
1663 | 1664 | ~~~ C++ 1665 | /// MARK: - 8진수, 10진수, 16진수 별 10진수 변환 출력하기 예제 1666 | // * stdlib.h 를 추가 후, strtol을 사용하여 간단하게 진수 변환 가능 1667 | #include 1668 | #include 1669 | #include 1670 | using namespace std; 1671 | 1672 | void octalAndDecimalAnsHexaDecimal() { 1673 | string S; cin>>S; 1674 | long Ans=0; 1675 | if(S[0]=='0') { 1676 | if(S[1]=='x') Ans = strtol(S.c_str(), NULL, 16); 1677 | else Ans = strtol(S.c_str(), NULL, 8); 1678 | } else Ans=stoi(S); 1679 | printf("%ld\n",Ans); 1680 | return; 1681 | } 1682 | ~~~ 1683 | 1684 |
1685 |
1686 | 1687 | ## 자주 사용되는 헤더(Header) 1688 | 1689 |
1690 | 1691 | ### iostream 1692 | - C++ 입출력 헤더 1693 | - cin, cout 등의 입출력 함수 사용 가능 1694 | - * C++_입출력 코너 참고 1695 | 1696 |
1697 | 1698 | ### algorithm 1699 | - sort(), fill(), reverse() 등 다양한 유용 함수 제공 1700 | - sort() 1701 | - 퀵정렬+힙정렬을 혼합한 정렬함수 제공 1702 | ~~~ C++ 1703 | sort(V.begin(), V.end(), greater); 1704 | ~~~ 1705 | 1706 |
1707 | 1708 | - reverse 1709 | - 시퀀스 컨테이너의 요소를 뒤집어주는 함수, mutating 함수 1710 | ~~~ C++ 1711 | reverse(S.begin(), S.end()); 1712 | ~~~ 1713 | 1714 |
1715 | 1716 | - fill 1717 | - 특정 시퀄스 영역을 특정 값으로 채워 줌 1718 | ~~~ C++ 1719 | // 배열의 경우) 1720 | fill(begin(Visit), begin(Visit)+N+1, false); 1721 | 1722 | // 벡터의 경우) 1723 | fill(V.begin(), V.end(), true); 1724 | ~~~ 1725 | 1726 |
1727 | 1728 | ### bits/stdc++.h 1729 | - 알고리즘 간 사용될 수 있는 모든 기능을 사용할 수 있다. 1730 | - Visual Studio가 아닌 Xcode 등 일부 환경에서는 사용 불가능하다. 1731 | 1732 |
1733 | 1734 | ### string 1735 | - 문자열 타입, string 사용 시 추가 1736 | 1737 |
1738 | 1739 | ### sstream 1740 | - stringstream 1741 | - 문자열의 공백 간 분리 기능 사용 예시 ▼ 1742 | 1743 | ~~~ C++ 1744 | #include 1745 | #include 1746 | using namespace std; 1747 | 1748 | int main() { 1749 | string s = "my name is asdf"; 1750 | stringstream ss(s); 1751 | 1752 | string dat; 1753 | while (ss >> dat) cout << dat << '\n'; 1754 | } 1755 | ~~~ 1756 | 1757 |
1758 | 1759 |
1760 |
1761 | 1762 | ## ✓ C++_입출력 1763 | - 출력 1764 | - printf("...") / cout << ... 1765 | - 입력 1766 | - scanf("%d",&value) / cin >> ... 1767 | 1768 |
1769 | 1770 | ### cin / cout 입출력 속도 개선 1771 | - printf(), scanf() 사용에 제한이 생기므로 사용에 주의가 따른다. 1772 | ~~~ C++ 1773 | /// cin / cout 입출력 속도 개선방법 예시) 1774 | ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 1775 | ~~~ 1776 | 1777 |
1778 | 1779 | ### while + 일괄 입력 처리 1780 | - while문 + cin 을 사용해서 일괄적인 값들을 읽어들일 수 있다. 1781 | ~~~ C++ 1782 | /// while(cin >> value) 사용예시 1783 | int sum=0; 1784 | int value=0; 1785 | while(cin >> value) { 1786 | sum += value; 1787 | } 1788 | ~~~ 1789 | 1790 |
1791 | 1792 | ### 끝을 모르는 입력을 받을때 사용하는 while(scanf()) 1793 | - 입력의 구체적인 끝이 주어지지 않았을때 사용할 수 있다. 1794 | - while(1), while(true)를 사용하면 출력초과가 발생하는 경우 대체로 사용 가능하다. 1795 | ~~~ C++ 1796 | /// 끝을 모르는 입력 받을때 사용 예시 1797 | void thePermutation() { 1798 | char str[11]; memset(str,' ',sizeof(str)); 1799 | int pos; 1800 | 1801 | while(scanf("%s %d",str,&pos)!=EOF) { 1802 | string S(str); 1803 | sort(S.begin(),S.end()); 1804 | int cnt=1; 1805 | bool flag=false; 1806 | printf("%s %d = ",S.c_str(),pos); 1807 | do { 1808 | if(cnt==pos) { 1809 | printf("%s\n",S.c_str()); 1810 | flag=true; 1811 | break; 1812 | } 1813 | cnt++; 1814 | 1815 | }while(next_permutation(S.begin(),S.end())); 1816 | if(!flag) printf("No permutation\n"); 1817 | } 1818 | return; 1819 | } 1820 | ~~~ 1821 | 1822 |
1823 | 1824 | ### 특정 길이의 문자열을 계속 입력받을 때 사용하는 getchar(), fgets..., ~scanf()... 1825 | - while(~scanf("%c", &C)) {} 1826 | - while((C=getchar()) != EOF) {} 1827 | ~~~ swift 1828 | #include 1829 | #include 1830 | using namespace std; 1831 | 1832 | int main() { 1833 | vector AV(26,0); 1834 | char C; 1835 | // 문자열 특정 갯수까지 계속 입력받기 1) 1836 | while(~scanf("%c", &C)) { 1837 | if(C>='a' && C<='z') AV[C-'a']++; 1838 | } 1839 | 1840 | // 문자열 특정 갯수까지 계속 입력받기 2) 1841 | // while((C=getchar()) != EOF) { 1842 | // if(C>='a' && C<='z') AV[C-'a']++; 1843 | // } 1844 | 1845 | int max = 0; 1846 | for(int i=0; i<26; i++) max = max 1854 | 1855 |
1856 |
1857 | 1858 | ## ✓ iterator, 반복자로 주소 접근하기 1859 | - 반복자(iterator) 사용방법 1860 | - <타입>::iterator `반복자이름`; 1861 | - 반복자 활용 예시 ▼ 1862 | ~~~ C++ 1863 | // 반복자(iterator) 정의 1864 | vector>::iterator iter; 1865 | 1866 | // iter 변수의 초기값이 vector contest의 첫 주소값을 가리키게, 주소값 끝까지 순회한다. 1867 | for(iter=contests.begin(); iter!=contests.end(); iter++) { 1868 | // 특정 주소에 위치한 값을 접근하려면 iter 앞에 `*`를 붙이면 된다. 1869 | if((*iter)[1]==1) { 1870 | if(k>0) { 1871 | Ans += (*iter)[0]; 1872 | k--; 1873 | } else { 1874 | Ans -= (*iter)[0]; 1875 | } 1876 | } else { 1877 | Ans += (*iter)[0]; 1878 | } 1879 | } 1880 | ~~~ 1881 | 1882 | ### iterator 값 접근 방법 1883 | - 1) iterator 변수에 -> 를 통한 값 접근 1884 | ~~~ C++ 1885 | // map::iterator iter의 key 값 접근 1886 | iter->first; 1887 | // map::iterator iter의 value 값 접근 1888 | iter->second; 1889 | ~~~ 1890 | 1891 |
1892 | 1893 | - 2) iterator 변수 앞에 *를 찍고 감싼 뒤 '.'으로 접근 1894 | ~~~ C++ 1895 | // map::iterator iter의 값을 (*iter).<값> 으로 접근 가능 1896 | // (*iter)를 사용해 map의 second(value 값)에 접근하고 이다. 1897 | if((*iter).second != 0) { Ans = iter->first; } 1898 | ~~~ 1899 | 1900 | 1901 | - iterator 값 접근 예시 ▼ 1902 | ~~~ C++ 1903 | #include 1904 | #include 1905 | #include 1906 | 1907 | using namespace std; 1908 | 1909 | string solution(vector participant, vector completion) { 1910 | // 해시테이블로 선수들의 정보를 저장한다. 1911 | // HASH -> Key: 선수들 이름 / Value: 선수들 도착 유무 1912 | map m; 1913 | string Ans = ""; 1914 | for(auto p : participant) m[p]++; 1915 | for(auto c : completion) m[c]--; 1916 | 1917 | map::iterator iter; 1918 | for(iter=m.begin(); iter!=m.end(); iter++) { 1919 | if((*iter).second != 0) { Ans = iter->first; } 1920 | } 1921 | return Ans; 1922 | } 1923 | ~~~ 1924 | 1925 |
1926 | 1927 | ### iterator 역방향 반복자 사용하기 1928 | - iterator에 rbegin(), rend() 를 로 접근해서 역방향 반복자를 사용 가능하다. 1929 | - 반복자를 역순으로 순회하고자 할 때 사용 가능하다. 1930 | - 역방향 반복자 사용 예시 1931 | ~~~ swift 1932 | #include 1933 | #include 1934 | #include 1935 | using namespace std; 1936 | 1937 | int main() { 1938 | ios_base :: sync_with_stdio(0); cin.tie(0); 1939 | int N; cin>>N; 1940 | vector V(N,0); 1941 | for(int i=0; i>V[i]; 1942 | sort(V.begin(),V.end()); 1943 | // V.rbegin() ~ V.rend() 구간은 V 벡터의 역방향 순회를 하게 된다. 1944 | for(auto iter = V.rbegin(); iter!=V.rend(); ++iter) { 1945 | printf("%d\n",*iter); 1946 | } 1947 | 1948 | return 0; 1949 | } 1950 | ~~~ 1951 | 1952 |
1953 |
1954 | 1955 | ## 자주 사용되는 함수 1956 | 1957 |
1958 |
1959 | 1960 | ### memset() 1961 | 1962 |
1963 | 1964 | ### fill_n(주소, 초기화 영역, 초기화 값) 1965 | - 배열, 벡터 초기화 변수 1966 | - fill_n 함수 사용 예시) ▼ 1967 | ~~~ C++ 1968 | chk = new bool[41]; 1969 | dp = new Pair[41]; 1970 | fill_n(chk, 41, false); 1971 | fill_n(dp, 41, make_pair(0, 0)); 1972 | ~~~ 1973 |
1974 | 1975 | ### memset(주소, 초기화 값, 초기화영역 메모리 크기) 1976 | - 배열, 벡터 초기화 변수 1977 | - memset 함수 사용 예시) ▼ 1978 | ~~~ C++ 1979 | int a[101]; 1980 | int main(){ 1981 | int K; 1982 | memset(a,0,sizeof(a)); 1983 | return 0; 1984 | } 1985 | ~~~ 1986 | 1987 | ### sizeof(<변수>) 1988 | - 변수의 메모리 사이즈를 반환한다. 1989 | - sizeof 사용 예시) ▼ 1990 | ~~~ C++ 1991 | int score[3] = {0,0,0}; 1992 | sizeof(score)/sizeof(int); // score 메모리사이즈 12(4 * 3byte), int 메모리사이즈 4(4byte) 1993 | ~~~ 1994 | 1995 |
1996 | 1997 | ### min_element, max_element 1998 | - 기능 1999 | - 배열, 벡터 등의 특정 영역 최댓값, 최솟값을 주소로 반환한다. 2000 | - 실제 최솟값, 최댓값을 구하려면 min_element, max_element 함수 앞에 '*'을 붙여 접근 가능하다. 2001 | ~~~ C++ 2002 | // min_element, max_element 사용예시 2003 | // 실제 최솟값, 최댓값을 구하려면 min_element, max_element 함수 앞에 *을 붙여 접근 가능하다. 2004 | for(int i=0; i 2012 | 2013 | ### lower_bound(first iterator, last iterator, Value) 2014 | - Binary Search Structure 2015 | - Value값 이상의 값이 존재하는 iterator를 반환한다. 2016 | 2017 | ### upper_bound(first iterator, last iterator, Value) 2018 | - Binary Search Structure 2019 | - Vallue값 초과의 값이 존재하는 iterator를 반환핟나. 2020 | 2021 |
2022 | 2023 | ### c_str() 2024 | - C++ string 문자열을 C에 호환 가능한 문자배열형으로 변환시켜준다. 2025 | - 문자열을 출력 가능한 상태로 만들 수 있다. 2026 | - 문자열 데이터를 출력할때 사용할 수 있다. 2027 | ~~~ C++ 2028 | // c_str() 사용 예시) 2029 | printf("%s",twoStrings("hi","world").c_str()); 2030 | ~~~ 2031 | 2032 |
2033 | 2034 | ### substr() 2035 | - 사용방법 2036 | ~~~ C++ 2037 | s.substr(<시작인덱스>,<잘라낼길이>)ㅣ 2038 | ~~~ 2039 | 2040 |
2041 | 2042 | ### strcat(<문자열1>,<문자열2>) 2043 | - 문자열 두개를 붙인다. 2044 | ~~~ C++ 2045 | #include 2046 | int main() { 2047 | string s1="AB", s2="AV"; 2048 | strcat(s1,s2); // "ABAV" 2049 | return 0; 2050 | } 2051 | ~~~ 2052 | 2053 |
2054 | 2055 | ### strtok 2056 | - 문자열을 특정 문자 기준으로 잘라낸다. 2057 | ~~~ C++ 2058 | /// MARK: - strtok 사용, 문자열 잘라내기 예시) 2059 | 2060 | int main() { 2061 | char s1[30] = "The Little Prince"; // 크기가 30인 char형 배열을 선언하고 문자열 할당 2062 | 2063 | char *ptr = strtok(s1, " "); // " " 공백 문자를 기준으로 문자열을 자름, 포인터 반환 2064 | 2065 | while (ptr != NULL) // 자른 문자열이 나오지 않을 때까지 반복 2066 | { 2067 | printf("%s\n", ptr); // 자른 문자열 출력 2068 | ptr = strtok(NULL, " "); // 다음 문자열을 잘라서 포인터를 반환 2069 | } 2070 | 2071 | return 0; 2072 | } 2073 | ~~~ 2074 | 2075 |
2076 | 2077 |
2078 | 2079 |
2080 | 2081 |
2082 | 2083 | - 문자열을 일부 잘라 반환해준다. 2084 | 2085 | ~~~ C++ 2086 | // substr() 사용 예시 2087 | // 0번째 인덱스부터 5 길이 만큼 문자열을 잘라 반환한다. 2088 | string str = s.substr(0,5); 2089 | ~~~ 2090 | 2091 |
2092 | 2093 | ### to_string 2094 | - Convert Type Int to Stirng 2095 | ~~~ C++ 2096 | string answer = ""; 2097 | vector Ans = {1,2,3,4,5}; 2098 | 2099 | // vector Ansd의 맨 앞의 값을 문자열로 변환하여 answer에 추가한다. 2100 | answer += to_string(Ans.front()) + " "; // "1 " 2101 | answer += to_string(Ans.back()); // "1 2" 2102 | ~~~ 2103 | 2104 |
2105 | 2106 | ### stoi(), stol(), stof(), stod() 2107 | - string에서 다른 타입으로 변환 시 사용 2108 | - Convert String to Int/long/Float/Double 2109 | - 함수원형 2110 | - **stoi (string to Int(정수형))** 2111 | - int stoi(const string& str, size_t* idx=0, int base=10) 2112 | - stol (string to long(정수형)) 2113 | - long stol(const string& str, size_t* idx=0, int base=10) 2114 | - stof (string to float(실수형)) 2115 | - float stof(const string& str, size_t* idx=0) 2116 | - stod (string to double(실수형)) 2117 | - double stod(const string& str, size_t* idx=0) 2118 | 2119 | - 사용 에시 ▼ 2120 | ~~~ C++ 2121 | string str_i = "3"; 2122 | string str_li = "2100000000"; 2123 | string str_f = "7.2"; 2124 | string str_d = "3.141592"; 2125 | 2126 | // stoi의 사용 : string to int 2127 | int i = stoi(str_i); 2128 | 2129 | // stol의 사용 : string to long 2130 | long int li = stol(str_li) 2131 | 2132 | // stof의 사용 : string to float 2133 | float f = stof(str_f); 2134 | 2135 | // stod의 사용 : string to double 2136 | double d = stod(str_d); 2137 | ~~~ 2138 | 2139 | 2140 |
2141 | 2142 | ### swap(<값1>, <값2>) 2143 | - 두개의 값을 받아 스왑한다. 'mutating' 2144 | - swap 사용 예시 ▼ 2145 | ~~~ C++ 2146 | int minimumSwaps(vector arr) { 2147 | int Ans = 0; 2148 | for(int i=0; i::iterator iter = find(arr.begin()+i+1, arr.end(), i+1); 2153 | swap(arr[i],arr[iter-arr.begin()]); 2154 | // i번째 숫자를 스왑할때마다 횟수를 기록한다. 2155 | Ans++; 2156 | } 2157 | return Ans; 2158 | } 2159 | ~~~ 2160 | 2161 |
2162 | 2163 | ### erase() 2164 | - 사용방법 2165 | - erase(<시작인덱스>) : 시작인덱스 ~ 끝까지 요소를 삭제한다. 2166 | - erase(<시작인덱스>,<삭제할길이>) : 시작인덱스 기준 특정 삭제할길이만큼 삭제한다. 2167 |
2168 | 2169 | ~~~ C++ 2170 | // erase() 사용 예시) 2171 | 2172 | int main() { 2173 | string s = "This is an example"; 2174 | cout << s << '\n'; 2175 | 2176 | // Erase "This " 2177 | // -> 0인덱스 기준, 5만큼의 길이를 삭제한다. 2178 | s.erase(0, 5); 2179 | cout << s << '\n'; 2180 | 2181 | // Erase ' ' 2182 | // -> ' ' 최초 공백을 제거한다. 2183 | s.erase(find(s.begin(), s.end(), ' ')); 2184 | cout << s << '\n'; 2185 | 2186 | // Trim from ' ' to the end of the string 2187 | // -> 최초 공백부터 끝까지 삭제한다. 2188 | s.erase(s.find(' ')); 2189 | cout << s << '\n'; 2190 | } 2191 | ~~~ 2192 | 2193 |
2194 | 2195 | ### find() 2196 | - 특정 요소가 있는지 확인 후 해당 요소가 있는 주소를 반환한다. 2197 | - 요소가 없을 시 순회했는 자료구조의 맨 끝 주소(end())를 반환한다. 2198 | 2199 | ~~~ C++ 2200 | // find() 사용 예시) 2201 | for(auto s : m1) { 2202 | // m2.end() : map자료구조, m2에 요소가 있다면 m2.end()는 반환하지 않는다 2203 | // m2.end()는 m2의 끝 주소로 요소가 없음을 나타내는 것 2204 | // Thus, 아래의 조건문은 요소가 있을 시 "Yes" 문자열을 반환하라는 코드가 된다. 2205 | if (m2.find(s) != m2.end()) { 2206 | return "YES"; 2207 | } 2208 | } 2209 | ~~~ 2210 | 2211 |
2212 | 2213 | ### insert() 2214 | - map 등의 자료구조에 요소를 넣는데 사용한다. 2215 | 2216 | ~~~ C++ 2217 | // insert() 사용 예시) 2218 | for(auto s : s2) { 2219 | m2.insert(s); 2220 | } 2221 | ~~~ 2222 | 2223 | 2224 |
2225 |
2226 |
2227 | 2228 | # Swift_알고리즘 2229 | 2230 |
2231 |
2232 | 2233 | ## Swift_자료구조 2234 | 2235 |
2236 |
2237 | 2238 | ## ✓ Array 2239 | - 스위프트의 기본적인 배열 2240 | - 정의 방법 2241 | 2242 |
2243 | 2244 | ~~~ swift 2245 | // 배열의 초기화 사용 예시) 2246 | let arr: [Int] = [] 2247 | let arr2 = [String]() 2248 | let arr3: Array = Array() 2249 | ~~~ 2250 | 2251 |
2252 | 2253 | - 배열 인덱스, **Array.Index의 접근(읽기) 복잡도 : O(1)** 2254 | - **String.Index의 접근 복잡도는 O(N)** 2255 | - 그러므로 String 접근 시 효율성이 필요하다면 배열로 변환 후 접근할 필요가 있다. 2256 | 2257 |
2258 | 2259 | ~~~ swift 2260 | // 배열 사용 예제 2261 | func sherlockAndAnagrams(s: String) -> Int { 2262 | 2263 | // 아래처럼 문자열 s를 배열화 시켜서 다룰 수 있다. 2264 | let arr = Array(s) 2265 | 2266 | var Anagram = 0 2267 | for length in 0 ... arr.count - 2 { 2268 | var dic = [String: Int]() 2269 | for j in 0 ..< arr.count - length { 2270 | 2271 | // 스위프트에서는 배열접근 시 아래와 같이 범위(...)를 지정해서 요소들을 접근할 수 있다. 2272 | for j in 0 ..< arr.count - length { 2273 | let txt = String(arr[j ... j + length].sorted()) 2274 | dic[txt] = (dic[txt] ?? 0) + 1 2275 | } 2276 | 2277 | for k in dic { 2278 | Anagram += (k.value * (k.value - 1) / 2) 2279 | } 2280 | } 2281 | return Anagram 2282 | } 2283 | ~~~ 2284 | 2285 |
2286 | 2287 | ### 초기화 방법 2288 | - Array<타입>(repeating:<반복값>,count:<할당크기>) 2289 | - Array Initialzation Example ▼ 2290 | ~~~ swift 2291 | // 배열 초기화 예시) 2292 | // chk: [Bool] 배열에 n+1의 크기만큼 true값을 적용한다. 2293 | var chk = [Bool](repeating: true, count: n+1) 2294 | ~~~ 2295 | 2296 |
2297 | 2298 | ### ✱ Array 기능 2299 | - count 2300 | - 배열의 크기를 반환한다. 2301 | - min() -> Int? 2302 | - 요소 내 최솟값을 반환한다. 2303 | - min() -> Int? 2304 | - 요소 내 최댓값을 반환한다. 2305 | - first? 2306 | - 배열의 맨 앞 요소를 반환한다. 2307 | - last? 2308 | - 배열의 맨 마지막 요소를 반환한다. 2309 | - sorted(), filter(), map(), reduce() 등 고차함수 사용 가능(고차함수 탭 참고) 2310 | - append(<값>), append(contentsOf: <범위값>) 2311 | - 배열의 맨 뒤에 요소를 추가한다. 2312 | - isEmpty -> Bool 2313 | - 배열 요소가 비어있는지 확인 후 Bool값을 반환한다. 2314 | ~~~ swift 2315 | func appnd() { 2316 | var arr = [Int]() 2317 | arr.append(3) // arr 뒤에 3을 추가한다. -> [3] 2318 | arr.append(2) // arr 뒤에 2을 추가한다. -> [3,2] 2319 | print(arr) // -> [3,2] 2320 | 2321 | var arr = [1,2,3,4,5,6] 2322 | print("nowArray elements : \(arr)") // -> [1,2,3,4,5,6] 2323 | arr.removeSubrange(0...1) // 0 ~ 1번째 인덱스의 값을 삭제 2324 | print("arr.removeSubrange(0...1) : \(arr)") // -> [3,4,5,6] 2325 | 2326 | arr.append(contentsOf: arr[0...1]) // 현재 arr의 0 ~ 1번째 인덱스 영역의 값을 arr 뒤에 추가한다. 2327 | print("arr.append(contentsOf: arr[0...1]) : \(arr)") // -> [3,4,5,6,3,4] 2328 | } 2329 | ~~~ 2330 | 2331 |
2332 | 2333 | - insert(_ newElement: Element, at i: Int) 2334 | - 특정 인덱스에 값을 추가한다. 2335 | - (at: <값>) 2336 | ~~~ swift 2337 | func insertion() { 2338 | var arr = [1,2,3] 2339 | print("nowArray elements : \(arr)") // -> [1,2,3] 2340 | 2341 | arr.insert(99, at: 0) // 맨 앞에 99를 추가한다. 2342 | print("arr.insert(99, at: 0) : \(arr)") // -> [99, 1, 2, 3] 2343 | 2344 | arr.insert(99, at: arr.endIndex) // 맨 뒤에 99를 추가한다. 2345 | print("arr.insert(99, at: arr.count) : \(arr)") // -> [99, 1, 2, 3, 99] 2346 | } 2347 | ~~~ 2348 | 2349 |
2350 | 2351 | - remove(at:<인덱스>) 2352 | - <인덱스>번째의 요소를 제거한다. 2353 | ~~~ swift 2354 | func rm() { 2355 | var arr = [1,2,3,4,5,6] 2356 | print("nowArray elements : \(arr)") 2357 | 2358 | arr.remove(at: 0) 2359 | print("arr.remove(at: 0) : \(arr)") // => [2,3,4,5,6] 2360 | 2361 | arr.remove(at: arr.count-1) 2362 | print("arr.remove(at: arr.count-1) : \(arr)") // => [2,3,4,5] 2363 | } 2364 | ~~~ 2365 | 2366 |
2367 | 2368 | - removeLast() 2369 | - 마지막 요소를 삭제한다. 2370 | ~~~ swift 2371 | func rmLast() { 2372 | var arr = [1,2,3,4,5,6] 2373 | print("nowArray elements : \(arr)") 2374 | 2375 | arr.removeLast() 2376 | print("arr.removeLast() : \(arr)") // => [1,2,3,4,5] 2377 | } 2378 | ~~~ 2379 | 2380 |
2381 | 2382 | - removeFirst() 2383 | - 맨 앞의 요소를 삭제한다. 2384 | ~~~ swift 2385 | func rmFirst() { 2386 | var arr = [1,2,3,4,5,6] 2387 | print("nowArray elements : \(arr)") 2388 | 2389 | arr.removeFirst() 2390 | print("arr.removeFirst() : \(arr)") // => [2,3,4,5,6] 2391 | } 2392 | ~~~ 2393 | 2394 |
2395 | 2396 | - removeAll() 2397 | - 배열 내 모든 요소를 제거하여 빈 배열로 만든다. 2398 | ~~~ swift 2399 | func rmAll() { 2400 | var arr = [1,2,3,4,5,6] 2401 | print("nowArray elements : \(arr)") 2402 | 2403 | arr.removeAll() 2404 | print("removeAll() : \(arr)") // [] 2405 | } 2406 | ~~~ 2407 | 2408 |
2409 | 2410 | - removeSubrange 2411 | - 특정 범위 인덱스의 값들을 제거한다. 2412 | ~~~ swift 2413 | func rmSubrange() { 2414 | var arr = [1,2,3,4,5,6] 2415 | 2416 | arr.removeSubrange(0...1) // 0 ~ 1번째 인덱스의 값을 삭제 2417 | print("arr.removeSubrange(0...1) : \(arr)") // [3,4,5,6] 2418 | } 2419 | ~~~ 2420 | 2421 |
2422 | 2423 | - firstIndex(of:<값>) -> Int? 2424 | - 배열 맨 앞에 나오는 <값>의 정수형 인덱스를 반환한다. 2425 | - firstIndex(of:<값>) -> Int? 2426 | - 배열 맨 마지막에 나오는 <값>의 정수형 인덱스를 반환한다. 2427 | 2428 |
2429 | 2430 | - swapAt(<인덱스1>,<인덱스2>) 2431 | - 두개의 요소를 교환한다. 2432 | 2433 | ~~~ swift 2434 | // swapAt() 사용 예시) 2435 | // j, j+1 인덱스의 요소를 교환한다. 2436 | arr.swapAt(j, j+1) 2437 | ~~~ 2438 | 2439 |
2440 | 2441 | - elementsEqual() 2442 | - 요소를 비교한 결과를 반환한다. 2443 | 2444 |
2445 |
2446 | 2447 | ## ✓ Dictionary 2448 | - 키(Key)와 값(Value)로 이루어 져 있는 자료구조 2449 | - 키와 값은 특정 타입을 허용한다. 2450 | - 키(Key) : Hashable프로토콜을 준수하는 값만 사용 가능 2451 | - 값(Value) : Any(어떠한 값이던 사용 가능) 2452 | - 딕셔너리의 키를 접근하면 옵셔널(?)값이 나온다. 2453 | - 사용 방법(초기화 방법) 2454 | 2455 |
2456 | 2457 | ~~~ swift 2458 | // 딕셔너리의 초기화 사용 예시) 2459 | let dictionary: [Int:String] = [:] 2460 | let dictionary = [String:Int]() 2461 | 2462 | // 2463 | for length in 0...arr.count-2 { 2464 | var dic = [String:Int]() 2465 | for i in 0.. 2478 | 2479 | ### ✱ Dictionary 기능 2480 | - values : 현재 딕셔너리 내에 있는 값들을 출력한다. 2481 | - **sorted(), filter(), map(), reduce()등 고차함수 사용 가능** 2482 | - key, value : 키, 값을 반환한다. 2483 | - **index(forKey:) -> Dictionary.Index** : 딕셔너리의 인덱스를 반환한다. 2484 | ~~~ swift 2485 | 2486 | // index(forKey:) 사용 예시) 2487 | // 딕셔너리 변수, dic 초기화 2488 | var dic = [Int:Int]() 2489 | for i in cost.indices { 2490 | dic[cost[i]] = i 2491 | } 2492 | 2493 | for i in 0.. 있으면 해당 Index, 없으면 nil을 반환한다. 2497 | let dicIdx = dic.index(forKey: money-cost[i]) 2498 | 2499 | // ✭ 해당 키값이 존재 했으면 Index가 반환되여 해당 인덱스의 키, 값에 접근할 수 있다. 2500 | if dicIdx != nil && i != dic[dicIdx!].value { 2501 | print(i+1,dic[dicIdx!].value+1, separator: " ") 2502 | return 2503 | } 2504 | } 2505 | ~~~ 2506 | 2507 |
2508 |
2509 | 2510 | ## ✓ Set 2511 | - 집합 자료구조 2512 | - 집합요소는 각각 중복 요소가 없는 단일 값이다. 2513 |
2514 | 2515 | ### Set 초기화 방법 2516 | - Set 초기화 방법 예시) ▼ 2517 | ~~~ swift 2518 | // Set 초기화 사용 예시) 2519 | let set = Set() 2520 | let set2: Set = [1,2,3] 2521 | let set3: Set = [] 2522 | ~~~ 2523 | 2524 |
2525 | 2526 | ### Set 기능 2527 | - insert(<값>) 2528 | - Set 자료구조에 요소를 삽입한다. 2529 | ~~~ swift 2530 | var setV = Set() 2531 | setV.insert(3) // 요소 삽입 2532 | setV.insert(3) // 요소 삽입 시 중복값은 취급안함 2533 | ~~~ 2534 | 2535 |
2536 | 2537 | 2538 | - index(of:<값>) -> Int? 2539 | - 특정 값의 인덱스를 반환 2540 | ~~~ swift 2541 | var idx = setV.index(of: 3)! //index(of:) 사용 후 만약 해당 값이 존재하지 않으면 nil을 반환한다. 2542 | ~~~ 2543 | 2544 |
2545 | 2546 | - remove(<값>), remove(at:) 2547 | - 특정 값, 특정 위치의 요소를 제거한다. 2548 | ~~~ swift 2549 | var setV: Set = ["1", "2", "3"] 2550 | setV.remove("3") // 특정 값을 인자로 받아 해당 값을 제거 2551 | setV.remove(at: setV.index(of:"1")!) // 특정 정수형 인덱스에 위치한 값을 제거(Set.Index) 2552 | ~~~ 2553 | 2554 |
2555 | 2556 | - removeAll() 2557 | - Set 자료구조 내 모든 요소를 지운다. 2558 | ~~~ swift 2559 | setV.removeAll() // => [] 2560 | ~~~ 2561 | 2562 |
2563 | 2564 | - **집합연산 기능** 2565 | - 합집합, union 2566 | - 교집합, intersection 2567 | - 여집합, subtracting 2568 | - 합집합 - 여집합, symmetricDifference 2569 | 2570 | ~~~swift 2571 | 2572 | var a: Set = [1,2,3] 2573 | var b: Set = [3,4,5] 2574 | 2575 | // 집합 연산 사용예시 2576 | // 합집합 연산 2577 | a.union(b) // => [1,2,3,4,5] 2578 | 2579 | // 교집합 연산 2580 | a.intersection(b) // => [3] 2581 | 2582 | // 여집합 연산 2583 | a.subtracting(b) // => [1,2] 2584 | 2585 | // 합집합 - 교집합 연산 2586 | a.symmetricDiffernce(b) // => [1,2,4,5] 2587 | ~~~ 2588 | 2589 | 2590 |
2591 |
2592 | 2593 | ## ✓ Queue 2594 | - 스위프트 Queue의 사용 2595 | - FIFO(Fire In First Out) 방식 2596 | 2597 | - 간단한 QueueArray 구현 예시) ▼ 2598 | ~~~ swift 2599 | struct Queue { 2600 | private(set) var elements: Array = [] 2601 | mutating func push(value: T) { elements.append(value) } // O(1) 2602 | mutating func pop() -> T { return elements.removeFirst() } // O(`count`) 2603 | } 2604 | ~~~ 2605 | 2606 | - Queue 프로토콜 구현 예시) ▼ 2607 | 2608 | ~~~ swift 2609 | // MARK: - Queue 2610 | 2611 | // MARK: FIFO방식의 Queue 프로토콜 구현 2612 | 2613 | // Int, String, Double, Float 어떠한 타입으로 지정하던 Element라는 별칭으로서 사용되어질 수 있다. 2614 | // * associatedtype : 프로토콜을 정의할 때, 제네릭타입과 같이 일반화 시킨 타입을 지정할때 사용할 수 있다. 2615 | import Foundation 2616 | 2617 | // MARK: - FIFO방식의 Queue 2618 | 2619 | public protocol Queue { 2620 | // Queue의 데이터타입 별칭을 Element로 지정합니다. 2621 | associatedtype Element 2622 | 2623 | // 큐의 요소를 FIFO방식으로 추가합니다. 2624 | mutating func push(_ element: Element) -> Bool 2625 | 2626 | // 큐의 요소를 FIFO방식으로 제거합니다. 2627 | mutating func pop() -> Element? 2628 | 2629 | // 해당 큐가 비어있는지를 확인합니다. 2630 | var isEmpty: Bool { get } 2631 | 2632 | // 해당 큐의 앞쪽에 요소가 존재하는지 확인합니다. 2633 | var front: Element? { get } 2634 | 2635 | // 해당 큐의 뒷쪽에 요소가 존재하는지 확인합니다. 2636 | var back: Element? { get } 2637 | } 2638 | ~~~ 2639 | 2640 |
2641 |
2642 | 2643 | ## ✓ QueueArray 2644 | - Array를 활용한 Queue의 구현 + Queue프로토콜 활용 2645 | - **push 시간 복잡도 : 평소 O(1) 최악 O(N)** -> 배열 공간의 요소가 다 찼을때 배열공간 확장으로 O(N)의 복잡도 될 수 있음 2646 | - **pop 시간 복잡도 : O(N)** -> 배열 맨 앞의 요소 제거 후 전체 요소를 전부 좌 쉬프트 해야하기 때문이다. 2647 | - 구현 예시) ▼ 2648 | 2649 | ~~~ swift 2650 | // MARK: - QueueArray 2651 | 2652 | // MARK: Array를 사용한 Queue 구현 2653 | 2654 | import Foundation 2655 | 2656 | public struct QueueArray: Queue { 2657 | private var elements = [T]() 2658 | public mutating func push(_ element: T) -> Bool { 2659 | elements.append(element) 2660 | return true 2661 | } 2662 | 2663 | public mutating func pop() -> T? { 2664 | return elements.removeFirst() 2665 | } 2666 | 2667 | public var isEmpty: Bool { 2668 | return elements.isEmpty 2669 | } 2670 | 2671 | public var front: T? { 2672 | return elements[0] 2673 | } 2674 | 2675 | public var back: T? { 2676 | return elements[elements.count - 1] 2677 | } 2678 | } 2679 | ~~~ 2680 | 2681 |
2682 |
2683 | 2684 | ## ✓ Stack 2685 | - 스위프트 Stack의 사용 2686 | - FILO(Fire In Last Out) 방식 2687 | 2688 | ~~~ swift 2689 | struct Stack { 2690 | public private(set) var items: Array = [] 2691 | mutating func push(item: T) { 2692 | items.append(item) 2693 | } 2694 | mutating func pop() -> T { 2695 | return items.removeLast() 2696 | } 2697 | mutating func count() -> Int { 2698 | return items.count 2699 | } 2700 | mutating func show() { 2701 | println(items) 2702 | } 2703 | } 2704 | ~~~ 2705 | 2706 |
2707 |
2708 | 2709 | ## ✓ DoubleStack 2710 | - 두 개의 Stack을 사용해 큐와 같은 기능을 수행한다. 2711 | - 배열을 사용한 큐보다 Enqueue, Dequeue에서의 시간복잡도가 가볍다. 2712 | - **두개의 스택을 사용하여 enQueue, deQueue의 시간복잡도 O(1)** 을 이룰 수 있다. 2713 | - **공간복잡도 O(N)** 2714 | ~~~ swift 2715 | // MARK: - DoubleStack, 더블스택 2716 | 2717 | // MARK: 두개의 스택을 사용하여 enQueue, deQueue의 시간복잡도 O(1)을 이룰 수 있다. 2718 | 2719 | // ✓ 확인해야 할 사항 : deQueue(pop) 실행 간 rightStack을 reversed() 실행할 경우 시간복잡도는 O(N)이 되는 것 아닌가?? 2720 | 2721 | import Foundation 2722 | 2723 | public struct QueueDoubleStack: Queue { 2724 | // Enqueue 역할을 할 좌측 스택 2725 | private var leftStack = [T]() 2726 | 2727 | // Dequeue 역할을 할 우측 스택 2728 | private var rightStack = [T]() 2729 | 2730 | public init() {} 2731 | 2732 | public mutating func push(_ element: T) -> Bool { 2733 | rightStack.append(element) 2734 | return true 2735 | } 2736 | 2737 | // 시간복잡도 최선 O(1) ~ 최악 O(N) 2738 | public mutating func pop() -> T? { 2739 | if leftStack.isEmpty { 2740 | // 배열의 reversed() 복잡도는 N이다. 2741 | leftStack = rightStack.reversed() 2742 | rightStack.removeAll() 2743 | } 2744 | return leftStack.popLast() 2745 | } 2746 | 2747 | public var front: T? { 2748 | return !leftStack.isEmpty ? leftStack.last : rightStack.first 2749 | } 2750 | 2751 | public var back: T? { 2752 | return !rightStack.isEmpty ? rightStack.last : leftStack.first 2753 | } 2754 | 2755 | public var isEmpty: Bool { 2756 | return leftStack.isEmpty && rightStack.isEmpty 2757 | } 2758 | } 2759 | ~~~ 2760 | 2761 |
2762 |
2763 | 2764 | ## ✓ 문자열 2765 | 2766 | ### String 2767 | - Swift의 문자열 타입 2768 | - String 초기화 예시 ▼ 2769 | ~~~ swift 2770 | var str0 = "ABC" 2771 | var str: String = "HELLOWORLD" 2772 | print(str) // -> "HELLOWORLD" 2773 | ~~~ 2774 | 2775 |
2776 | 2777 | ### Character 2778 | - 별칭, String.Element 2779 | - String의 부분적 요소 2780 | 2781 |
2782 | 2783 | ### 문자 아스키코드 값 변환하기 2784 | - unicodeScalars.first!.value 2785 | - 문자열의 특정 문자를 아스키코드값으로 변환 시킨다. 2786 | - 반환타입은 UInt32(Unsigned Integer 32)이다. 2787 | - Unicode.Scalar() -> Unicode.Scalar 2788 | - 반환타입을 문자열로 사용하기 위해서 String, Character형 등으로 타입 변환하여 사용한다. 2789 | - Int 타입 변수를 문자열로 변환 시킨다. 2790 | - unicodeScalars, Unicode.Scalar 사용 예시 ▼ 2791 | 2792 | ~~~ swift 2793 | func sizierCode(_ s: String, _ n: Int) -> String { 2794 | var arr = Array(s) 2795 | 2796 | for i in arr.indices { 2797 | for _ in 0 ..< n { 2798 | if arr[i] == " " { break } 2799 | // ✓ arr[i] 문자를 unicodeScalars.first!.value를 사용해 아스키코드 값으로 변환 시킨다. 2800 | let ascV = Int(arr[i].unicodeScalars.first!.value) 2801 | if ascV == 122 { arr[i] = "a"; continue } 2802 | if ascV == 90 { arr[i] = "A"; continue } 2803 | // ✓ arr[i] 문자를 Unicode.Scalar()를 사용해 아스키코드 값으로 변환 시킨다. 2804 | arr[i] = Character(Unicode.Scalar(ascV + 1)!) 2805 | } 2806 | } 2807 | return arr.map { String($0) }.joined() 2808 | } 2809 | ~~~ 2810 | 2811 |
2812 |
2813 | 2814 | ## ✓ 반복문 2815 | 2816 |
2817 | 2818 | ### for <인덱스변수> in <범위, 컬렉션..> {} 2819 | - 지정 영역을 순회하여 반복실행한다. 2820 | - for문 사용 예시 ▼ 2821 | ~~~ swift 2822 | if i+1 >= h.count { continue } 2823 | for j in i+1 ..< h.count { 2824 | if h[i] > h[j] { break } 2825 | index += 1 2826 | Ans = max(Ans, index * h[i]) 2827 | } 2828 | ~~~ 2829 |
2830 | 2831 | ### stride(from:,through/to:,by:) 2832 | - *Float 등의 부동소수점을 반복문으로 돌릴 수 없을까?* 2833 | - Swift에서는 stride 전역함수를 이용하여 구현할 수 있다. 2834 | - 부동소수점 이외에 문자열의 인수 등도 셀 수 있다. 2835 | - stride 사용 예시 ▼ 2836 | 2837 | ~~~ swift 2838 | // for i stride 사용 예시) 2839 | // for (i = 0.5; i<=15.25; i+=0.3) 과 같은 동작의 stride 사용 예 2840 | for i in stride(from: 0.5, through: 15.25, by: 0.3) { 2841 | 2842 | } 2843 | ~~~ 2844 | 2845 |
2846 | 2847 | ~~~ swift 2848 | // 반복문 내의 i-1 ~ 0까지 내려가면서 순회한다. 실행마다 -1씩 감소한다. 2849 | // from, to, by를 통해 증가하며 순회하는 실행도 가능 2850 | Ans = max(Ans, index * h[i]) 2851 | for j in stride(from: i-1, through: 0, by: -1) { 2852 | if h[i] > h[j] { break } 2853 | index += 1 2854 | Ans = max(Ans, index * h[i]) 2855 | } 2856 | ~~~ 2857 | 2858 |
2859 |
2860 | 2861 | ## ✓ String 문자열 기능 메서드 2862 | ### components(saparatedBy:) -> Array 2863 | - 문자열을 특정 separator 기준으로 잘라서 배열로 만들어준다. 2864 | ~~~ swift 2865 | public func sad(_ S : String) -> Int { 2866 | Components를 사용하여 "?", "!", "."간격으로 분리, 배열화 한다. 2867 | let arr = S.components(separatedBy: ["?","!","."]) 2868 | } 2869 | ~~~ 2870 | ~~~ swift 2871 | /// components + 고차함수 응용 예시) 2872 | func getMinMax(_ s: String) -> String { 2873 | // 1) 입력한 문자열의 공백을 기준으로 잘라 배열로 만든다. 2874 | // 2) map을 이용해 배열 요소를 각각 Int 형으로 강제 변환 2875 | // 3) 변환한 Int형 요소들을 sorted()를 이용해 오름차순 정렬한다. 2876 | let Ans = s.components(separatedBy: " ").map { Int($0)! }.sorted() 2877 | return "\(Ans[0]) \(Ans[Ans.count-1])" 2878 | } 2879 | ~~~ 2880 | 2881 |
2882 | 2883 | ### index(, offsetBy:) 2884 | - 문자열 인덱스 접근에 사용한다. 2885 | ~~~ swift 2886 | // index(, offsetBy:) 사용 예시 2887 | for i in 0.. 2895 | 2896 | ### unicodeScalars (+ Unicode.Scalar) 2897 | - 문자열 요소인 문자(Character)의 아스키 값을 얻어오고 처리하는데 사용할 수 있다. 2898 | ~~~ swift 2899 | // unicodeScalars, Unicode.Scalar 사용 예시 2900 | let index = Int(a[idx].unicodeScalars.first!.value - Unicode.Scalar("a").value) 2901 | ~~~ 2902 | 2903 |
2904 |
2905 | 2906 | ## ✓ 콘솔 출력 메서드 2907 | ### print(“”, separator:, terminator:) 2908 | - 인자 옵션 기능 2909 | - separator: String 2910 | - 문자 출력 사이의 구분자 옵션 2911 | ~~~ swift 2912 | print(“my”, “name”, “is”, “applebuddy”, separator: “ / ”) 2913 | //=> “my / name / is / applebuddy ” 2914 | ~~~ 2915 | 2916 | - terminator: String, default = newline() // terminator 미정 시, 한줄 개행이 기본설정 상태 2917 | - 문자 출력 후 처리 옵션 2918 | - 기본적으로 terminator 값을 설정하지 않으면 문자 출력 후 개행 처리된다. 2919 | 2920 | ~~~ swift 2921 | // 개행 없이 출력 하기 위해선 terminator의 값을 "" 처리 해주면 된다. 2922 | print(“바보”, terminator: “”) 2923 | // => 한줄 개행 없이 “바보” 출력) 2924 | ~~~ 2925 | 2926 |
2927 |
2928 | 2929 | ## ✓ 유용한 클로져 함수(고차함수) 2930 | 2931 |
2932 | 2933 | ### filter() 2934 | - 특정 조건을 충족하는 요소만 필터링하여 배열에 저장한다. 2935 | ~~~ swift 2936 | let A: [Int] = [-1,1,-1,2] 2937 | let sorted = A.filter { $0 > 0 } // [1,2] 2938 | ~~~ 2939 | 2940 |
2941 | 2942 | ### sort() `mutating` 2943 | - 정렬 메서드 2944 | - 해당 배열의 값 자체를 변경한다. 2945 | 2946 |
2947 | 2948 | ### sorted(), sorted(by: ) 2949 | - 정렬 메서드 2950 | - 두개의 인자값을 통해 비교함수를 재정의할 수도 있음. 2951 | - sorted(by: )는 인자값을 >, < 으로 받아 내림차순 or 오름차순 정렬을 실행한다. 2952 | - sorted() 사용 예시 ▼ 2953 | ~~~ swift 2954 | ans.sorted { (c1, c2) -> Bool in 2955 | // 재정의 부분, true를 리턴 시 두개의 값이 서로 스왑된다. 2956 | } 2957 | 2958 | var sorted = contests.sorted { (v1, v2) in 2959 | return v1[0] > v2[0] 2960 | // `return` 없이 v1[0] > v2[0] 만 명시해도 문제없음. 2961 | } 2962 | ~~~ 2963 | 2964 |
2965 | 2966 | - sorted(by:) 사용 예시 ▼ 2967 | ~~~ swift 2968 | // sorted(by: ) 사용 예시 2969 | // 위와 동일한 내림차순 결과를 보여준다. 2970 | sorted = con.sorted(by: >) 2971 | 2972 | // 오름차순 결과를 보여준다. 2973 | sorted = con2.sorted(by: <) 2974 | ~~~ 2975 | 2976 |
2977 |
2978 | 2979 | ### reduce() 2980 | - 1개의 초기값 인자, 2개의 클로저 인자 2981 | - 초기값 인자를 기준으로 요소를 하나의 결과값으로 합쳐 하나의 최종 값을 도출한다. 2982 | 2983 | ~~~ swift 2984 | // reduce() 사용 예시 2985 | arr.reduce(0) { $0 + $1 } 2986 | arr2.reduce(0,+) 2987 | ~~~ 2988 | 2989 |
2990 | 2991 | ### map() 2992 | - 1개의 클로저 인자, 각각의 요소 인자마다 특정 코드 적용을 시킨다. 2993 | - **삽입속도는 느리나, 탐색속도가 빠른 자료구조** 2994 | 2995 | ~~~ swift 2996 | // map() 사용예시 2997 | // * map, $ 인자값을 사용하여 간결하게 구현할 수 있다. 2998 | // + sorted() 등 클로저 내 또다른 고차함수의 사용도 가능 2999 | func solution2(_ array: [Int], _ commands: [[Int]]) -> [Int] { 3000 | return commands.map { 3001 | Array(array[($0[0] - 1) ... ($0[1] - 1)]).sorted()[$0[2] - 1] 3002 | } 3003 | } 3004 | ~~~ 3005 | 3006 |
3007 |
3008 | 3009 | 3010 | -------------------------------------------------------------------------------- /Structures/.DS_Store: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/applebuddy/AlgorithmMemo/6ffe9a92468d1b14a71e6f78e695ec6af96f531b/Structures/.DS_Store -------------------------------------------------------------------------------- /Structures/Structures.xcodeproj/project.pbxproj: -------------------------------------------------------------------------------- 1 | // !$*UTF8*$! 2 | { 3 | archiveVersion = 1; 4 | classes = { 5 | }; 6 | objectVersion = 50; 7 | objects = { 8 | 9 | /* Begin PBXBuildFile section */ 10 | 074980D723D8D8520005A4B3 /* Heap.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 074980D623D8D8520005A4B3 /* Heap.cpp */; }; 11 | 0775B93823E9B1910050EF75 /* LinkedList2.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0775B93723E9B1910050EF75 /* LinkedList2.swift */; }; 12 | 0775B93A23E9B6560050EF75 /* LinkedList3.swift in Sources */ = {isa = PBXBuildFile; fileRef = 0775B93923E9B6560050EF75 /* LinkedList3.swift */; }; 13 | 0784705923E7027E007F2EA6 /* BinaryTree.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 0784705823E7027E007F2EA6 /* BinaryTree.cpp */; }; 14 | 07A672CC23E83219006AE0C7 /* LinkedList.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07A672CB23E83219006AE0C7 /* LinkedList.swift */; }; 15 | 07A672D123E8371D006AE0C7 /* BinaryTree.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07A672D023E8371D006AE0C7 /* BinaryTree.swift */; }; 16 | 07C8C606232F6229005DBA4A /* mainc.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07C8C605232F6229005DBA4A /* mainc.swift */; }; 17 | 07C8C60D232F623A005DBA4A /* DoubleStack.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07C8C60C232F623A005DBA4A /* DoubleStack.swift */; }; 18 | 07C8C60F232F6360005DBA4A /* Queue.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07C8C60E232F6360005DBA4A /* Queue.swift */; }; 19 | 07C8C611232F6881005DBA4A /* QueueArray.swift in Sources */ = {isa = PBXBuildFile; fileRef = 07C8C610232F6881005DBA4A /* QueueArray.swift */; }; 20 | /* End PBXBuildFile section */ 21 | 22 | /* Begin PBXCopyFilesBuildPhase section */ 23 | 07C8C600232F6229005DBA4A /* CopyFiles */ = { 24 | isa = PBXCopyFilesBuildPhase; 25 | buildActionMask = 2147483647; 26 | dstPath = /usr/share/man/man1/; 27 | dstSubfolderSpec = 0; 28 | files = ( 29 | ); 30 | runOnlyForDeploymentPostprocessing = 1; 31 | }; 32 | /* End PBXCopyFilesBuildPhase section */ 33 | 34 | /* Begin PBXFileReference section */ 35 | 074980D523D8D8520005A4B3 /* Structures-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Structures-Bridging-Header.h"; sourceTree = ""; }; 36 | 074980D623D8D8520005A4B3 /* Heap.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = Heap.cpp; sourceTree = ""; }; 37 | 0775B93723E9B1910050EF75 /* LinkedList2.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LinkedList2.swift; sourceTree = ""; }; 38 | 0775B93923E9B6560050EF75 /* LinkedList3.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LinkedList3.swift; sourceTree = ""; }; 39 | 0784705823E7027E007F2EA6 /* BinaryTree.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = BinaryTree.cpp; sourceTree = ""; }; 40 | 07A672CB23E83219006AE0C7 /* LinkedList.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = LinkedList.swift; sourceTree = ""; }; 41 | 07A672D023E8371D006AE0C7 /* BinaryTree.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = BinaryTree.swift; sourceTree = ""; }; 42 | 07C8C602232F6229005DBA4A /* Structures */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = Structures; sourceTree = BUILT_PRODUCTS_DIR; }; 43 | 07C8C605232F6229005DBA4A /* mainc.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = mainc.swift; sourceTree = ""; }; 44 | 07C8C60C232F623A005DBA4A /* DoubleStack.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = DoubleStack.swift; sourceTree = ""; }; 45 | 07C8C60E232F6360005DBA4A /* Queue.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = Queue.swift; sourceTree = ""; }; 46 | 07C8C610232F6881005DBA4A /* QueueArray.swift */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.swift; path = QueueArray.swift; sourceTree = ""; }; 47 | /* End PBXFileReference section */ 48 | 49 | /* Begin PBXFrameworksBuildPhase section */ 50 | 07C8C5FF232F6229005DBA4A /* Frameworks */ = { 51 | isa = PBXFrameworksBuildPhase; 52 | buildActionMask = 2147483647; 53 | files = ( 54 | ); 55 | runOnlyForDeploymentPostprocessing = 0; 56 | }; 57 | /* End PBXFrameworksBuildPhase section */ 58 | 59 | /* Begin PBXGroup section */ 60 | 07A672CD23E8368C006AE0C7 /* Stack */ = { 61 | isa = PBXGroup; 62 | children = ( 63 | 07C8C60C232F623A005DBA4A /* DoubleStack.swift */, 64 | ); 65 | path = Stack; 66 | sourceTree = ""; 67 | }; 68 | 07A672CE23E836A1006AE0C7 /* Heap */ = { 69 | isa = PBXGroup; 70 | children = ( 71 | 074980D623D8D8520005A4B3 /* Heap.cpp */, 72 | ); 73 | path = Heap; 74 | sourceTree = ""; 75 | }; 76 | 07A672CF23E836AC006AE0C7 /* Tree */ = { 77 | isa = PBXGroup; 78 | children = ( 79 | 0784705823E7027E007F2EA6 /* BinaryTree.cpp */, 80 | 07A672D023E8371D006AE0C7 /* BinaryTree.swift */, 81 | ); 82 | path = Tree; 83 | sourceTree = ""; 84 | }; 85 | 07C8C5F9232F6229005DBA4A = { 86 | isa = PBXGroup; 87 | children = ( 88 | 07C8C604232F6229005DBA4A /* Structures */, 89 | 07C8C603232F6229005DBA4A /* Products */, 90 | ); 91 | sourceTree = ""; 92 | }; 93 | 07C8C603232F6229005DBA4A /* Products */ = { 94 | isa = PBXGroup; 95 | children = ( 96 | 07C8C602232F6229005DBA4A /* Structures */, 97 | ); 98 | name = Products; 99 | sourceTree = ""; 100 | }; 101 | 07C8C604232F6229005DBA4A /* Structures */ = { 102 | isa = PBXGroup; 103 | children = ( 104 | 07C8C605232F6229005DBA4A /* mainc.swift */, 105 | 07A672CB23E83219006AE0C7 /* LinkedList.swift */, 106 | 0775B93723E9B1910050EF75 /* LinkedList2.swift */, 107 | 0775B93923E9B6560050EF75 /* LinkedList3.swift */, 108 | 07A672CF23E836AC006AE0C7 /* Tree */, 109 | 07A672CE23E836A1006AE0C7 /* Heap */, 110 | 07A672CD23E8368C006AE0C7 /* Stack */, 111 | 07C8C612232F7228005DBA4A /* Queue */, 112 | 074980D523D8D8520005A4B3 /* Structures-Bridging-Header.h */, 113 | ); 114 | path = Structures; 115 | sourceTree = ""; 116 | }; 117 | 07C8C612232F7228005DBA4A /* Queue */ = { 118 | isa = PBXGroup; 119 | children = ( 120 | 07C8C60E232F6360005DBA4A /* Queue.swift */, 121 | 07C8C610232F6881005DBA4A /* QueueArray.swift */, 122 | ); 123 | path = Queue; 124 | sourceTree = ""; 125 | }; 126 | /* End PBXGroup section */ 127 | 128 | /* Begin PBXNativeTarget section */ 129 | 07C8C601232F6229005DBA4A /* Structures */ = { 130 | isa = PBXNativeTarget; 131 | buildConfigurationList = 07C8C609232F6229005DBA4A /* Build configuration list for PBXNativeTarget "Structures" */; 132 | buildPhases = ( 133 | 07C8C5FE232F6229005DBA4A /* Sources */, 134 | 07C8C5FF232F6229005DBA4A /* Frameworks */, 135 | 07C8C600232F6229005DBA4A /* CopyFiles */, 136 | ); 137 | buildRules = ( 138 | ); 139 | dependencies = ( 140 | ); 141 | name = Structures; 142 | productName = Structures; 143 | productReference = 07C8C602232F6229005DBA4A /* Structures */; 144 | productType = "com.apple.product-type.tool"; 145 | }; 146 | /* End PBXNativeTarget section */ 147 | 148 | /* Begin PBXProject section */ 149 | 07C8C5FA232F6229005DBA4A /* Project object */ = { 150 | isa = PBXProject; 151 | attributes = { 152 | LastSwiftUpdateCheck = 1030; 153 | LastUpgradeCheck = 1030; 154 | ORGANIZATIONNAME = MinKyeongTae; 155 | TargetAttributes = { 156 | 07C8C601232F6229005DBA4A = { 157 | CreatedOnToolsVersion = 10.3; 158 | LastSwiftMigration = 1130; 159 | }; 160 | }; 161 | }; 162 | buildConfigurationList = 07C8C5FD232F6229005DBA4A /* Build configuration list for PBXProject "Structures" */; 163 | compatibilityVersion = "Xcode 9.3"; 164 | developmentRegion = en; 165 | hasScannedForEncodings = 0; 166 | knownRegions = ( 167 | en, 168 | ); 169 | mainGroup = 07C8C5F9232F6229005DBA4A; 170 | productRefGroup = 07C8C603232F6229005DBA4A /* Products */; 171 | projectDirPath = ""; 172 | projectRoot = ""; 173 | targets = ( 174 | 07C8C601232F6229005DBA4A /* Structures */, 175 | ); 176 | }; 177 | /* End PBXProject section */ 178 | 179 | /* Begin PBXSourcesBuildPhase section */ 180 | 07C8C5FE232F6229005DBA4A /* Sources */ = { 181 | isa = PBXSourcesBuildPhase; 182 | buildActionMask = 2147483647; 183 | files = ( 184 | 0775B93A23E9B6560050EF75 /* LinkedList3.swift in Sources */, 185 | 07A672D123E8371D006AE0C7 /* BinaryTree.swift in Sources */, 186 | 07C8C606232F6229005DBA4A /* mainc.swift in Sources */, 187 | 07C8C60F232F6360005DBA4A /* Queue.swift in Sources */, 188 | 0784705923E7027E007F2EA6 /* BinaryTree.cpp in Sources */, 189 | 07C8C60D232F623A005DBA4A /* DoubleStack.swift in Sources */, 190 | 0775B93823E9B1910050EF75 /* LinkedList2.swift in Sources */, 191 | 07C8C611232F6881005DBA4A /* QueueArray.swift in Sources */, 192 | 074980D723D8D8520005A4B3 /* Heap.cpp in Sources */, 193 | 07A672CC23E83219006AE0C7 /* LinkedList.swift in Sources */, 194 | ); 195 | runOnlyForDeploymentPostprocessing = 0; 196 | }; 197 | /* End PBXSourcesBuildPhase section */ 198 | 199 | /* Begin XCBuildConfiguration section */ 200 | 07C8C607232F6229005DBA4A /* Debug */ = { 201 | isa = XCBuildConfiguration; 202 | buildSettings = { 203 | ALWAYS_SEARCH_USER_PATHS = NO; 204 | CLANG_ANALYZER_NONNULL = YES; 205 | CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; 206 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; 207 | CLANG_CXX_LIBRARY = "libc++"; 208 | CLANG_ENABLE_MODULES = YES; 209 | CLANG_ENABLE_OBJC_ARC = YES; 210 | CLANG_ENABLE_OBJC_WEAK = YES; 211 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; 212 | CLANG_WARN_BOOL_CONVERSION = YES; 213 | CLANG_WARN_COMMA = YES; 214 | CLANG_WARN_CONSTANT_CONVERSION = YES; 215 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; 216 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 217 | CLANG_WARN_DOCUMENTATION_COMMENTS = YES; 218 | CLANG_WARN_EMPTY_BODY = YES; 219 | CLANG_WARN_ENUM_CONVERSION = YES; 220 | CLANG_WARN_INFINITE_RECURSION = YES; 221 | CLANG_WARN_INT_CONVERSION = YES; 222 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; 223 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; 224 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; 225 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 226 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; 227 | CLANG_WARN_STRICT_PROTOTYPES = YES; 228 | CLANG_WARN_SUSPICIOUS_MOVE = YES; 229 | CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; 230 | CLANG_WARN_UNREACHABLE_CODE = YES; 231 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 232 | CODE_SIGN_IDENTITY = "Mac Developer"; 233 | COPY_PHASE_STRIP = NO; 234 | DEBUG_INFORMATION_FORMAT = dwarf; 235 | ENABLE_STRICT_OBJC_MSGSEND = YES; 236 | ENABLE_TESTABILITY = YES; 237 | GCC_C_LANGUAGE_STANDARD = gnu11; 238 | GCC_DYNAMIC_NO_PIC = NO; 239 | GCC_NO_COMMON_BLOCKS = YES; 240 | GCC_OPTIMIZATION_LEVEL = 0; 241 | GCC_PREPROCESSOR_DEFINITIONS = ( 242 | "DEBUG=1", 243 | "$(inherited)", 244 | ); 245 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 246 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 247 | GCC_WARN_UNDECLARED_SELECTOR = YES; 248 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 249 | GCC_WARN_UNUSED_FUNCTION = YES; 250 | GCC_WARN_UNUSED_VARIABLE = YES; 251 | MACOSX_DEPLOYMENT_TARGET = 10.14; 252 | MTL_ENABLE_DEBUG_INFO = INCLUDE_SOURCE; 253 | MTL_FAST_MATH = YES; 254 | ONLY_ACTIVE_ARCH = YES; 255 | SDKROOT = macosx; 256 | SWIFT_ACTIVE_COMPILATION_CONDITIONS = DEBUG; 257 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 258 | }; 259 | name = Debug; 260 | }; 261 | 07C8C608232F6229005DBA4A /* Release */ = { 262 | isa = XCBuildConfiguration; 263 | buildSettings = { 264 | ALWAYS_SEARCH_USER_PATHS = NO; 265 | CLANG_ANALYZER_NONNULL = YES; 266 | CLANG_ANALYZER_NUMBER_OBJECT_CONVERSION = YES_AGGRESSIVE; 267 | CLANG_CXX_LANGUAGE_STANDARD = "gnu++14"; 268 | CLANG_CXX_LIBRARY = "libc++"; 269 | CLANG_ENABLE_MODULES = YES; 270 | CLANG_ENABLE_OBJC_ARC = YES; 271 | CLANG_ENABLE_OBJC_WEAK = YES; 272 | CLANG_WARN_BLOCK_CAPTURE_AUTORELEASING = YES; 273 | CLANG_WARN_BOOL_CONVERSION = YES; 274 | CLANG_WARN_COMMA = YES; 275 | CLANG_WARN_CONSTANT_CONVERSION = YES; 276 | CLANG_WARN_DEPRECATED_OBJC_IMPLEMENTATIONS = YES; 277 | CLANG_WARN_DIRECT_OBJC_ISA_USAGE = YES_ERROR; 278 | CLANG_WARN_DOCUMENTATION_COMMENTS = YES; 279 | CLANG_WARN_EMPTY_BODY = YES; 280 | CLANG_WARN_ENUM_CONVERSION = YES; 281 | CLANG_WARN_INFINITE_RECURSION = YES; 282 | CLANG_WARN_INT_CONVERSION = YES; 283 | CLANG_WARN_NON_LITERAL_NULL_CONVERSION = YES; 284 | CLANG_WARN_OBJC_IMPLICIT_RETAIN_SELF = YES; 285 | CLANG_WARN_OBJC_LITERAL_CONVERSION = YES; 286 | CLANG_WARN_OBJC_ROOT_CLASS = YES_ERROR; 287 | CLANG_WARN_RANGE_LOOP_ANALYSIS = YES; 288 | CLANG_WARN_STRICT_PROTOTYPES = YES; 289 | CLANG_WARN_SUSPICIOUS_MOVE = YES; 290 | CLANG_WARN_UNGUARDED_AVAILABILITY = YES_AGGRESSIVE; 291 | CLANG_WARN_UNREACHABLE_CODE = YES; 292 | CLANG_WARN__DUPLICATE_METHOD_MATCH = YES; 293 | CODE_SIGN_IDENTITY = "Mac Developer"; 294 | COPY_PHASE_STRIP = NO; 295 | DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym"; 296 | ENABLE_NS_ASSERTIONS = NO; 297 | ENABLE_STRICT_OBJC_MSGSEND = YES; 298 | GCC_C_LANGUAGE_STANDARD = gnu11; 299 | GCC_NO_COMMON_BLOCKS = YES; 300 | GCC_WARN_64_TO_32_BIT_CONVERSION = YES; 301 | GCC_WARN_ABOUT_RETURN_TYPE = YES_ERROR; 302 | GCC_WARN_UNDECLARED_SELECTOR = YES; 303 | GCC_WARN_UNINITIALIZED_AUTOS = YES_AGGRESSIVE; 304 | GCC_WARN_UNUSED_FUNCTION = YES; 305 | GCC_WARN_UNUSED_VARIABLE = YES; 306 | MACOSX_DEPLOYMENT_TARGET = 10.14; 307 | MTL_ENABLE_DEBUG_INFO = NO; 308 | MTL_FAST_MATH = YES; 309 | SDKROOT = macosx; 310 | SWIFT_COMPILATION_MODE = wholemodule; 311 | SWIFT_OPTIMIZATION_LEVEL = "-O"; 312 | }; 313 | name = Release; 314 | }; 315 | 07C8C60A232F6229005DBA4A /* Debug */ = { 316 | isa = XCBuildConfiguration; 317 | buildSettings = { 318 | CLANG_ENABLE_MODULES = YES; 319 | CODE_SIGN_STYLE = Automatic; 320 | DEVELOPMENT_TEAM = NF9G85TZ2T; 321 | LD_RUNPATH_SEARCH_PATHS = ( 322 | "$(inherited)", 323 | "@executable_path/../Frameworks", 324 | "@loader_path/../Frameworks", 325 | ); 326 | PRODUCT_NAME = "$(TARGET_NAME)"; 327 | SWIFT_OBJC_BRIDGING_HEADER = "Structures/Structures-Bridging-Header.h"; 328 | SWIFT_OPTIMIZATION_LEVEL = "-Onone"; 329 | SWIFT_VERSION = 5.0; 330 | }; 331 | name = Debug; 332 | }; 333 | 07C8C60B232F6229005DBA4A /* Release */ = { 334 | isa = XCBuildConfiguration; 335 | buildSettings = { 336 | CLANG_ENABLE_MODULES = YES; 337 | CODE_SIGN_STYLE = Automatic; 338 | DEVELOPMENT_TEAM = NF9G85TZ2T; 339 | LD_RUNPATH_SEARCH_PATHS = ( 340 | "$(inherited)", 341 | "@executable_path/../Frameworks", 342 | "@loader_path/../Frameworks", 343 | ); 344 | PRODUCT_NAME = "$(TARGET_NAME)"; 345 | SWIFT_OBJC_BRIDGING_HEADER = "Structures/Structures-Bridging-Header.h"; 346 | SWIFT_VERSION = 5.0; 347 | }; 348 | name = Release; 349 | }; 350 | /* End XCBuildConfiguration section */ 351 | 352 | /* Begin XCConfigurationList section */ 353 | 07C8C5FD232F6229005DBA4A /* Build configuration list for PBXProject "Structures" */ = { 354 | isa = XCConfigurationList; 355 | buildConfigurations = ( 356 | 07C8C607232F6229005DBA4A /* Debug */, 357 | 07C8C608232F6229005DBA4A /* Release */, 358 | ); 359 | defaultConfigurationIsVisible = 0; 360 | defaultConfigurationName = Release; 361 | }; 362 | 07C8C609232F6229005DBA4A /* Build configuration list for PBXNativeTarget "Structures" */ = { 363 | isa = XCConfigurationList; 364 | buildConfigurations = ( 365 | 07C8C60A232F6229005DBA4A /* Debug */, 366 | 07C8C60B232F6229005DBA4A /* Release */, 367 | ); 368 | defaultConfigurationIsVisible = 0; 369 | defaultConfigurationName = Release; 370 | }; 371 | /* End XCConfigurationList section */ 372 | }; 373 | rootObject = 07C8C5FA232F6229005DBA4A /* Project object */; 374 | } 375 | -------------------------------------------------------------------------------- /Structures/Structures.xcodeproj/project.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /Structures/Structures.xcodeproj/project.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | IDEDidComputeMac32BitWarning 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /Structures/Structures.xcodeproj/project.xcworkspace/xcuserdata/applebuddy.xcuserdatad/UserInterfaceState.xcuserstate: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/applebuddy/AlgorithmMemo/6ffe9a92468d1b14a71e6f78e695ec6af96f531b/Structures/Structures.xcodeproj/project.xcworkspace/xcuserdata/applebuddy.xcuserdatad/UserInterfaceState.xcuserstate -------------------------------------------------------------------------------- /Structures/Structures.xcodeproj/xcuserdata/applebuddy.xcuserdatad/xcdebugger/Breakpoints_v2.xcbkptlist: -------------------------------------------------------------------------------- 1 | 2 | 6 | 7 | -------------------------------------------------------------------------------- /Structures/Structures.xcodeproj/xcuserdata/applebuddy.xcuserdatad/xcschemes/xcschememanagement.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | SchemeUserState 6 | 7 | Structures.xcscheme_^#shared#^_ 8 | 9 | orderHint 10 | 0 11 | 12 | 13 | 14 | 15 | -------------------------------------------------------------------------------- /Structures/Structures/Heap/Heap.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // Heap.cpp 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 2020/01/23. 6 | // Copyright © 2020 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: Heap 10 | #if 0 11 | #include 12 | #include 13 | using namespace std; 14 | 15 | int main() { 16 | 17 | vector heap = {8, 7, 5, 6, 3, 5, 9, 1, 6}; 18 | for(int i=1; i=0; i--) { 37 | int temp = heap[0]; 38 | heap[0] = heap[i]; 39 | heap[i] = temp; 40 | int root = 0; 41 | int c = 1; 42 | do { 43 | c = 2 * root + 1; 44 | // 자식 중에 더 큰 값을 찾기 45 | if(heap[c] < heap[c+1] && c < i-1) { 46 | c++; 47 | } 48 | // 루트보다 자식이 더 크다면 서로 교환 49 | if(heap[root] < heap[c] && c < i) { 50 | int temp = heap[root]; 51 | heap[root] = heap[c]; 52 | heap[c] = temp; 53 | } else break; 54 | root = c; 55 | }while(c { 18 | var value: Int 19 | var next: LLNode? 20 | 21 | init(_ value: Int, _ next: LLNode? = nil) { 22 | self.value = value 23 | self.next = next 24 | } 25 | } 26 | 27 | extension LLNode: CustomStringConvertible { 28 | var description: String { 29 | guard let next = self.next else { 30 | return "\(self.value)" 31 | } 32 | 33 | return "\(self.value) -> \(next.description)" 34 | } 35 | } 36 | 37 | var node5 = LLNode(5) 38 | var node4 = LLNode(4, node5) 39 | var node3 = LLNode(3, node4) 40 | var node2 = LLNode(2, node3) 41 | var node1 = LLNode(1, node2) 42 | 43 | print(node1.description) 44 | */ 45 | 46 | // MARK: - 기본 연결리스트 구조 구현 47 | 48 | /* 49 | import Foundation 50 | 51 | class Node { 52 | var value: Int 53 | var next: Node? 54 | init(_ value: Int, _ next: Node? = nil) { 55 | self.value = value 56 | self.next = next 57 | } 58 | } 59 | 60 | extension Node: CustomStringConvertible { 61 | var description: String { 62 | guard let next = self.next else { 63 | return "\(value)" 64 | } 65 | 66 | return "\(value) -> \(next.description) " 67 | } 68 | } 69 | 70 | var node = Node(1) 71 | var node2 = Node(2) 72 | var node3 = Node(3) 73 | node.next = node2 74 | node2.next = node3 75 | print(node.description) 76 | */ 77 | -------------------------------------------------------------------------------- /Structures/Structures/LinkedList2.swift: -------------------------------------------------------------------------------- 1 | // 2 | // LinkedList2.swift 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 2020/02/04. 6 | // Copyright © 2020 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: SinglyLinkedList with Insertion, print 10 | 11 | /* 12 | import Foundation 13 | 14 | class Node { 15 | var value: Int 16 | var next: Node? 17 | init(_ value: Int, _ next: Node? = nil) { 18 | self.value = value 19 | self.next = next 20 | } 21 | } 22 | 23 | final class SinglyLinkedList { 24 | var head: Node? 25 | var tail: Node? 26 | 27 | init() {} 28 | 29 | func insertNode(_ nodeData: Int) { 30 | let node = Node(nodeData) 31 | if let tail = self.tail { 32 | tail.next = node 33 | } else { 34 | head = node 35 | } 36 | self.tail = node 37 | } 38 | 39 | func insertNodeAt(_ pos: Int, _ nodeData: Int) { 40 | let nodeToInsert = Node(nodeData) 41 | var pos = pos 42 | var head = self.head 43 | 44 | if pos == 0 { 45 | nodeToInsert.next = head 46 | self.head = nodeToInsert 47 | return 48 | } 49 | else if head == nil { 50 | head = nodeToInsert 51 | tail = nodeToInsert 52 | return 53 | } 54 | 55 | while pos-1 > 0, head?.next != nil { 56 | head = head?.next 57 | pos -= 1 58 | } 59 | 60 | let originNode = head?.next 61 | head?.next = nodeToInsert 62 | head = head?.next 63 | head?.next = originNode 64 | } 65 | 66 | func printNode() { 67 | var cur = head 68 | while cur != nil { 69 | print("\(cur!.value)", terminator: " ") 70 | cur = cur!.next 71 | } 72 | print() 73 | } 74 | } 75 | 76 | extension Node: CustomStringConvertible { 77 | var description: String { 78 | guard let next = self.next else { 79 | return "\(self.value)" 80 | } 81 | 82 | return "\(self.value) -> \(next.description)" 83 | } 84 | } 85 | 86 | let llist = SinglyLinkedList() 87 | llist.insertNode(1) 88 | llist.insertNode(3) 89 | llist.insertNode(5) 90 | llist.printNode() 91 | llist.insertNodeAt(0,10) 92 | llist.printNode() 93 | 94 | */ 95 | -------------------------------------------------------------------------------- /Structures/Structures/LinkedList3.swift: -------------------------------------------------------------------------------- 1 | // 2 | // LinkedList3.swift 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 2020/02/04. 6 | // Copyright © 2020 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: SinglyLinkedList with Generic and Insertion/Deletion/Print 10 | 11 | /* 12 | import Foundation 13 | 14 | class Node { 15 | var value: T 16 | var next: Node? 17 | init(_ value: T, _ next: Node? = nil) { 18 | self.value = value 19 | self.next = next 20 | } 21 | } 22 | 23 | final class SinglyLinkedList { 24 | var head: Node? 25 | var tail: Node? 26 | 27 | init() {} 28 | 29 | func insertNode(_ nodeData: T) { 30 | let node = Node(nodeData) 31 | if let tail = self.tail { 32 | tail.next = node 33 | } else { 34 | head = node 35 | } 36 | tail = node 37 | } 38 | 39 | func deleteNodeAt(_ pos: Int) { 40 | var pos = pos 41 | var head = self.head 42 | if pos == 0 { 43 | self.head = head?.next 44 | return 45 | } 46 | 47 | while pos - 1 > 0, head?.next != nil { 48 | head = head?.next 49 | pos -= 1 50 | } 51 | 52 | head?.next = head?.next?.next 53 | } 54 | 55 | func insertNodeAt(_ pos: Int, _ nodeData: T) { 56 | let nodeToInsert = Node(nodeData) 57 | var pos = pos 58 | var head = self.head 59 | 60 | if pos == 0 { 61 | nodeToInsert.next = head 62 | self.head = nodeToInsert 63 | return 64 | } else if head == nil { 65 | head = nodeToInsert 66 | tail = nodeToInsert 67 | return 68 | } 69 | 70 | while pos - 1 > 0, head?.next != nil { 71 | head = head?.next 72 | pos -= 1 73 | } 74 | 75 | let originNode = head?.next 76 | head?.next = nodeToInsert 77 | head = head?.next 78 | head?.next = originNode 79 | } 80 | 81 | func printNode() { 82 | var cur = head 83 | while cur != nil { 84 | print("\(cur!.value)", terminator: " ") 85 | cur = cur!.next 86 | } 87 | print() 88 | } 89 | } 90 | 91 | extension Node: CustomStringConvertible { 92 | var description: String { 93 | guard let next = self.next else { 94 | return "\(value)" 95 | } 96 | 97 | return "\(value) -> \(next.description)" 98 | } 99 | } 100 | 101 | let llist = SinglyLinkedList() 102 | llist.insertNode(1) 103 | llist.insertNode(3) 104 | llist.insertNode(5) 105 | llist.printNode() 106 | llist.insertNodeAt(0, 10) 107 | llist.printNode() 108 | llist.deleteNodeAt(9) 109 | llist.printNode() 110 | 111 | */ 112 | -------------------------------------------------------------------------------- /Structures/Structures/Queue/Queue.swift: -------------------------------------------------------------------------------- 1 | // 2 | // Queue.swift 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 16/09/2019. 6 | // Copyright © 2019 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: - Queue 10 | 11 | // MARK: FIFO방식의 Queue 프로토콜 구현 12 | 13 | // Int, String, Double, Float 어떠한 타입으로 지정하던 Element라는 별칭으로서 사용되어질 수 있다. 14 | // * associatedtype : 프로토콜을 정의할 때, 제네릭타입과 같이 일반화 시킨 타입을 지정할때 사용할 수 있다. 15 | import Foundation 16 | 17 | // MARK: - FIFO방식의 Queue 18 | 19 | public protocol Queue { 20 | // Queue의 데이터타입 별칭을 Element로 지정합니다. 21 | associatedtype Element 22 | 23 | // 큐의 요소를 FIFO방식으로 추가합니다. 24 | mutating func push(_ element: Element) -> Bool 25 | 26 | // 큐의 요소를 FIFO방식으로 제거합니다. 27 | mutating func pop() -> Element? 28 | 29 | // 해당 큐가 비어있는지를 확인합니다. 30 | var isEmpty: Bool { get } 31 | 32 | // 해당 큐의 앞쪽에 요소가 존재하는지 확인합니다. 33 | var front: Element? { get } 34 | 35 | // 해당 큐의 뒷쪽에 요소가 존재하는지 확인합니다. 36 | var back: Element? { get } 37 | } 38 | 39 | // *학습 내용 출처 : https://the-brain-of-sic2.tistory.com/19 40 | -------------------------------------------------------------------------------- /Structures/Structures/Queue/QueueArray.swift: -------------------------------------------------------------------------------- 1 | // 2 | // QueueArray.swift 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 16/09/2019. 6 | // Copyright © 2019 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: - QueueArray 10 | 11 | // MARK: Array를 사용한 Queue 구현 12 | 13 | /// - push 시간 복잡도 : 평소 O(1) 최악 O(N) -> 배열 공간의 요소가 다 찼을때 배열공간 확장으로 O(N)의 복잡도 될 수 있음 14 | /// - pop 시간 복잡도 : O(N) -> 배열 맨 앞의 요소 제거 후 전체 요소를 좌쉬프트 해야하기 때문이다. 15 | 16 | import Foundation 17 | 18 | public struct QueueArray: Queue { 19 | private var elements = [T]() 20 | public mutating func push(_ element: T) -> Bool { 21 | elements.append(element) 22 | return true 23 | } 24 | 25 | public mutating func pop() -> T? { 26 | return elements.removeFirst() 27 | } 28 | 29 | public var isEmpty: Bool { 30 | return elements.isEmpty 31 | } 32 | 33 | public var front: T? { 34 | return elements[0] 35 | } 36 | 37 | public var back: T? { 38 | return elements[elements.count - 1] 39 | } 40 | } 41 | -------------------------------------------------------------------------------- /Structures/Structures/Stack/DoubleStack.swift: -------------------------------------------------------------------------------- 1 | // 2 | // DoubleStack.swift 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 16/09/2019. 6 | // Copyright © 2019 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: - DoubleStack, 더블스택 10 | 11 | // MARK: 두개의 스택을 사용하여 enQueue, deQueue의 시간복잡도 O(1)을 이룰 수 있다. 12 | 13 | // ✓ 확인해야 할 사항 : deQueue(pop) 실행 간 rightStack을 reversed() 실행할 경우 시간복잡도는 O(N)이 되는 것 아닌가?? 14 | 15 | import Foundation 16 | 17 | public struct QueueDoubleStack: Queue { 18 | // Enqueue 역할을 할 좌측 스택 19 | private var leftStack = [T]() 20 | 21 | // Dequeue 역할을 할 우측 스택 22 | private var rightStack = [T]() 23 | 24 | public init() {} 25 | 26 | public mutating func push(_ element: T) -> Bool { 27 | rightStack.append(element) 28 | return true 29 | } 30 | 31 | // 시간복잡도 최선 O(1) ~ 최악 O(N) 32 | public mutating func pop() -> T? { 33 | if leftStack.isEmpty { 34 | // 배열의 reversed() 복잡도는 N이다. 35 | leftStack = rightStack.reversed() 36 | rightStack.removeAll() 37 | } 38 | return leftStack.popLast() 39 | } 40 | 41 | public var front: T? { 42 | return !leftStack.isEmpty ? leftStack.last : rightStack.first 43 | } 44 | 45 | public var back: T? { 46 | return !rightStack.isEmpty ? rightStack.last : leftStack.first 47 | } 48 | 49 | public var isEmpty: Bool { 50 | return leftStack.isEmpty && rightStack.isEmpty 51 | } 52 | } 53 | 54 | // *학습 내용 출처 : https://the-brain-of-sic2.tistory.com/22 55 | -------------------------------------------------------------------------------- /Structures/Structures/Structures-Bridging-Header.h: -------------------------------------------------------------------------------- 1 | // 2 | // Use this file to import your target's public headers that you would like to expose to Swift. 3 | // 4 | 5 | -------------------------------------------------------------------------------- /Structures/Structures/Tree/BinaryTree.cpp: -------------------------------------------------------------------------------- 1 | // 2 | // BinaryTree.cpp 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 2020/02/02. 6 | // Copyright © 2020 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: Binary Tree 10 | 11 | #if 0 12 | #include 13 | using namespace std; 14 | template // 다형성을 위해 타입은 템플릿을 사용, 15 | class Node { 16 | private: 17 | T value; 18 | Node *left; 19 | Node *right; 20 | Node *root; 21 | public: 22 | Node() : value(0), left(nullptr), root(nullptr) {}; 23 | Node(T _value) : value(_value), right(nullptr), root(nullptr) {}; 24 | Node(T _value, Node* _left, Node* _right) : value(_value), left(_left), right(_right), root(nullptr) { 25 | // 만약 왼쪽 오른쪽 노드가 존재한다면, 현재 노드는 부모노드이다. 26 | if(nullptr != _left) 27 | _left->root = this; 28 | if(nullptr != _right) 29 | _right->root = this; 30 | }; 31 | 32 | ~Node() {}; 33 | 34 | void setLeft(Node* node) { this->left = node; } 35 | void setRight(Node* node) { this->right = node; } 36 | Node* getLeft() { return left; } 37 | Node* getRight() { return right; } 38 | T getValue() { return value; } 39 | }; 40 | 41 | // 재귀를 사용한 전위 / 중위 / 후위 노드 출력 42 | template 43 | void printPreorder(Node* node) // 전위 44 | { 45 | if(node == nullptr) return; 46 | cout << node->getValue() << " "; 47 | printPreorder(node->getLeft()); 48 | printPreorder(node->getRight()); 49 | } 50 | 51 | template 52 | void printInorder(Node* node) // 중위 53 | { 54 | if(node == nullptr) return; 55 | printInorder(node->getLeft()); 56 | cout << node->getValue() << " "; 57 | printInorder(node->getRight()); 58 | } 59 | 60 | template 61 | void printPostOrder(Node* node) { // 후위 62 | if(node == nullptr) return; 63 | printPostOrder(node->getLeft()); 64 | printPostOrder(node->getRight()); 65 | cout << node->getValue() << " "; 66 | } 67 | 68 | int main() { 69 | ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0); 70 | 71 | // TREE STATUS 72 | 73 | // 3 74 | // 1 2 75 | // 4 5 6 76 | 77 | // inorder : 4 1 5 3 6 2 78 | // preorder : 3 1 4 5 2 6 79 | // postorder : 4 5 1 6 2 3 80 | 81 | Node* node1 = new Node(1); 82 | Node* node2 = new Node(2); 83 | Node* node3 = new Node(3, node1, node2); 84 | Node* node4 = new Node(4); 85 | Node* node5 = new Node(5); 86 | Node* node6 = new Node(6); 87 | 88 | node1->setLeft(node4); 89 | node1->setRight(node5); 90 | node2->setLeft(node6); 91 | 92 | cout << "전위 결과 : "; 93 | printPreorder(node3); 94 | puts(""); 95 | cout << "중위 결과 : "; 96 | printInorder(node3); 97 | puts(""); 98 | cout << "후위 결과 : "; 99 | printPostOrder(node3); 100 | puts(""); 101 | return 0; 102 | } 103 | #endif 104 | -------------------------------------------------------------------------------- /Structures/Structures/Tree/BinaryTree.swift: -------------------------------------------------------------------------------- 1 | // 2 | // BinaryTree.swift 3 | // Structures 4 | // 5 | // Created by MinKyeongTae on 2020/02/03. 6 | // Copyright © 2020 MinKyeongTae. All rights reserved. 7 | // 8 | 9 | // MARK: BinaryTree Structure Implementation by Swift 10 | 11 | // MARK: - Basic BinaryTree Structure 코드구현 복습 12 | 13 | /* 14 | class BinaryTreeNode { 15 | var value: T 16 | var leftChild: BinaryTreeNode? 17 | var rightChild: BinaryTreeNode? 18 | init(_ value: T, _ leftChild: BinaryTreeNode? = nil, _ rightChild: BinaryTreeNode? = nil) { 19 | self.value = value 20 | self.leftChild = leftChild 21 | self.rightChild = rightChild 22 | } 23 | 24 | func traverseInOrder(_ visit: (T) -> ()) { 25 | self.leftChild?.traverseInOrder(visit) 26 | visit(self.value) 27 | self.rightChild?.traverseInOrder(visit) 28 | } 29 | 30 | func traversePreOrder(_ visit: (T) -> ()) { 31 | visit(self.value) 32 | self.leftChild?.traversePreOrder(visit) 33 | self.rightChild?.traversePreOrder(visit) 34 | } 35 | 36 | func traversePostOrder(_ visit: (T) -> ()) { 37 | self.leftChild?.traversePostOrder(visit) 38 | self.rightChild?.traversePostOrder(visit) 39 | visit(self.value) 40 | } 41 | } 42 | 43 | // MARK: - Below Nodes 44 | 45 | // 1 46 | // 2 3 47 | // 4 5 6 7 48 | 49 | // InOrder : 4, 2, 5, 1, 6, 3, 7 50 | // PreOrder : 1, 2, 4, 5, 3, 6, 7 51 | // PostOrder : 4, 5, 2, 6, 7, 3, 1 52 | 53 | var leaf7 = BinaryTreeNode(7) 54 | var leaf6 = BinaryTreeNode(6) 55 | var leaf5 = BinaryTreeNode(5) 56 | var leaf4 = BinaryTreeNode(4) 57 | var node3 = BinaryTreeNode(3, leaf6, leaf7) 58 | var node2 = BinaryTreeNode(2, leaf4, leaf5) 59 | var rootNode = BinaryTreeNode(1, node2, node3) 60 | rootNode.traverseInOrder { print("\($0) ", terminator: "")} // 4,2,5,1,6,3,7 61 | print() 62 | rootNode.traversePreOrder { print("\($0) ", terminator: "")} // 1,2,4,5,3,6,7 63 | print() 64 | rootNode.traversePostOrder { print("\($0) ", terminator: "")} // 4,5,2,6,7,3,1 65 | */ 66 | 67 | // MARK: - BinaryTree 기본구조 Swift 구현 68 | 69 | /* 70 | import Foundation 71 | 72 | class BinaryTreeNode { 73 | var value: T 74 | var leftChild: BinaryTreeNode? 75 | var rightChild: BinaryTreeNode? 76 | init(_ value: T, _ leftChild: BinaryTreeNode? = nil, _ rightChild: BinaryTreeNode? = nil) { 77 | self.value = value 78 | self.leftChild = leftChild 79 | self.rightChild = rightChild 80 | } 81 | 82 | func traverseInOrder(_ visit: (T) -> ()) { 83 | leftChild?.traverseInOrder(visit) 84 | visit(self.value) 85 | rightChild?.traverseInOrder(visit) 86 | } 87 | 88 | func traversePreOrder(_ visit: (T) -> ()) { 89 | visit(self.value) 90 | leftChild?.traversePreOrder(visit) 91 | rightChild?.traversePreOrder(visit) 92 | } 93 | 94 | func traversePostOrder(_ visit: (T) -> ()) { 95 | leftChild?.traversePostOrder(visit) 96 | rightChild?.traversePostOrder(visit) 97 | visit(self.value) 98 | } 99 | } 100 | 101 | let five = BinaryTreeNode(5) 102 | let four = BinaryTreeNode(4) 103 | let three = BinaryTreeNode(3) 104 | let two = BinaryTreeNode(2, five, nil) 105 | let one = BinaryTreeNode(1, three, four) 106 | let rootTree = BinaryTreeNode(0, one, two) 107 | 108 | // 3 1 4 0 5 2 109 | print("traverseInOrder Rusult ▼") 110 | rootTree.traverseInOrder { print($0, terminator: "->") } 111 | print() 112 | 113 | // 0 1 3 4 2 5 114 | print("traversePreOrder Rusult ▼") 115 | rootTree.traversePreOrder { print($0, terminator: "->") } 116 | print() 117 | 118 | // 3 4 1 5 2 0 119 | print("traversePostOrder Rusult ▼") 120 | rootTree.traversePostOrder { print($0, terminator: "->")} 121 | 122 | */ 123 | -------------------------------------------------------------------------------- /Structures/Structures/mainc.swift: -------------------------------------------------------------------------------- 1 | //// 2 | //// main.swift 3 | //// Structures 4 | //// 5 | //// Created by MinKyeongTae on 16/09/2019. 6 | //// Copyright © 2019 MinKyeongTae. All rights reserved. 7 | //// 8 | // 9 | // import Foundation 10 | // 11 | // print("Hello, World!") 12 | // 13 | //// MARK: - Queue VS DoubleStack 14 | // 15 | //// MARK: QueueArray 16 | // 17 | // var queueArray = QueueArray() 18 | // queueArray.push(1) 19 | // queueArray.push(2) 20 | // queueArray.push(3) 21 | // print(queueArray) 22 | // queueArray.pop() 23 | // print(queueArray) 24 | // queueArray.pop() 25 | // print(queueArray) 26 | // queueArray.pop() 27 | // print(queueArray) 28 | // 29 | //// MARK: DoubleStack 30 | // 31 | // var doubleStack = QueueDoubleStack() 32 | // doubleStack.push(1) 33 | // doubleStack.push(2) 34 | // doubleStack.push(3) 35 | // print(doubleStack) 36 | // doubleStack.pop() 37 | // print(doubleStack) 38 | // doubleStack.pop() 39 | // print(doubleStack) 40 | // doubleStack.pop() 41 | // print(doubleStack) 42 | -------------------------------------------------------------------------------- /SwiftAlgorithmStudy.playground/Contents.swift: -------------------------------------------------------------------------------- 1 | import UIKit 2 | 3 | ////// MARK:- SWIFT ALGORITHM CHALLENGE STUDY 4 | 5 | //// MARK: - Challenge 1 6 | /// 본 문자열 내의 중복문자가 있는지 확인하라 7 | 8 | // var strDic = Set() 9 | // var flag = true 10 | // 11 | func challenge0(_ input: String) -> Bool { 12 | return (input.count == Set(input).count) 13 | } 14 | 15 | // 16 | // func challenge1(_ input: String) -> Bool { 17 | // 18 | // for char in input { 19 | // if strDic.contains(char) == false { 20 | // strDic.insert(char) 21 | // } else { 22 | // return false 23 | // } 24 | // } 25 | // return true 26 | // } 27 | // 28 | print(challenge0("as")) 29 | 30 | //// MARK: - Challenge 2 31 | ///// 본 문자열과 reversed 문자열이 동일한지 확인하라 32 | // 33 | // func challenge3(_ input: String) -> Bool { 34 | // return String(input.lowercased()) == String(input.lowercased().reversed()) 35 | // } 36 | // 37 | // print(challenge3("Rats live on no evil star")) 38 | 39 | //// MARK: - Challenge 3 40 | // 41 | // var strDic = [Character:Int]() 42 | // var strDic2 = [Character:Int]() 43 | // 44 | // 45 | // func challenge4(input: String, input2: String) -> Bool { 46 | // let str = input.replacingOccurrences(of: " ", with: "").sorted() 47 | // let str2 = input2.replacingOccurrences(of: " ", with: "").sorted() 48 | // print(str) 49 | // print(str2) 50 | // return str == str2 51 | // } 52 | // 53 | ////✭ component 구분자 + separated + joined() 를 사용할 수도 있다. 54 | //// remove를 통한 공백 제거 후 sorted() 55 | // print(challenge4(input: "a1b2", input2: "1a b2")) 56 | 57 | // let str = "asd" 58 | // print(str.fuzzyContains(input: "asd")) 59 | 60 | //// 첫번째 방법 61 | // extension String { 62 | // func fuzzyContains(input: String) -> Bool { 63 | // return self.lowercased().range(of: input.lowercased()) != nil 64 | // } 65 | // } 66 | 67 | //// 두번째 방법 68 | // extension String { 69 | // func fuzzyContains(input: String) -> Bool { 70 | // 71 | // let mStr = Array(self.lowercased()) // 접근한 String 72 | // let lowercasedStr = input.lowercased() 73 | // var index: String.Index 74 | // 75 | // for char in mStr { 76 | // var index = char == mStr[index] ? mStr.index(after: index) : mStr.startIndex 77 | // 78 | // } 79 | // 80 | // if index == str.endIndex { 81 | // return true 82 | // } 83 | // 84 | // return false 85 | // } 86 | // } 87 | 88 | //// MARK: - Challenge 5 89 | 90 | //// 1번째 방법 91 | // print(verifyString(char: "i", str2: "Hacking With Swift")) 92 | // func verifyString(char: Character, str2: String) -> Int { 93 | // var count = 0 94 | // for ch in str2 { 95 | // if char == ch { 96 | // count += 1 97 | // } 98 | // } 99 | // return count 100 | // } 101 | // 102 | // func verifyString(char: Character, str2: String) -> Int { 103 | // var count = 0 104 | // 105 | // return str2.characters.reduce(0) { 106 | // $0 == count ? $0 + 1 : $0 107 | // } 108 | // } 109 | 110 | //////// MARK: - Challenge 6 111 | //// ** 중복된 문자열은 하나씩만 출력하시오. ** 112 | // var str = "Hello, playground" 113 | //// var dict = [Character:Bool]() 114 | // var setData = Set() 115 | // func checkDuplicate(string: String) -> String { 116 | // // string.forEach { (char) in 117 | // // dict[char] = false 118 | // // } 119 | // // 120 | // // var ansString: String = "" 121 | // // string.forEach { (char) in 122 | // // guard let chk = dict[char] else { return } 123 | // // if !chk { 124 | // // dict[char] = true 125 | // // ansString.append(char) 126 | // // } 127 | // // } 128 | // 129 | // return string.filter { (char) -> Bool in 130 | // if setData.contains(char) { 131 | // return false 132 | // } else { 133 | // setData.insert(char) 134 | // return true 135 | // } 136 | // } 137 | // } 138 | // 139 | //// ✔︎ contains를 활용한 문제 풀이 가능하다. 140 | // 141 | // print(checkDuplicate(string: "Mississippi")) 142 | // 143 | // func challenge6a(string: String) -> String { 144 | // let array = string.map { String($0) } 145 | // let set = NSOrderedSet(array: array) 146 | // let letters = Array(set) as! [String] 147 | // return letters.joined() // 빈칸없는 String으로 정리한 뒤 출력 -> 정답! 148 | // } 149 | // 150 | // func challenge6c(string: String) -> String { 151 | // var used = [Character: Bool]() 152 | // 153 | // let result = string.filter { 154 | // used.updateValue(true, forKey: $0) == nil 155 | // } 156 | // 157 | // return result 158 | // } 159 | 160 | ////// MARK: - Challenge 7 ** 161 | ///// 문자열 내 스페이스공간을 최대 하나로 응축시켜라 162 | // 163 | // func condenseString(str: String) -> String { 164 | // var flag: Bool = false 165 | // var ans = Array(str) 166 | // 167 | // var index = 0 168 | // while true { 169 | // if index >= ans.count { break } 170 | // if ans[index] == " " { 171 | // if flag { 172 | // ans.remove(at: index) 173 | // index -= 1 174 | // 175 | // } else { 176 | // flag = true 177 | // } 178 | // 179 | // } else { 180 | // flag = false 181 | // } 182 | // index += 1 183 | // } 184 | // 185 | // return String(ans) 186 | // } 187 | // 188 | // print("\(condenseString(str: "s ad asd jqw dioq"))") 189 | 190 | //////// MARK: - Challenge 8 191 | //// **문자열이 회전 시 일치하는 경우가 있는지 판별하시오.** 192 | //// CASE 1) * 문자열을 탐색하며 비교값과 문자가 동일하면 해당 문자 기준 앞 뒤를 비교한다. 193 | // func isRotatable(first: String, second: String) -> Bool { 194 | // let char = first[first.startIndex] 195 | // var endIndexOfFirst = first.endIndex 196 | // 197 | // for index in second.indices { 198 | // if char == second[index] { 199 | // if first[.. Bool { 212 | // guard first.count == second.count else { return false } 213 | // let combined = first + first 214 | // return combined.contains(second) 215 | // } 216 | // 217 | //// 1: asdfg <-> gasdf 218 | // print(isRotatable2(first: "asdfg", second: "gasdf")) 219 | 220 | ////////// MARK: - Challenge 10 221 | // * 문자열의 자음, 모음 갯수를 각각 출력하라 222 | // func printVowelAndConsonants(str: String) -> (Int,Int) { 223 | // let chkArr = str.lowercased().components(separatedBy: .whitespaces).joined() 224 | // var answer: (Int,Int) = (0,0) 225 | // for char in chkArr { 226 | // if char == "a" || char == "e" || char == "i" || char == "o" || char == "u" { 227 | // answer.0 += 1 228 | // } else { 229 | // answer.1 += 1 230 | // } 231 | // } 232 | // return answer 233 | // } 234 | // 235 | ///// 1) aeiou, ~~~~ 를 String 명시 후 contains 사용방법 236 | ///// 2) 정규표현식을 사용하는 방법 237 | ///// 3) rangeOfCharacter의 활용 238 | // 239 | // print("\(printVowelAndConsonants(str: "Swift Coding Challenges"))") 240 | // print("\(printVowelAndConsonants(str: "Mississippi"))") 241 | 242 | ////////// MARK: - Challenge 11 243 | // * 4개 이상 문자가 틀리면 false, 아니면 true를 리턴하라 244 | func checkString(str: String, str2: String) -> Bool { 245 | let strArray = Array(str) 246 | let str2Array = Array(str2) 247 | if strArray.count != str2Array.count { return false } 248 | var count = 0 249 | 250 | for idx in str2Array.indices { 251 | if strArray[idx] != str2Array[idx] { 252 | count += 1 253 | if count > 3 { 254 | return false 255 | } 256 | } 257 | } 258 | return true 259 | } 260 | 261 | print(checkString(str: "Clamp", str2: "Cramp")) 262 | print(checkString(str: "Clamp", str2: "Crams")) 263 | print(checkString(str: "Clamp", str2: "Grams")) 264 | print(checkString(str: "Clamp", str2: "Grans")) 265 | print(checkString(str: "Clamp", str2: "Clam")) 266 | print(checkString(str: "Clamp", str2: "maple")) 267 | -------------------------------------------------------------------------------- /SwiftAlgorithmStudy.playground/contents.xcplayground: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | -------------------------------------------------------------------------------- /SwiftAlgorithmStudy.playground/playground.xcworkspace/contents.xcworkspacedata: -------------------------------------------------------------------------------- 1 | 2 | 4 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /SwiftAlgorithmStudy.playground/playground.xcworkspace/xcshareddata/IDEWorkspaceChecks.plist: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | 5 | IDEDidComputeMac32BitWarning 6 | 7 | 8 | 9 | -------------------------------------------------------------------------------- /SwiftAlgorithmStudy.playground/playground.xcworkspace/xcuserdata/applebuddy.xcuserdatad/UserInterfaceState.xcuserstate: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/applebuddy/AlgorithmMemo/6ffe9a92468d1b14a71e6f78e695ec6af96f531b/SwiftAlgorithmStudy.playground/playground.xcworkspace/xcuserdata/applebuddy.xcuserdatad/UserInterfaceState.xcuserstate --------------------------------------------------------------------------------