블로그

감자

나는 AI에 대체될까?

AI 시대에는 분야를 막론하고 "AI가 내 자리를 대체하지 않을까?"라는 걱정을 피하기 어렵습니다.특히 개발자들은 코드 자동 생성 서비스가 폭발적으로 등장하면서 "이제 코딩 공부는 필요 없겠다"라고 생각할 수 있습니다.과연 이것이 사실일까요?우리는 정말 코딩 공부를 하지 않아도 될까요?이 질문에 답하기 전에 2025년 3월의 한 기사를 살펴보겠습니다. 빌게이츠가 예측한 AI 시대 유망한 직업 ‘세 가지’… "의사·교사는 AI에 대체될 것”다만 게이츠는 전 직종에서 AI가 인간을 대체할 것이라면서도 일부 직종의 경우 대체되지 않는 직업도 있을 것이라고 했다. 그는 "기계가 야구를 하는 것을 누구도 보고 싶지 않을 것"이라고 했다.그러면서 AI가 대체하기 힘든 직업으로 '코딩 개발자, 에너지 전문가, 생물학자' 등을 언급했다. 최신 AI 모델들이 등장할 때마다 개발자들이 가장 먼저 대체될 것이라는 주장이 나오고 있지만, 게이츠는 인간 전문가가 필수적이라고 보고 있다.게이츠는 AI가 코드를 생성할 수 있다는 것은 분명하지만, 이 과정에서 여전히 인간이 필요하다고 했다.인간 전문가는 오류를 식별하고 수정하며, 알고리즘을 개선하고 AI 개발을 강화하는 데 반드시 필요하다는 설명이다. 이어 게이츠는 생물학자도 AI가 대체하기 어려울 것이라고 주장했다. 빌게이츠가 언급한 AI 시대에도 대체되기 어려운 직업으로는 코딩 개발자, 에너지 전문가, 생물학자가 있습니다. 이 중에서 코딩 개발자에 초점을 맞춰 살펴보겠습니다.AI가 코드를 빠르게 생성할 수 있게 되면서 개발자의 생산성은 크게 향상되었습니다. 하지만 동시에 컴퓨터 과학에 대한 깊은 지식이 필요 없는 단순 코드 생성 작업은 AI가 신입 개발자의 역할을 대체하고 있습니다. 이러한 기술적 변화와 경제적 요인으로 신입 개발자 채용이 감소하고 있습니다.그렇다면 주니어 개발자들은 개발직을 포기하고 다른 진로를 모색해야 할까요? 앞서 본 기사에 따르면, 개발자가 여전히 필요한 이유는 AI가 생성한 잘못된 코드와 비효율적인 알고리즘을 수정해야 하기 때문입니다. 즉, AI가 만든 코드의 품질을 판단하고 개선할 수 있는 능력이 필수적이라는 뜻입니다.경험이 부족한 주니어 개발자들은 이러한 능력이 아직 미흡할 수 있습니다. 하지만 AI 시대에 살아남기 위해서는 반드시 이러한 역량을 키워야 합니다.  컴퓨터 공학(Computer Science)에 대한 지식은 이러한 능력을 키우는 데 필수적입니다.이는 주니어 개발자는 물론 시니어 개발자에게도 해당됩니다.컴퓨터 공학은 컴퓨터 구조, 운영체제, 자료구조와 알고리즘, 네트워크, 데이터베이스 등을 포함합니다.이번 포스트에서는 그 중 컴퓨터 구조에 초점을 맞추어 보겠습니다.컴퓨터는 0과 1을 스위칭 하는 장치로 만들어집니다.과거에는 릴레이라는 장치를 이용해 만들었고, 이보다 효율적인 진공관, 트랜지스터로 발전되어 왔습니다.현재 컴퓨터는 트랜지스터를 이용해 만들 수 있는데요.트랜지스터로 논리 회로를 구성하고, 논리 회로를 조합해 프로그래밍을 할 수 있는 컴퓨터를 만듭니다.이 과정에서 논리 연산과 논리 연산의 특성, 메모리의 구조와 특성, 기계어와 어셈블리어를 다루면서 메모리에 대한 추상적인 이해가 아니라 실제적인 이해를 할 수 있습니다.이를 이해한다면 C언어의 메모리 접근은 굉장히 쉽게 느껴질 수 있습니다.그리고 컴퓨터가 ‘진짜로 어떻게 동작하는지’를 이해할 수 있기 때문에 상위 계층에서 해결하기 어려운 최적화 작업도 할 수 있는 능력을 가지게 됩니다.단순히 코드를 빠르게 만들어 내는 것은 AI가 가장 잘하는 것입니다.AI가 주도하는 시대에 우리는 컴퓨터 공학에 대한 기초를 단단히 가지고 AI의 부족한 부분을 채워 확실한 경쟁력을 가졌으면 좋겠습니다.그렇지 않으면 대체될 것입니다. 컴퓨터 구조는 대학교 수업, 인터넷 강의, 서적 등 다양한 방법으로 배울 수 있습니다.제가 준비한 컴퓨터 구조 강의는 시각적 자료를 활용하여 개념을 쉽게 설명하고, 실제 8비트 컴퓨터를 직접 만들어보며 컴퓨터의 구조와 동작 원리를 깊이 이해할 수 있도록 구성했습니다. 컴퓨터 구조를 배우는 것은 단순히 AI 시대의 흐름을 쫓아가는 것이 아닌, 그 흐름을 주도할 수 있는 힘을 키우는 일입니다. 이 강의를 통해 여러분이 기술의 최전선에서 활약하며 세상의 변화를 이끌어낼 수 있도록 돕겠습니다.(2025년 5월 10일까지 30%할인 진행하고 있습니다)add_shortcode('course','336749','list')

컴퓨터 구조컴퓨터과학컴퓨터구조AI

왜 CS 전공지식은 ‘개발자 기본기’로 꼽힐까?

컴퓨터 구조, 자료구조, 알고리즘, 운영체제, 네트워크, 데이터베이스 등은 컴퓨터공학 및 컴퓨터과학, 소프트웨어공학 등의 전공에서 반드시 배우는 주제로 꼽힙니다. 학교나 학과마다 커리큘럼에 차이는 있더라도 내용 자체는 모두 동일한 개념을 배우게 되는데요.이러한 CS 전공 지식은 컴퓨터 관련 학과에서의 전공 이해를 좌우할 뿐만 아니라, 개발자 채용을 위한 기술 면접 과정에서 주로 검증하는 핵심 개념이기도 합니다. 가령 서비스 개발자라면 비즈니스 로직을 구축하는 등, 프로그램의 구조를 만들고 문제를 해결하는 바탕이 되기 때문입니다. 이미 실무에 진출한 개발자들조차도 CS 전공 지식을 강조하는 이유가 여기에 있죠.다시 말해 CS 전공 지식은 개발자로서 필요한 문제 해결 역량을 결정하는 기본기 역할을 합니다. 대학생, 취업 준비생, 주니어 개발자 등을 막론하고 실력 있는 프로그래머가 되기 위한 든든한 뿌리가 필요하다면 CS 전공 지식에 주목해야 합니다.•••기술 면접 전, 실무 프로젝트 전 빠르게 기초를 정리하고 싶으신가요?지금 인프런 프리즘 [CS 전공 지식 로드맵]을 통해 학습해보세요. https://www.inflearn.com/roadmaps/643•••인프런 프리즘 브랜드 스토리 읽어보기 >>

개발 · 프로그래밍 기타CS전공지식컴퓨터구조알고리즘자료구조운영체제네트워크데이터베이스컴퓨터공학인프런프리즘InflearnPrism

avraskio

[워밍업클럽4기-CS] 1주차 미션

컴퓨터 구조4입력 AND, OR, NAND, NOR, XOR 연산의 진리표를 작성해보세요.입력 4개 AND입력 4개 OR입력 4개 NAND입력 4개 NOR입력 4개 XOR다음 불 방정식들을 여러 방법을 이용해 간략화 해보세요.A( (BB)’+ 0A) + (CC)' = A(B’ + 0) + C’ = AB’ + A0 + C’ = AB’ + C’(B’B’) + (AD’ + (CA)’)D = B’ + (AD’ + C’ + A’)D = B’ + C’D + A’D(A’B) + B(B1 + BC) = A’B +B(B(1+C)) = A’B + B = (A’+1)B = BB’(1C + BD) + DB = B’C + B’BD + DB = B’C +DB다음 2진수를 10진수로 변환해보세요.110111 = 32 + 16 + 4 + 2 + 1 = 5510000001 = 128 + 1 = 12911111100000 = 1024 + 512 +256 +128 +64 +32 = 2016101010 = 32 + 8 +2 = 42다음 10진수를 2진수로 변환해보세요.10 = 8 + 2 = 101027 = 16 +8 +2 +1 = 1101186 = 64 +16 + 4 + 2 = 1010110516 = 512 + 4 = 1000000100다음 불 방정식을 logisim을 이용해 회로를 만들어보세요.(회로 이미지와 .circ파일 첨부)(B’C) + (DB)(AB’) +CB’ + (DC’) + (DA’)자료구조와 알고리즘public class BinaryTree<T> { private T data; private BinaryTree<T> leftTree; private BinaryTree<T> rightTree; private int height; public BinaryTree(T data) { this.data = data; this.leftTree = null; this.rightTree = null; this.height = 1; } public T getData() { return this.data; } public void setData(T data) { this.data = data; } public int getHeight() { return this.height; } public void setHeight(int height) { this.height = height; } public BinaryTree<T> getLeftSubTree() { return this.leftTree; } public void setLeftSubTree(BinaryTree<T> leftTree) { this.leftTree = leftTree; } public BinaryTree<T> getRightSubTree() { return this.rightTree; } public void setRightSubTree(BinaryTree<T> rightTree) { this.rightTree = rightTree; } public BinaryTree<T> removeLeftSubTree() { BinaryTree<T> deletingNode = this.leftTree; this.setLeftSubTree(null); return deletingNode; } public BinaryTree<T> removeRightSubTree() { BinaryTree<T> deletingNode = this.rightTree; this.setRightSubTree(null); return deletingNode; } // 전위순회 public void preOrderTraversal() { System.out.print(this.data + " "); if (this.leftTree != null) { this.leftTree.preOrderTraversal(); } if (this.rightTree != null) { this.rightTree.preOrderTraversal(); } } // 중위순회 public void inOrderTraversal() { if (this.leftTree != null) { this.leftTree.inOrderTraversal(); } System.out.print(this.data + " "); if (this.rightTree != null) { this.rightTree.inOrderTraversal(); } } // 후위순회 public void postOrderTraversal() { if (this.leftTree != null) { this.leftTree.postOrderTraversal(); } if (this.rightTree != null) { this.rightTree.postOrderTraversal(); } System.out.print(this.data + " "); } }public class AvlTree { private BinaryTree<Integer> root; public BinaryTree<Integer> getRoot() { return this.root; } public BinaryTree<Integer> searchCeil(int data) { BinaryTree<Integer> currentNode = this.root; BinaryTree<Integer> result = null; while (currentNode != null) { if (currentNode.getData() == data) { return currentNode; } else if (currentNode.getData() < data) { currentNode = currentNode.getRightSubTree(); } else { result = currentNode; currentNode = currentNode.getLeftSubTree(); } } return result; } public Integer search(int data) { BinaryTree<Integer> currentNode = this.root; while (currentNode != null) { if (currentNode.getData() == data) { return currentNode.getData(); } else if (currentNode.getData() > data) { currentNode = currentNode.getLeftSubTree(); } else { currentNode = currentNode.getRightSubTree(); } } return null; } public int getHeight(BinaryTree<Integer> node) { if (node == null) { return 0; } return node.getHeight(); } public void updateHeight(BinaryTree<Integer> node) { int leftChildHeight = this.getHeight(node.getLeftSubTree()); int rightChildHeight = this.getHeight(node.getRightSubTree()); node.setHeight(Math.max(leftChildHeight, rightChildHeight) + 1); } public int getBalanceFactor(BinaryTree<Integer> node) { if (node == null) { return 0; } return this.getHeight(node.getLeftSubTree()) - this.getHeight(node.getRightSubTree()); } public BinaryTree<Integer> rotateLeft(BinaryTree<Integer> node) { BinaryTree<Integer> childNode = node.getRightSubTree(); node.setRightSubTree(childNode.getLeftSubTree()); childNode.setLeftSubTree(node); this.updateHeight(node); this.updateHeight(childNode); return childNode; } public BinaryTree<Integer> rotateRight(BinaryTree<Integer> node) { BinaryTree<Integer> childNode = node.getLeftSubTree(); node.setLeftSubTree(childNode.getRightSubTree()); childNode.setRightSubTree(node); this.updateHeight(node); this.updateHeight(childNode); return childNode; } public BinaryTree<Integer> rotation(BinaryTree<Integer> targetNode, int data) { int balanceFactor = this.getBalanceFactor(targetNode); boolean isRootNode = false; if(targetNode == this.root) { isRootNode = true; } if (balanceFactor < -1 && data > targetNode.getRightSubTree().getData()) { targetNode = this.rotateLeft(targetNode); // LL }else if(balanceFactor > 1 && data < targetNode.getLeftSubTree().getData()) { targetNode = this.rotateRight(targetNode); // RR } else if (balanceFactor > 1 && data > targetNode.getLeftSubTree().getData()) { targetNode.setLeftSubTree(this.rotateLeft(targetNode.getLeftSubTree())); targetNode = this.rotateRight(targetNode); // LR } else if(balanceFactor < -1 && data < targetNode.getRightSubTree().getData()) { targetNode.setRightSubTree(this.rotateRight(targetNode.getRightSubTree())); targetNode = this.rotateLeft(targetNode); // RL } if (isRootNode) { this.root = targetNode; } return targetNode; } public BinaryTree<Integer> getUnBalanceNode(BinaryTree<Integer> targetRootNode, BinaryTree<Integer> unBalanceNode) { if (targetRootNode.getLeftSubTree() == null && targetRootNode.getRightSubTree() == null) { unBalanceNode = targetRootNode; return unBalanceNode; } int balanceFactor = this.getBalanceFactor(targetRootNode); if (balanceFactor > 0) { unBalanceNode = this.getUnBalanceNode(targetRootNode.getLeftSubTree(), unBalanceNode); } else if (balanceFactor < 0) { unBalanceNode = this.getUnBalanceNode(targetRootNode.getRightSubTree(), unBalanceNode); } else { unBalanceNode = targetRootNode.getRightSubTree(); } return unBalanceNode; } public BinaryTree<Integer> insert(BinaryTree<Integer> targetRootNode, int data) { if(targetRootNode == null) { targetRootNode = new BinaryTree<>(data); } if (this.root == null) { this.root = targetRootNode; } else if (targetRootNode.getData() == data) { return targetRootNode; } else if (targetRootNode.getData() > data) { targetRootNode.setLeftSubTree(this.insert(targetRootNode.getLeftSubTree(), data)); } else { targetRootNode.setRightSubTree(this.insert(targetRootNode.getRightSubTree(), data)); } this.updateHeight(targetRootNode); targetRootNode = this.rotation(targetRootNode, data); return targetRootNode; } public BinaryTree<Integer> remove(BinaryTree<Integer> targetRootNode, int data, BinaryTree<Integer> parentNode) { if (targetRootNode.getData() > data && targetRootNode.getLeftSubTree() != null) { targetRootNode.setLeftSubTree(this.remove(targetRootNode.getLeftSubTree(), data, targetRootNode)); } else if (targetRootNode.getData() < data && targetRootNode.getRightSubTree() != null) { targetRootNode.setRightSubTree(this.remove(targetRootNode.getRightSubTree(), data, targetRootNode)); } else if (targetRootNode.getData() == data) { targetRootNode = this.removeHelper(targetRootNode, data, parentNode); if (parentNode == null && targetRootNode != null) { this.updateHeight(targetRootNode); BinaryTree<Integer> unBalanceNode = this.getUnBalanceNode(targetRootNode, null); targetRootNode = this.rotation(targetRootNode, unBalanceNode.getData()); } return targetRootNode; } this.updateHeight(targetRootNode); BinaryTree<Integer> unBalanceNode = this.getUnBalanceNode(targetRootNode, null); targetRootNode = this.rotation(targetRootNode, unBalanceNode.getData()); return targetRootNode; } private BinaryTree<Integer> removeHelper(BinaryTree<Integer> deletingNode, int data, BinaryTree<Integer> parentNode) { BinaryTree<Integer> fakeParentRootNode = new BinaryTree<>(0); fakeParentRootNode.setRightSubTree(this.root); if (parentNode == null) { parentNode = fakeParentRootNode; } BinaryTree<Integer> deletingNodeChild = null; if (deletingNode.getLeftSubTree() == null && deletingNode.getRightSubTree() == null) { if (parentNode.getLeftSubTree() == deletingNode) { parentNode.removeLeftSubTree(); } else { parentNode.removeRightSubTree(); } } else if (deletingNode.getLeftSubTree() == null || deletingNode.getRightSubTree() == null) { if (deletingNode.getLeftSubTree() != null) { deletingNodeChild = deletingNode.getLeftSubTree(); } else { deletingNodeChild = deletingNode.getRightSubTree(); } if (parentNode.getLeftSubTree() == deletingNode) { parentNode.setLeftSubTree(deletingNodeChild); } else { parentNode.setRightSubTree(deletingNodeChild); } } else { BinaryTree<Integer> replacingNode = deletingNode.getLeftSubTree(); BinaryTree<Integer> replacingNodeParent = deletingNode; while (replacingNode.getRightSubTree() != null) { replacingNodeParent = replacingNode; replacingNode = replacingNode.getRightSubTree(); } deletingNode.setData(replacingNode.getData()); if (replacingNodeParent.getLeftSubTree() == replacingNode) { replacingNodeParent.setLeftSubTree(replacingNode.getLeftSubTree()); } else { replacingNodeParent.setRightSubTree(replacingNode.getLeftSubTree()); } deletingNodeChild = deletingNode; } if (fakeParentRootNode.getRightSubTree() != this.root) { this.root = fakeParentRootNode.getRightSubTree(); } return deletingNodeChild; } }public class GarbageCollector { private final AvlTree avlTree; public GarbageCollector() { this.avlTree = new AvlTree(); } public void insertFreeMemory(int size) { this.avlTree.insert(this.avlTree.getRoot(), size); } public BinaryTree<Integer> searchFreeMemory(int size) { return this.avlTree.searchCeil(size); } public void releaseFreeMemory(int size) { this.avlTree.remove(this.avlTree.getRoot(), size, null); } public static void main(String[] args) { GarbageCollector gc = new GarbageCollector(); System.out.println("================= 빈 메모리 영역 초기화 ================="); gc.insertFreeMemory(64); gc.insertFreeMemory(48); gc.insertFreeMemory(87); gc.insertFreeMemory(13); gc.insertFreeMemory(102); gc.insertFreeMemory(34); gc.insertFreeMemory(61); gc.insertFreeMemory(40); gc.insertFreeMemory(6); BinaryTree<Integer> freeMemory1 = gc.searchFreeMemory(64); // 64 System.out.println("Found: " + (freeMemory1 != null ? freeMemory1.getData() : "null")); if (freeMemory1 != null) { gc.releaseFreeMemory(freeMemory1.getData()); } BinaryTree<Integer> freeMemory2 = gc.searchFreeMemory(42); // 48 System.out.println("Found: " + (freeMemory2 != null ? freeMemory2.getData() : "null")); if (freeMemory2 != null) { gc.releaseFreeMemory(freeMemory2.getData()); } BinaryTree<Integer> freeMemory3 = gc.searchFreeMemory(150); // X System.out.println("Found: " + (freeMemory3 != null ? freeMemory3.getData() : "null")); if (freeMemory3 != null) { gc.releaseFreeMemory(freeMemory3.getData()); } } } 첨부파일: https://jeongburgger.notion.site/20538ccc08b98012b5a7c6dd7ddf388d?pvs=73https://inf.run/4sVHg (그림으로 쉽게 배우는 자료구조와 알고리즘 (심화편))https://inf.run/yFzxT (만들면서 쉽게 배우는 컴퓨터 구조)

알고리즘 · 자료구조감자컴퓨터구조알고리즘&자료구조

인프런 워밍업 클럽 4기 - CS 전공지식; 컴퓨터 구조 및 알고리즘

인프런 워밍업 클럽 4기 첫 주차!먼저 컴퓨터 구조 강의들을 수강하였다.각 강의들은 큰 주제를 나누어 섹션별로 구분되어있었는데첫 번째 섹션은 컴퓨터 구조 개론 이였다.이 섹션은 4강의로 나누어 이 강의를 들어야 하는 이유 및 컴퓨터의 역사를 배워보는 시간이였다.어릴 적 어딘가 들어봤던 용어들을 다시 떠올리는 기본 워밍업 느낌의 섹션이였다. 두 번째 섹션은 컴퓨터의 구성 요소!가장 중요한 CPU부터 메모리 및 주변 장치들에 대하여 공부하였고다양한 비트의 컴퓨터의 차이점을 배우며 앞으로 실습하게 될 8bit컴퓨터에 대해서 기본을 알 수 있는 강의였다. 다음 섹션은 불 대수에 대한 섹션이였다.6개의 강의로 나누어져 불 대수에 대해서 공부하는 시간이였는데.대학생때로 돌아가 가물가물한 기억들을 더듬어가며 한강의씩 수강해나갔고.첨부링크에 있는 드모르간 법칙의 정의 사이트로 이동하여 시간이 걸리더라도 하나씩 직접 종이에 써가며해당 정의에 대해 친숙함을 가지려고 하였다. 4번째 섹션은 비트에 대한 섹션이였는데.우리가 흔히 사용하는 10진법부터 2진법, 16진법에 대하여 공부하였고어떠한 숫자를 각 진법에 따라 변환하는 방법을 공부하였다.빅 엔디안 및 리틀 엔디안 방법에 대해서도 알게 되었고, 컴퓨터가 음수를 표현하는 방식에 대해서도 공부하였다. 5번째 섹션은 지금까지 기초를 공부했다면 실습에 돌입하는 섹션이였는데.직접 프로그램을 이용해서 NAND, NOT 등 다양한 회로들을 만들어 볼 수 있는 섹션이였다.프로그램을 처음써보다보니 신기하면서도 이렇게 프로그램으로 회로를 만들어 볼 수 있다는 것이 신기하였다.이번 1주차때는 XOR 게이트까지 직접 만들어보는 강의가 이어졌고 다음 2주차에는 비트별 입력회로를 공부하는 것 같았다. 컴퓨터 구조 강의를 듣고 나서는 자료구조와 알고리즘 강의를 수강하였는데.심화편이란걸 좀 더 미리 알았으면 이 워밍업 클럽이 시작되기전에 미리 기본편을 듣는건데너무 늦게 알아버린 바람에 기본편과 같이 조금씩 듣기로 마음먹었다. 알고리즘 강의의 첫 번째 섹션은 정말 기본적인 준비과정이였다.기본편을 듣지 못한 수강생들을 위해 기본 파일들을 다운받을 수 있었고또한 vs코드 프로그램 설치방법부터 시작할 수 있었다.이제 준비가 끝나고 나면 본강의 시작전 P-NP강의를 시작으로 이제 본격적으로 코스가 시작되는 느낌이였다. 두 번째 섹션은 트리와 이진트리 섹션이였는데기본적인 트리와 이진트리의 개념에 대하여 자세한 강의를 듣고 이제 그걸 직접 코드로 구현해보는 강의였다.처음한번 강의만 틀어서 한번 본뒤에 이제 vscode를 켜고 다시 강의를 따라가면서 하나씩 차근차근코드를 치며 이해를 해보려고 하였다. 세 번째 섹션은 이전 섹션에서 이진트리의 기본 개념을 이해했다~이제 심화를 가자 느낌으로두 가지 개념을 합친 이진 탐색 트리에 대한 개념강의가 이어졌고. 마찬가지로 개념 강의가 끝난 뒤에는 삽입의 구현과 제거의 구현이 이어졌다.역시 저번 섹션처럼 단 한번만 강의를 들어서는 무슨 내용인지 이해하기가 쉽지 않았고최대한 이해하려고 노력하며 이번 섹션을 마무리하였다. 몰아치듯 이어지는 다음 섹션은 AVL 트리!앞 섹션과 마찬가지로 개념설명 -> 구현의 형식으로 강의가 이어졌다.벌써부터 어질어질한걸봐선 다음 2주차 진행하기 전에 3~4섹션에 대해서 다시 복습이 필요할 것 같다 하는 생각이 들었다.기본편을 다 듣고 시작했다면 쉬웠을까? 하는 생각이 들어 다음 2주차 발자국을 작성할때에는 기본편을 마무리하고 작성해야겠다 하는 다짐을 하며 한 주 학습을 마무리하였다. 

알고리즘 · 자료구조인프런워밍업클럽CS컴퓨터구조알고리즘심화편

강동훈

[인프런 워밍업 클럽 4기 - CS] - 1주차 미션 (컴퓨터 구조)

문제1. 4입력 AND, OR, NAND, NOR, XOR 연산의 진리표를 작성해보세요.(3입력 AND게이트의 예)| A | B | C | D | AND | OR | NAND | NOR | XOR | | --- | --- | --- | --- | --- | --- | ---- | --- | --- | | 0 | 0 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | | 1 | 0 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | | 0 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 1 | | 0 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | | 0 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | | 1 | 1 | 0 | 0 | 0 | 1 | 1 | 0 | 0 | | 1 | 0 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | | 1 | 0 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | | 0 | 1 | 1 | 0 | 0 | 1 | 1 | 0 | 0 | | 0 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 0 | | 0 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | 0 | | 1 | 1 | 1 | 0 | 0 | 1 | 1 | 0 | 1 | | 1 | 1 | 0 | 1 | 0 | 1 | 1 | 0 | 1 | | 1 | 0 | 1 | 1 | 0 | 1 | 1 | 0 | 1 | | 0 | 1 | 1 | 1 | 0 | 1 | 1 | 0 | 1 | | 1 | 1 | 1 | 1 | 1 | 1 | 0 | 0 | 0 |AND: 모든 값이 1일 경우에만 1OR: 하나의 값이라도 1이면 1NAND: AND 반대NOR: OR 반대XOR: (((A ⊕ B) ⊕ C) ⊕ D) > 두 입력이 같으면 0, 다르면 1 2.다음 불 방정식들을 여러 방법을 이용해 간략화 해보세요.1. A( (BB)’+ 0A) + (CC)' = (AB’) +C ㄴ A( (B)’+ 0A) + (C)' : 동일 법칙 ㄴ A(B’) + (C)' : 항등원 ㄴ AB’ + C’ 2. (B’B’) + (AD’ + (CA)’)D = B’ + (DC’) + (DA’) ㄴ (B’) + (AD’ + (CA)’)D : 동일 법칙 ㄴ (B’) + (AD’ + C’+ A’)D : 드모르간 법칙 ㄴ B’ + DC’+ DA’: 항등원 3. (A’B) + B(B1 + BC) = B ㄴ (A’B) + B(B + BC): 항등원 ㄴ (A’B) + B(B) : 흡수법칙 ㄴ (A’B) + B: 동일법칙 ㄴ B(A’ + 1): 결합법칙 ㄴ B(1): 항등원 ㄴ B 4. B’(1C + BD) + DB = (B’C) + (DB) ㄴ B’(C + BD) + DB = 항등원 ㄴ B’C + B’BD + DB = 분배법칙 ㄴ B’C + DB = 보완법칙다음 2진수를 10진수로 변환해보세요.1. 110111 = 1 + 2 + 4 + 16 + 32 = 55 2. 10000001 = 1 + 128 = 129 3. 11111100000 = 32 + 64 + 128 +256 + 512 + 1024 = 2016 4. 101010 = 2 + 8 + 32 = 42다음 10진수를 2진수로 변환해보세요.1. 10 = 1010(2) - 10/2 = 5 ...0 - 5/2 = 2...1 - 2/2 = 1...0 - 1/2 = 0...1 2. 27 = 11011(2) - 27/2 = 13...1 - 13/2 = 6...1 - 6/2 = 3...0 - 3/2 = 1...1 - 1/2 = 0...1 3. 86 = 1010110(2) - 86/2 = 43...0 - 43/2 = 21...1 - 21/2 = 10...1 - 10/2 = 5...0 - 5/2 = 2...1 - 2/2 = 1...0 - 1/2= 0...1 4. 516 = 100000100(2) - 516/2 =258...0 - 258/2 = 129...0 - 129/2 = 64...1 - 64/2 = 32...0 - 32/2 = 16...0 - 16/2 = 8...0 - 8/2 = 4...0 - 4/2 = 2...0 - 2/2 = 1...0 - 1/2 = 0...1다음 불 방정식을 logisim을 이용해 회로를 만들어보세요.(회로 이미지와 .circ파일 첨부)1. (B’C) + (DB) 2. (AB’) +C 3. B’ + (DC’) + (DA’) 1. (B’C) + (DB)2. (AB’) +C3. B’ + (DC’) + (DA’)후기불 대수나 불 연산에 대해서 개념을 공부할 때는 크게 와닿지 못하였고 외우기 바빴지만 직접 미션을 통해서 작업해보고 불 대수에서 나온 여러 법칙들이 왜 사용되게 되는지 흐름을 이해할 수 있었다. 또한 직접 프로그램을 통해 회로를 연결해보는 경험이 불 연산을 더 깊이 체감해볼 수 있는 경험이 되었다.

컴퓨터 구조미션컴퓨터구조

강동훈

[인프런 워밍업 클럽 4기 - CS] - 1주차 발자국

📕 자료구조와 알고리즘(심화)✅ P-NP문제가 어려운 지, 쉬운 지 혹은 해결이 가능한 지 불가한 지 판단하는 것.결정 문제: 참 혹은 거짓을 대답할 수 있는 문제최적화 문제: 최적의 해를 찾을 수 있는 문제 (대부분의 최적화 문제는 결정 문제가 된다)결정론적 튜링 머신: 다음 상태가 유일한(오직 하나의) 상태로 결정되는 것비결정론적 튜링 머신: 현재 상태와 기호에 대해 여러 개의 가능한 다음 상태가 존재할 수 있는 것 (현실에는 존재 X 가정으로 상상)다항 시간: 어떤 문제의 해결 시간을 다항식으로 표현이 가능한 것다항 시간 내 1. 상수 시간: O(1) 2. 로그 시간: O(log n) 3. 선형 시간: O(n) 4. 로그-선형 시간: O(nlog n) 5. 다항 시간: O(n^k) 다항 시간 외 1. 지수 시간: O(k^n) 2. 팩토리얼 시간: O(n!) P 문제: 결정문제에 대해 결정론적 튜링 머신을 통해 다항 시간 내에 답을 구할 수 있는 문제NP 문제: 결정문제에 대해 비결정론적 튜링 머신을 사용하여 다항 시간 내에 답을 구할 수 있는 문제NP Hard: 모든 NP문제들을 다항 시간 내에 어떤 문제 A로 환원이 가능한 것NP Complete: NP-Hard이면서 NP에 포함되는 문제결정론적 / 비결정론적 문제ex) 완전 이진 트리 형태로 되어 있고 깊이가 k인 갈림길에 하나의 리프에만 보물이 있다고 가정결정론적: 한 번씩 모든 길을 거쳐서 보물을 확인 > 최악의 경우 2^k의 시간이 걸린다.비결정론적: 갈림길을 마주할 때마다 분신술을 사용하여 동시에 모든 리프 확인 > k의 시간이 걸린다.어떠한 힌트가 주어지게 된다면 비결정론적 문제들은 결정론적 문제로 검증이 가능모든 결정론적 문제들은 비결정론적 문제들에 속함 (P⊆NP) ✅ 트리와 이진 트리트리: 하나의 노드에서 점차 내려가는 자료구조Edge: 각 노드를 연결하는 선루트 노드: 트리에서 최상위 노드터미널 노드: 자식 노드가 없는 노드인터널 노드: 터미널 노드를 제외한 노드서브 트리: 트리 구조 내에 작은 트리 (터미널 노드 또한 루트 노드만 있는 트리라고 판단)레벨: 각트리의 높이이진 트리: 각 노드는 최대 2개의 자식 노드를 갖는 트리포화 이진 트리: 트리의 최대 레벨에 있는 모든 터미널 노드가 꽉 찬 트리완전 이진 트리: 최대 레벨을 제외한 나머지 레벨에는 모두 노드가 존재하고 최대 레벨의 노드는 왼쪽부터 채워진 트리순회: 트리의 노드들을 순회전위: 루트 노드 먼저 순회중위: 루트 노드를 중간에 순회후위: 루트 노드를 마지막에 순회 ✅ 이진 탐색 트리이진 탐색 알고리즘: 정렬되어 있는 배열에서 반씩 나눠 탐색을 해가며 범위를 줄여나가는 알고리즘이진 탐색 트리이진 탐색은 정렬된 상태에서만 가능하며 배열의 경우 데이터 삽입, 삭제가 비효율적이다.해시 테이블은 데이터 조회, 삽입, 제거가 빠르지만 해시 함수에 따라 성능이 달라지고 데이터를 저장할 메모리가 필요하다.이진 탐색 테이블은 데이터 조회, 삽입, 제거가 빠르고 해시 테이블에 비해 메모리 사용량이 적다규칙자식 노드는 모두 이진 트리여야 한다.중복된 노드의 데이터는 없어야 한다.A 노드의 왼쪽 자식 노드값은 A 노드값보다 작아야 한다.A 노드의 오른쪽 자식 노드값은 A 노드값보다 커야 한다.자식 트리도 상위 규칙을 따라야 한다.평가:트리가 만들어졌을 때 : O(logn)트리가 잘 만들어지지 않을 때 : O(n)이진 트리는 균형을 유지하는 것이 성능에 중요삽입, 삭제 시 트리의 균형이 깨질 가능성이 크다.✅ AVL 트리이진 트리에서는 균형을 유지하는 것이 중요하다.규칙:왼쪽과 오른쪽 자식트리의 높이가 최대 1까지만 차이가 날 수 있다.균형이 맞지 않는 트리는 회전을 통해 균형을 다시 맞출 수 있다.(못 맞추는 경우도 존재)회전LL회전: 오른쪽으로 뻗은 트리에 대해 적용 가능RR회전: 왼쪽으로 뻗은 트리에 대해 적용 가능LR회전: 왼쪽으로 꺾였다가 안쪽으로 꺾인 트리 적용 가능RL회전: 오른쪽으로 꺾였다가 안쪽으로 꺾인 트리 적용 가능📕 컴퓨터 구조✅ 컴퓨터 구조블랙박스: 내부 작동 원리는 모르더라도 입력에 따라 출력이 예측 가능한 것들모듈화: 큰 문제를 작은 문제로 분할하여 복잡함을 단순화 시키는 방법역사:수동식 계산기- 주판기계식 계산기- 계산봉, 파스칼린, 라이프니츠 휠자동 계산기- 차분 기관(톱니바퀴로 계산 결과 활용), 해석 기관(프로그래밍 가능)디지털 계산기- ENIAC- 폰노이만 구조(중앙 처리 장치, 메모리, 입출력 장치)- 트랜지스터 (진공관 대체)- 집척 회로- ,,, 동작방식컴퓨터는 0,1로 이루어진 명령어만 해석이 가능하다.기계어: 0,1로 이루어진 명령어컴파일러: 정적 코드를 기계어로 변환하는 과정에서 에러 발견 가능하고 실행속도가 매우 빠름 (c, C++) / 변환 과정이 오래 걸림인터프리터: 한 줄씩 기계어로 변환하기에 프로그램 실행 도중 문법 오류 발생 가능, 실행 속도가 느림✅ 컴퓨터 구성 요소CPU:프로그램 카운터: 다음 실행할 명령어 저장제어 유닛: 명령어 해석 및 실행산술 논리 연산장치: 산술, 논리 연산을 수행레지스터: 용량은 적지만 속도가 빠른 CPU 내장 메모리버스: 데이터 전송 통로Memory:RAM(Random Access Memory): 어떤 메모리에 접근하여도 접근 시간이 동일하며 휘발성ROM(Read Only Memory): 쓰기가 불가하며 비휘발성이기 때문에 컴퓨터 동작을 위한 BIOS가 저장  1. CPU가 프로그램 실행 시, 코드와 데이터를 RAM에서 가져온다. 2. 연산에 필요한 데이터 레지스터 저장 3. 연산 이후 결과를 RAM에 저장 4. 자주 사용되는 데이터 CPU 내부에 캐시 메모리 저장 (< 레지스터) / > RAM) 주변 장치:입출력 장치1. 키보드 / 마우스2. 모니터 / 스피커 / 프린터보조기억 장치1. HDD / SSD32, 64bit 컴퓨터:1bit (0,1 표현) = 21byte = 8bit = 2564byte = 32bit = 약 42억8byte = 64bit = 약 18경플리플롭: 1비트를 저장할 수 있는 회로컴퓨터 비트에 맞춰서 레지스터와 버스의 비트 수가 맞춰짐- 64비트 -> 64비트 레지스터 / 64개의 버스비트 수에 따라 저장할 수 있는, 계산할 수 있는 한계가 정해짐RAM이 여러개를 갖고 있더라도 CPU에서 처리할 수 있는 한계가 있음컴퓨터의 성능은 클럭, 명령어 최적화, 메모리, 레지스터 속도가 중요✅ 불 대수디지털 장치들은 불 대수 기반으로 작동한다.true: 1false: 0 불 연산:NOT: 입력값의 반대AND: A와 B가 같을 때만 1 (논리곱)OR: A와 B중 하나만 1이면 1 (논리합)NAND: AND 연산의 반대NOR: 하나라도 1이면 1XOR: 하나만 1일 경우에만 1 (두 입력이 다를 때)불 대수의 성질과 법칙항등원:원산 결과가 자기 자신이 되는 수AND (⋅) / A ⋅ 1 = AOR (+) / A + 0 = A교환법칙: 피연산자의 순서를 바꿔도 결과는 동일하다A ⋅ B = B ⋅ A결합법칙: 괄호의 위치를 바꿔도 결과 동일(A ⋅ B) ⋅ C = A ⋅ (B ⋅ C)분배법칙A ⋅ (B + C) = A⋅B + A⋅C동일법칙: 동일한 값을 두 번 연산해도 원래 값A ⋅ A = A이중 부정법칙: 두 번 부정하면 원래 값으로 돌아감흡수법칙A(A + B)= AA + AB ← 분배법칙= A + AB ← AA = A (동일법칙)= A(1 + B). ← A로 묶음 (결합법칙의 역)= A(1) ← 1 + B = 1 (항등원)= A 드모르간 법칙AND = NOT A OR NOT BA NOR B = NOT A AND NOT B불 함수함수: 입력 값에 따라 출력 값이 변하는 것불함수: 입력 값과 출력 값 모두 boolean 진리표 변환결과가 0인 행은 제외(Don't care 행)모든 행을 AND 연산으로 만들고결과값에 맞춰서 수정✅ 비트10진법과 2진법1개의 비트로 표현할 수 있는 수의 개수 = 2^1개2개의 비트로 표현할 수 있는 수의 개수 = 2^2개3개의 비트로 표현할 수 있는 수의 개수 = 2^3개,,, 10진법 > 2진법 변환10진수를 2로 나눌 수 있을 때까지 나누는 것ex) 9 > 9/2 = 4...1 > 4/2 > 2...0 > 2/2 > 1...09(10) = 1001(2) 16진법0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F16진법을 사용하는 이유는 2진수를 10진법으로 표현하는 것보다 더 간단하기 때문16은 2^4이기 때문에 간단히 변환 가능11111111(2) = FF(16)Ox1001 => 16진수 표기법 빅 엔디안과 리틀 엔디안MSB: 가장 왼쪽 비트LSB: 가장 오른쪽 비트 빅 엔디안: MSB를 가장 낮은 주소부터 채우는 방식리틀 엔디안: LSB를 가장 낮은 주소부터 채우는 방식하나의 방식으로 통일해서 사용해야 함. 오버플로우와 인터럽트오버플로우: 값이 데이터 타입(또는 레지스터)이 표현할 수 있는 범위를 초과했을 때 발생하는 현상인터럽트: CPU가 실행 중인 작업을 중단하고 인터럽트 서비스를 실행 음수- 부호없는 정수 (양수만 표현 가능)0000 ~ 1111 = 0 ~ 15까지 16개 값 표현- 부호있는 정수 (양수, 음수 표현 가능)0000 ~ 1111 = -8 ~ 7까지 16개 값 표현MSB가 부호를 표현(0이면 양수, 1이면 음수) > 나머지 3비트로만 값 표현 가능예: +5 → 00000101 (8비트 기준)음수 표현 만들기 (예: -5)① 비트를 반전 (1의 보수): 11111010② +1 더함: 11111010 + 1 = 11111011 00000101 ( +5 ) + 11111011 ( -5 ) ----------- 00000000 → 결과: 0 후기직접 프로그램을 통해 불 연산을 시각화해볼 수 있다는 것이 가장 인상깊었다. 기존에는 논리 연산을 통해서 조건문을 작성할 때를 제외하고는 생각해본 적이 없었는데, 더 하위 레벨에서 불대수, 불함수, 그리고 불 연산에서 자주 사용되는 수학적인 법칙까지 직접 공부해보고 이를 통해 간단한 프로그램을 만들어 보는 경험이 어렵지 않으면서 가장 크게 체감을 할 수 있었던 것 같다.  자료구조와 알고리즘 또한 트리가 나오게된 배경부터 AVL 트리가 탄생하게 된 계기까지 그 흐름을 잘 따라갈 수 있었고 AVL 트리만의 특징과 균형을 잡기 위한 여러 회전 원리에 대해서도 탄탄히 공부해볼 수 있었다.

컴퓨터 구조컴퓨터구조감자CS

고차원정신줄

인프런 워밍업 클럽 4기 CS - 1주차 발자국

컴퓨터 구성 요소CPU (Central Processing Unit): 컴퓨터의 뇌라고 할 수 있습니다. 모든 계산과 데이터 처리를 담당하며, 프로그램의 명령어를 실행합니다.메모리 (Memory): CPU가 작업을 처리하는 데 필요한 데이터를 임시로 저장하는 공간입니다. 주로 RAM(Random Access Memory)을 의미하며, 전원이 꺼지면 내용이 사라지는 휘발성 메모리입니다.주변 장치 (Peripherals): 컴퓨터와 정보를 주고받는 외부 장치들을 말합니다.입력 장치: 키보드, 마우스, 스캐너처럼 컴퓨터에 정보를 입력하는 장치입니다.출력 장치: 모니터, 프린터, 스피커처럼 컴퓨터가 처리한 정보를 보여주거나 내보내는 장치입니다.저장 장치: 하드 디스크 드라이브(HDD), 솔리드 스테이트 드라이브(SSD), USB 메모리처럼 데이터를 영구적으로 저장하는 장치입니다. 비트와 데이터 표현비트 (Bit): 컴퓨터가 정보를 표현하는 가장 작은 단위입니다. 0 또는 1의 두 가지 값만 가질 수 있습니다. 스위치의 ON/OFF처럼 생각할 수 있습니다.10진법, 2진법, 16진법:10진법 (Decimal): 우리가 일상생활에서 사용하는 숫자 체계입니다. 0부터 9까지 10개의 숫자를 사용합니다.2진법 (Binary): 컴퓨터가 사용하는 숫자 체계입니다. 0과 1 두 가지 숫자만 사용하여 모든 수를 표현합니다. 비트는 2진법의 한 자리를 의미합니다.16진법 (Hexadecimal): 0부터 9까지의 숫자와 A부터 F까지의 알파벳을 사용하여 16개의 숫자를 표현하는 체계입니다. 2진수를 간결하게 표현하기 위해 사용됩니다. 예를 들어, 2진수 1111은 16진수 F와 같습니다.빅 엔디안 (Big-Endian), 리틀 엔디안 (Little-Endian): 컴퓨터 메모리에 여러 바이트로 이루어진 데이터를 저장하는 방식입니다.빅 엔디안: 데이터의 가장 큰(빅) 자리부터 메모리에 저장하는 방식입니다. (예: 1234를 저장할 때 12-34 순)리틀 엔디안: 데이터의 가장 작은(리틀) 자리부터 메모리에 저장하는 방식입니다. (예: 1234를 저장할 때 34-12 순)LSB (Least Significant Bit), MSB (Most Significant Bit):LSB: 이진수에서 가장 낮은 자리의 비트입니다. 10진수의 일의 자리와 같습니다. (예: 1011에서 가장 오른쪽 1)MSB: 이진수에서 가장 높은 자리의 비트입니다. 숫자의 부호나 크기를 결정하는 중요한 비트입니다. (예: 1011에서 가장 왼쪽 1)오버플로우 (Overflow): 특정 비트 수로 표현할 수 있는 숫자의 범위를 넘어섰을 때 발생하는 현상입니다. 예를 들어, 4비트로 15까지 표현할 수 있는데 16을 표현하려 할 때 오버플로우가 발생합니다.인터럽트 (Interrupt): CPU가 어떤 작업을 처리하는 도중에 급하게 처리해야 할 일이 생겼을 때, 현재 작업을 잠시 멈추고 그 일을 먼저 처리하도록 알리는 신호입니다. 음수와 2의 보수음수 표현: 컴퓨터는 0과 1만으로 음수를 표현해야 합니다. 여러 방법이 있지만, 가장 널리 사용되는 방법은 2의 보수(Two's Complement)를 이용하는 것입니다.2의 보수 + 1로 치환: 어떤 양수 X에 대한 2의 보수는 모든 비트를 반전시킨 후 1을 더한 값입니다. 이 2의 보수 표현을 사용하면 뺄셈 연산을 덧셈 연산으로 편리하게 처리할 수 있습니다.예: 5−3을 5+(−3)으로 계산할 때, −3을 2의 보수로 표현하여 덧셈을 수행합니다. 불 대수와 논리 연산불 대수 (Boolean Algebra): 조지 불이 창시한 수학적 체계로, 논리적인 참(1)과 거짓(0)을 다루는 대수입니다. 컴퓨터의 모든 논리 회로는 불 대수를 기반으로 설계됩니다.연산:AND (논리곱): 두 입력이 모두 1일 때만 결과가 1입니다. (A AND B = A ⋅ B)OR (논리합): 두 입력 중 하나라도 1이면 결과가 1입니다. (A OR B = A + B)NOT (논리 부정): 입력이 1이면 0, 0이면 1로 반전시킵니다. (Aˉ)성질과 법칙: 불 대수에는 연산을 간단하게 할 수 있는 여러 법칙이 있습니다.교환법칙 (Commutative Law): A⋅B=B⋅A, A+B=B+A (순서를 바꿔도 결과는 같음)결합법칙 (Associative Law): (A⋅B)⋅C=A⋅(B⋅C), (A+B)+C=A+(B+C) (묶는 순서를 바꿔도 결과는 같음)분배법칙 (Distributive Law): A⋅(B+C)=A⋅B+A⋅C, A+(B⋅C)=(A+B)⋅(A+C) (괄호 안의 연산을 분배하여 계산)흡수법칙 (Absorption Law): A+(A⋅B)=A, A⋅(A+B)=A (특정 항이 다른 항을 흡수)드모르간의 법칙 (De Morgan's Law): A⋅B=A+B, A+B​=A⋅B (논리 연산의 부정을 분리)불 함수 (Boolean Function): 불 변수들을 사용하여 논리 연산으로 표현되는 함수입니다. 컴퓨터 회로의 동작을 수학적으로 표현합니다.카르노 맵 (Karnaugh Map): 불 함수를 간소화하는 시각적인 도구입니다. 복잡한 논리식을 직관적으로 정리하여 더 간단한 논리 회로를 설계할 수 있도록 돕습니다. 자료구조 & 알고리즘P-NP 문제P-NP 문제: 컴퓨터 과학의 가장 큰 미해결 문제 중 하나입니다.P (Polynomial time) 문제: 주어진 답이 올바른지 검증하는 데 걸리는 시간과 해결하는 데 걸리는 시간이 모두 효율적인(다항 시간) 문제입니다.NP (Non-deterministic Polynomial time) 문제: 주어진 답이 올바른지 검증하는 데 걸리는 시간은 효율적이지만, 해결하는 데 걸리는 시간은 비효율적일 수 있는 문제입니다.P = NP 인가? 라는 질문은 "해답을 빠르게 확인할 수 있는 모든 문제가 해답을 빠르게 찾을 수 있는 문제인가?"를 묻는 것입니다.트리 (Tree)트리: 나무처럼 가지를 뻗어나가는 형태의 자료구조입니다.계층 구조를 표현하기에 적합: 파일 시스템(폴더 안에 폴더, 파일), 조직도(사장 아래 부서장, 사원)처럼 상하 관계가 있는 데이터를 표현하는 데 아주 유용합니다.이진 트리 (Binary Tree): 각각의 노드가 최대 2개의 자식 노드(왼쪽 자식, 오른쪽 자식)를 가질 수 있는 트리입니다.성능:조회: 최악의 경우 O(n) (모든 노드를 탐색해야 함), 평균 및 최적의 경우 O(logn) (트리의 높이에 비례하여 빠르게 탐색 가능)종류:완전 이진 트리 (Complete Binary Tree): 마지막 레벨을 제외하고 모든 레벨이 완전히 채워져 있으며, 마지막 레벨은 왼쪽부터 채워지는 트리입니다.포화 이진 트리 (Full Binary Tree): 모든 노드가 0개 또는 2개의 자식 노드를 가지는 트리입니다.AVL 트리 (Adelson-Velsky and Landis Tree): 스스로 균형을 잡는(self-balancing) 이진 탐색 트리입니다. 좌우 서브트리의 높이 차이가 1을 넘지 않도록 자동으로 노드를 재배치하여 트리의 균형을 유지합니다. 이를 통해 탐색, 삽입, 삭제 시 항상 O(logn)의 시간 복잡도를 보장합니다.회전 (Rotation): AVL 트리가 균형을 맞추기 위해 사용하는 방법입니다. 불균형이 발생하면 노드의 위치를 회전시켜 높이를 조절합니다.RR 회전 (Right-Right Rotation): 오른쪽 자식 노드가 오른쪽에 추가되어 불균형이 발생할 때 왼쪽으로 회전LL 회전 (Left-Left Rotation): 왼쪽 자식 노드가 왼쪽에 추가되어 불균형이 발생할 때 오른쪽으로 회전RL 회전 (Right-Left Rotation): 오른쪽 자식 노드의 왼쪽 자식 노드가 추가되어 불균형이 발생할 때 오른쪽-왼쪽으로 두 번 회전LR 회전 (Left-Right Rotation): 왼쪽 자식 노드의 오른쪽 자식 노드가 추가되어 불균형이 발생할 때 왼쪽-오른쪽으로 두 번 회전

컴퓨터구조자료구조알고리즘

suover

인프런 워밍업 클럽 스터디 4기 - CS 전공지식 1주차 발자국

그림으로 쉽게 배우는 자료구조와 알고리즘 (심화편)만들면서 쉽게 배우는 컴퓨터 구조강의와 함께한 인프런 워밍업 클럽 스터디 4기 - CS 전공지식 (자료구조, 알고리즘, 컴퓨터구조)1주차 발자국 입니다.학습 내용 요약이번 주에는 두 가지 강의를 통해 자료구조·알고리즘과 컴퓨터 구조의 큰 틀을 살펴보며, 이론과 실습을 병행했습니다.그림으로 쉽게 배우는 자료구조와 알고리즘 (심화편)크게 트리 구조와 이진 탐색 트리(BST), 그리고 그 위에 균형을 더한 AVL 트리를 다뤘습니다.초반에는 "트리와 이진 트리 개념"으로 부모·자식 노드 간 관계를 복습했고, 이어서 BST의 삽입·검색·삭제 과정을 훑어보았습니다.마지막으로 AVL 트리 개념과 구현(보조 함수, 삽입, 삭제)을 익히며, "왜 균형 인자가 중요한지"와 "삽입/삭제 후 어떻게 회전으로 높이를 조정하는지"를 이해했습니다.만들면서 쉽게 배우는 컴퓨터 구조컴퓨터 구조 전반(블랙박스 관점, CPU·메모리·주변 장치)과 함께, 불 대수 및 논리 게이트 설계로 넘어가 간단한 하드웨어 시뮬레이션을 해보았습니다.먼저 "컴퓨터 구조를 배우는 이유"와 명령어가 메모리→CPU→다시 메모리로 흐르는 과정을 개념적으로 파악했고, CPU 내부와 메모리 계층도 간단히 살펴봤습니다.이어서 불 대수 기본 연산과 성질을 학습한 뒤, 직접 Logisim을 설치해 NAND/NOT/AND/OR/XOR 게이트를 조합해 보는 실습을 경험했습니다.또 10진수↔2진수 변환, 16진법, 빅·리틀 엔디안, 2의 보수 음수 표현 같은 비트 단위 개념을 짚으며, 디지털 회로의 밑바탕이 되는 이진 표현 방식을 정리했습니다.미션🎯 자료구조·알고리즘 미션1: GarbageCollector 클래스 구현목표: AVL 트리로 빈 메모리 블록을 관리해, 요청 크기와 정확히 일치하는 블록이나 그보다 큰 값 중 최소값을 찾아 반환·삭제하도록 한다.코드import { AVLTree } from "../../avlTree/avlTree.mjs"; class GabageCollector { constructor() { this.avlTree = new AVLTree(); } // 빈 메모리 블록 삽입 insertFreeMemory(size) { this.avlTree.root = this.avlTree.insert(this.avlTree.root, size); } // 요청 크기 이상인 블록 검색 searchFreeMemory(requestSize) { let current = this.avlTree.root; let candidate = null; while (current) { const nodeSize = current.getData(); if (nodeSize === requestSize) { // 정확히 같은 크기를 찾으면 즉시 반환 candidate = current; break; } if (nodeSize > requestSize) { // 후보로 저장한 뒤, 더 작은 후보를 찾기 위해 왼쪽 서브트리 탐색 candidate = current; current = current.getLeftSubTree(); } else { current = current.getRightSubTree(); } } return candidate; } // 반환된 블록(크기) 삭제 releaseFreeMemory(size) { this.avlTree.root = this.avlTree.remove(this.avlTree.root, size); } } // 실행 const gc = new GabageCollector(); console.log("========== 빈 메모리 영역 초기화 =========="); gc.insertFreeMemory(64); // 빈 64바이트 삽입 gc.insertFreeMemory(48); // 빈 48바이트 삽입 gc.insertFreeMemory(87); // 빈 87바이트 삽입 gc.insertFreeMemory(13); // 빈 13바이트 삽입 gc.insertFreeMemory(102); // 빈 102바이트 삽입 gc.insertFreeMemory(34); // 빈 34바이트 삽입 gc.insertFreeMemory(61); // 빈 61바이트 삽입 gc.insertFreeMemory(40); // 빈 40바이트 삽입 gc.insertFreeMemory(6); // 빈 6바이트 삽입 let freeMemory1 = gc.searchFreeMemory(64); // 64바이트 메모리 console.log(freeMemory1); if (freeMemory1) { gc.releaseFreeMemory(freeMemory1.data); } let freeMemory2 = gc.searchFreeMemory(42); // 48바이트 메모리 획득 console.log(freeMemory2); if (freeMemory2) { gc.releaseFreeMemory(freeMemory2.data); }실행 요약const gc = new GarbageCollector(); 빈 블록 [64, 48, 87, 13, 102, 34, 61, 40, 6]을 insertFreeMemory(...)로 순차 삽입 searchFreeMemory(64) → 정확히 64 노드를 찾아 반환 → releaseFreeMemory(64) 삭제 searchFreeMemory(42) → 42와 동일한 값이 없어 “42보다 큰 값 중 최소(48)” 반환 → releaseFreeMemory(48) 삭제 회고AVL 트리의 삽입·삭제 시 "LL·RR·LR·RL 회전"이 실제로 동작하는 것을 확인하며, 균형 인자의 중요성을 체감했습니다. 삽입, 삭제, 검색이 모두 로그 시간에 동작하기 때문에, 빈 메모리 블록이 많아질 때도 성능을 보장할 수 있다는 점을 체감했습니다. "정확히 같은 크기가 없을 때, 그보다 큰 값 중 최소값을 찾는 후보(candidate)" 로직을 루트부터 내려가며 올바르게 업데이트해야 합니다.    🔗자료구조·알고리즘 미션1 블로그 링크🎯 컴퓨터 구조 미션1 (총 5개)미션 1. 4입력 논리 연산 진리표 작성내용: 4개의 입력(A, B, C, D)에 대한 AND, OR, NAND, NOR, XOR 진리표를 총 16조합으로 작성실행A B C D를 0000 → 0001 → … → 1111 순서로 나열 각 연산(AND, OR, NAND, NOR, XOR)의 출력(Q)을 직접 채워 넣음느낀 점2진수 순서대로 입력 조합을 정리하니 빠짐없이 작성할 수 있었고, XOR처럼 "1 개수 홀짝 판정" 연산은 중간에 헷갈려도 정리 순서를 엄수하면 실수를 줄일 수 있었다.미션 2. 불 방정식 간략화내용: 아래 네 개의 불 방정식을 단계별로 법칙(아이디엠포턴트, 드모르간, 흡수 등)을 적용해 간략화했다.A( (BB)’ + 0A) + (CC)’ = (AB’) + C’ (B’B’) + (AD’ + (CA)’)D = B’ + (DC’) + (DA’) (A’B) + B(B1 + BC) = B B’(1C + BD) + DB = (B’C) + (DB) 느낀 점드모르간·흡수법칙을 차례로 적용하며 "복잡해 보이던 식이 단번에 간결해지는 과정"이 인상적이었다.단계별로 어떤 법칙을 먼저 적용해야 가장 효율적으로 축약되는지 아직 직관이 부족해, 다음주엔 다양한 예제를 풀어 보며 연습할 예정이다.미션 3. 2진수를 10진수로 변환내용: 다음 네 개의 2진수를 10진수로 바꿔 보았다.110111₂ = 55₁₀ 10000001₂ = 129₁₀ 11111100000₂ = 2016₁₀ 101010₂ = 42₁₀실행 각 2진수를 우측 끝 비트부터 자리값(2⁰, 2¹, 2², …)을 곱해 합산 예: 11111100000₂ = 1·2¹⁰ + 1·2⁹ + … + 1·2⁵ + 0·… = 1024 + 512 + 256 + 128 + 64 + 32 = 2016느낀 점자릿값을 일일이 계산하는 것은 번거롭지만, "가장 큰 2의 거듭제곱부터 차례로 빼 나가는 방식"으로 익히니 긴 이진수도 비교적 빠르게 변환할 수 있었다.미션 4. 10진수를 2진수로 변환내용: 다음 네 개의 10진수를 2진수로 바꿔 보았다.10₁₀ = 1010₂ 27₁₀ = 11011₂ 86₁₀ = 1010110₂ 516₁₀ = 1000000100₂실행 나눗셈→나머지 반복: 예를 들어 86 ÷ 2 = 43, 나머지 0 → 43 ÷ 2 = 21, 나머지 1 → … → 최종 이진수 역순 또는 "가장 큰 2의 거듭제곱(2⁶=64)부터 빼 나가기" 방식으로 빠르게 도출느낀 점처음엔 헷갈렸지만, "2ⁿ 이하 최대값을 찾아서 빼고, 나머지로 또 반복"하는 방식이 머릿속에 각인되자 더 긴 수도 금방 변환할 수 있었다.미션 5. 불 방정식을 Logisim으로 회로 구현내용: 불 방정식을 logisim을 이용해 회로 만들기 실행(B′·C) + (D·B)B → NOT → B′AND1: (B′, C)AND2: (D, B)OR: (AND1, AND2) → 출력(A·B′) + CB → NOT → B′AND: (A, B′)OR: (AND, C) → 출력B′ + (D·C′) + (D·A′)B → NOT → B′ (첫 OR 입력)C → NOT → C′, A → NOT → A′AND1: (D, C′)AND2: (D, A′)OR( B′, AND1, AND2 ) → 출력대표 입력별 검증(B′·C)+(D·B) → B=0,C=1,D=0 → OUT=1, B=1,C=0,D=1 → OUT=1, B=1,C=1,D=0 → OUT=0(A·B′)+C → A=0,B=0,C=1 → OUT=1, A=1,B=1,C=0 → OUT=0B′+(D·C′)+(D·A′) → A=0,B=0,C=0,D=0 → OUT=1, A=1,B=1,C=0,D=1 → OUT=1느낀 점Logisim을 통해 "진리표상의 연산이 실제 게이트 단위 회로에서 어떻게 동작하는지"를 직접 눈으로 확인할 수 있었다.회로가 복잡해질수록 배선이 겹치는 문제가 있었으나, 다음에는 모듈 단위(예: (B′·C) 회로 → (D·B) 회로 → OR)로 나눠서 단계별로 검증하려 한다. 🔗컴퓨터 구조 미션1 블로그 링크회고이번 주에는 AVL 트리와 논리 회로 설계를 함께 학습했습니다.AVL 트리 구현: 삽입·삭제 시 LL·RR·LR·RL 회전을 거쳐 균형을 유지하는 과정을 직접 코드로 확인했습니다. "정확히 같은 값이 없으면 그보다 큰 값 중 최소값을 찾는 로직"을 구현하면서, 균형 인자를 어떻게 업데이트해야 하는지 확실히 알게 되었습니다.논리 회로 설계: 4입력 진리표 작성부터 불 방정식 간략화, Logisim 회로 구성까지 순서대로 진행했습니다. 직접 회로를 만들어 입력을 바꿔 볼 때마다 결과가 즉시 바뀌는 모습을 보면서, 이론이 실제 게이트 동작으로 이어진다는 점이 와닿았습니다.스스로 칭찬하는 점이론과 실습 병행AVL 트리 코드와 Logisim 회로를 동시에 구현하며, 배운 내용을 손으로 직접 확인한 점이 좋았습니다.진리표 정리법 습득2진수 순서대로 진리표를 빠짐없이 작성하면서, 체계적인 정리 방법을 제대로 익혔습니다.아쉬웠던 점 & 보완회로 배선 정리 부족Logisim에서 선이 겹치다 보니 가끔 헷갈렸습니다.→ 다음에는 작은 모듈로 나눠 단계별로 검증하고, 마지막에 합치는 방식을 사용하겠습니다. 개념 정리 자료 부족AVL 트리나 불 대수 법칙을 공부할 때, 머릿속으로만 이해하고 따로 요약해 두지 않아 복습할 때 헷갈리는 부분이 있었습니다.→ 학습 중에는 핵심 개념을 노트에 간단히 정리하여, 부족한 부분을 바로 찾아볼 수 있도록 하겠습니다.마치며이번 주차는 이론을 코드와 회로로 연결해 보는 경험을 했습니다. 다음 주에도 부족했던 부분을 보완하며 차근차근 학습을 이어가겠습니다! 감사합니다!

알고리즘 · 자료구조인프런워밍업클럽스터디CS전공지식자료구조컴퓨터구조발자국회고4기

H_dong

인프런 워밍업 클럽 4기 CS 전공지식 1주차 미션

컴퓨터 구조 1. 4입력 AND, OR, NAND, NOR, XOR 연산의 진리표를 작성해보세요.XOR은 1의 개수가 홀수일 때 1, 짝수일 때 02. 다음 불 방정식들을 여러 방법을 이용해 간략화 해보세요. A( (BB)’+ 0A) + (CC)' = (AB’) +CA( (B)' + 0) + (C)' = (AB') + CA(B') + C' = (AB') + CAB' + C' = AB' + C   (B’B’) + (AD’ + (CA)’)D = B’ + (DC’) + (DA’)(B') + AD'D + (CA)'D = B' + (DC') + (DA')B' + A0 + (CA)'D = B' + (DC') + (DA')B' + (CA)'D = B' + (DC') + (DA')B' + (C' + A')D = B' + (DC') + (DA')B' + C'D + A'D = B' + DC' + DA'  (A’B) + B(B1 + BC) = B(A’B) + B(B + BC) = B(A’B) + BB + BBC = B(A’B) + B + BC = B(A’B) + B = BA’B + B = BB = B   B’(1C + BD) + DB = (B’C) + (DB)B’(C + BD) + DB = (B’C) + DBB’C + B’BD + DB = B’C + DBB’C + 0D + DB = B’C + DBB’C + DB = B’C + DB3. 다음 2진수를 10진수로 변환해보세요.110111 =→ 1×2⁵ + 1×2⁴ + 0×2³ + 1×2² + 1×2¹ + 1×2⁰→ 32 + 16 + 0 + 4 + 2 + 1 = 5510000001 =→ 1×2⁷ + 0×2⁶ + … + 0×2¹ + 1×2⁰→ 128 + 0 + 0 + 0 + 0 + 0 + 0 + 1 = 12911111100000 =→ 1×2¹⁰ + 1×2⁹ + 1×2⁸ + 1×2⁷ + 1×2⁶ + 1×2⁵ + 0×2⁴ + … + 0×2⁰→ 1024 + 512 + 256 + 128 + 64 + 32 = 2016101010 =→ 1×2⁵ + 0×2⁴ + 1×2³ + 0×2² + 1×2¹ + 0×2⁰→ 32 + 0 + 8 + 0 + 2 + 0 = 42다음 10진수를 2진수로 변환해보세요.1. 10 = 101010 ÷ 2 = 5 → 나머지 05 ÷ 2 = 2 → 나머지 12 ÷ 2 = 1 → 나머지 01 ÷ 2 = 0 → 나머지 1 2. 27 = 1101127 ÷ 2 = 13 → 나머지 113 ÷ 2 = 6 → 나머지 16 ÷ 2 = 3 → 나머지 03 ÷ 2 = 1 → 나머지 11 ÷ 2 = 0 → 나머지 1 3. 86 = 101011086 ÷ 2 = 43 → 나머지 043 ÷ 2 = 21 → 나머지 121 ÷ 2 = 10 → 나머지 110 ÷ 2 = 5 → 나머지 05 ÷ 2 = 2 → 나머지 12 ÷ 2 = 1 → 나머지 01 ÷ 2 = 0 → 나머지 1 4. 516 = 1000000100516 ÷ 2 = 258 → 나머지 0258 ÷ 2 = 129 → 나머지 0129 ÷ 2 = 64 → 나머지 164 ÷ 2 = 32 → 나머지 032 ÷ 2 = 16 → 나머지 016 ÷ 2 = 8 → 나머지 08 ÷ 2 = 4 → 나머지 04 ÷ 2 = 2 → 나머지 02 ÷ 2 = 1 → 나머지 01 ÷ 2 = 0 → 나머지 1 5. 다음 불 방정식을 logisim을 이용해 회로를 만들어보세요.circ파일링크1.(B’C) + (DB)2.(AB’) +C3.B’ + (DC’) + (DA’)자료구조와 알고리즘문제Python, JavaScript, C# 같은 언어는 가비지 컬렉터를 이용해 메모리를 자동으로 정리하는 매니지드 언어(Managed Language)에 속합니다. 매니지드 언어의 가비지 컬렉터는 개발자가 메모리를 요청하면 운영체제의 힙 영역에 할당하고, 더 이상 필요하지 않을 때 자동으로 해제하며 메모리를 관리합니다. 여러분이 속한 회사에서 새로운 매니지드 언어를 개발 중이며, 여러분은 가비지 컬렉터 개발을 담당하게 되었습니다. 특히 메모리 검색 부분을 맡게 되었는데, 사용자가 특정 크기(Byte)의 메모리를 요청하면 사용 가능한 메모리 중 가장 적절한 크기를 찾아 반환하는 GarbageCollector 클래스를 구현해보세요.(같은 크기의 메모리는 없다고 가정) 풀이내가 만든 AVLTree를 이용해서 풀어보았다key와 같거나 큰 값 중 가장 작은 노드를 찾아야 함예: key = 42, 트리에 {6, 13, 34, 40, 48, 61, ...}이 있다면 → 48 반환해야 함GarbageCollector.cpp#include "AVLTree.h" class GarbageCollector { public: void insertFreeMemory(int size) { tree.Insert(size); } void releaseFreeMemory(int size) { tree.Remove(size); } int searchFreeMemory(int size) { AVLTree::Node* node = tree.GetRoot(); AVLTree::Node* result = nullptr; while (node) { if (node->key == size) return node->key; if (node->key > size) { result = node; node = node->left; } else { node = node->right; } } return result ? result->key : -1; } void printFreeMemory() { tree.printTree(); } private: AVLTree tree; };출력 결과int main() { GarbageCollector gc; cout << "========== 빈 메모리 영역 초기화 ==========\n"; gc.insertFreeMemory(64); gc.insertFreeMemory(48); gc.insertFreeMemory(87); gc.insertFreeMemory(13); gc.insertFreeMemory(102); gc.insertFreeMemory(34); gc.insertFreeMemory(61); gc.insertFreeMemory(40); gc.insertFreeMemory(6); gc.printFreeMemory(); cout << "\n========== 메모리 요청: 64 ==========" << endl; int m1 = gc.searchFreeMemory(64); if (m1 != -1) { cout << "획득한 메모리: " << m1 << endl; gc.releaseFreeMemory(m1); } cout << "\n========== 메모리 요청: 42 ==========" << endl; int m2 = gc.searchFreeMemory(42); if (m2 != -1) { cout << "획득한 메모리: " << m2 << endl; gc.releaseFreeMemory(m2); } cout << "\n========== 남은 메모리 ==========" << endl; gc.printFreeMemory(); return 0; }

자료구조알고리즘컴퓨터구조

정예은

[ 워밍업클럽 4기 ] 컴퓨터 구조와 자료구조 알고리즘 - 1주차 발자국

1⃣강의 내용  컴퓨터 구조 불대수 (0과1 또는 참,거짓으로만 표현되는 논리함수)에 대해 학습하였고, 불대수로 오늘날의 디지털회로(컴퓨터)를 표현하고 계산된다는 점을 알게되었다.특히나, 불대수의 법칙으로 어려운 방정식을 쉽고 깔끔하게 리팩토링 된다는 점이 매력적이였고논리 회로로(그림) 직관적으로 계산할 수 있다는 점이 흥미로웠다.그러나 불대수 법칙들을 증명하는 과정에서 흡수법칙과 드모르간 법칙은 오늘날 가장 많이 사용되는 법칙인데, 증명 과정이 아직 익숙치 않고 확실히 이해가 어려웠다. (특히 A + (A · B) = A가 왜 되는지 모르겠음).그래서 다음 포스팅에 흡수법칙은 진리표로, 드모르간 법칙은 논리식으로 풀어보며 더 깊이 파고들어볼 계획이다. 자료구조와 알고리즘 트리는 말그대로 나무 처럼 생겼음 ( ex.회사 조직도,운영체제의 파일시스템 )하나의 노드에서 여러가지의 나뭇가지로 가지치기 하며 내려가는것 = "계층구조"를 표현하기에 제격이다.1. 노드 Node데이터를 담는 가장 작은 단위(덩어리)2. 엣지 Edge각 노드를 연결하는 선3. 루트노드 Root Node트리노드에서 가장 최상위의 노드4. 터미널 노드 Terminal Node자식노드가 없는 부모노드참고로, 터미널노드는 루트노드만 있는 트리로 볼 수 있음5. 인터널 노드 Internal Node루트노드,터미널노드를 제외한 노드6. 서브트리루트노드인 A인 입장에선, 3개의 서브트리가 연결된 구조이진트리란? (Binary Tree)Tree에서 어떤 규칙을 지켜야지 Binary Tree라고 불리운다.그 규칙은 무엇일까?자식노드가 최대 "2개" 만 가져야지 이진트리이다.트리의 레벨과 높이트리는 아래로 갈 수록 레벨이 높다.이 레벨의 최대 단위를 "높이"라고 표현함 .즉 레벨이 3이면, 이 트리의 높이도 3이다.포화 이진 트리트리의 최대 레벨에 있는 모든 터미널 노드가, 꽉 찬 트리예 ) 트리 높이가 3이며, 레벨3에 있는 노드(=터미널노드)들이 꽉 차있으므로 노드 추가가 불가한 상태만약, 터미널노드가 꽉 차있지 않으면? 노드 추가 가능2⃣학습 회고 🤔질문 | BIOS란 무엇일까?Basic Input Output System의 약자로 , 컴퓨터 킬 때 가장 먼저 실행되는 프로그램.주로 하드웨어가 정상적인지 검사하고, 정상인 경우 하드디스크나 SSD등에서 운영체제를 찾아 메모리로 불러오는 작업(부팅) 을 한다고 한다!.또한, 부팅 순서나 시스템 시간 + 메모리 정보 등 각종 하드웨어 설정을 관리하는 프로그램. 🤔캐시메모리는 어디에 위치하는가?CPU레지스터와 별도로 구분되는 메모리 공간임.메인 메모리 : 앞으로 사용될 것 같은 데이터 미리 저장👉🏻 CPU에서 메인메모리 데이터를 참조시 속도가 더 빠른 캐시를 먼저 "조회 "👉🏻 만약 캐시 데이터가 있다면? 레지스터로 가져와 계산 진행 !크게 L1,L2,L3 나눠져 있음. 👉🏻 L1과 L2캐시는 CPU내부, L3는 CPU외부에 위치함. 🤔질문 | 왜 컴퓨터는 0과1로만 표현? 다른 숫자는 NO?1. 전기 신호의 단순성컴퓨터는 전기 신호로 작동함전기 신호는 두 가지 상태, 즉 켜짐(ON)과 꺼짐(OFF) 로 표현하는 게 가장 간단하고 안정적.0은 "전기 꺼짐(낮은 전압)", 1은 "전기 켜짐(높은 전압)"으로 매핑.2. 신뢰성과 오류 최소화0과 1 두 가지 상태만 다루면 신호를 구분하기 쉬움.예를 들어, 0은 0V, 1은 5V로 설정하면 중간 값(예: 2.5V)이 애매하게 혼동될 가능성이 적다.만약 0~9(십진수)를 직접 사용하려면, 전압을 10단계로 나눠야 함(예: 0V, 0.5V, 1V, ..., 4.5V) 이건 하드웨어가 복잡해지고, 작은 전압 차이로 오류가 생길 확률이 높아짐.3. 효율적인 데이터 표현0과 1의 조합으로 모든 데이터를 표현할 수 있다.숫자, 문자, 이미지, 심지어 소리까지 이진수로 변환 가능!예: 문자 'A'는 ASCII 코드로 01000001(8비트). 숫자 5는 00000101.이진수로 모든 걸 표현할 수 있으니 다른 숫자 체계(예: 0~9)를 굳이 쓸 필요가 없다.  자료구조 알고리즘 회고재귀로 순회하는 로직을 알겠으나,생성자를 통해 노드를 생성하고, 서브트리를 만들어서 기능 설정하는 부분이 익숙하지 않아서 어려웠다.추후, 이번 강의에 대한 <기본편> 학습이 더욱 필요하다는 것을 깨달았다. 3⃣미션 해결 미션 제출 링크불대수 방정식을 활용하여, 간단하게 식을 정리하는 법이 재미있었다. 증명하는 과정이 흥미로웠다. 강의에서 배운 내용 ( 법칙들 ) 적용해가며 식을 스스로 증명하는게 재미있었다 그러나 자료구조와 알고리즘 문제는 <기본편> 학습이 제대로 되지 않은 상태에서 <심화편> 수업과 미션을 수행하려니 너무 어렵고 버거웠다. 그래서 자료구조 알고리즘 미션은 공란으로 제출해버렸다 .... 해당 미션은 차주에 <기본편>학습을 하며 미션을 해결할 예정이다.   4⃣학습일지 컴퓨터 구조 자료구조와 알고리즘  

컴퓨터 구조감자자료구조워밍업클럽발자국컴퓨터구조

채널톡 아이콘