'알고리즘 관련'에 해당되는 글 6건

  1. 2017.04.10 정렬 및 검색
  2. 2017.01.13 비트 연산
  3. 2017.01.04 트리와 그래프
  4. 2016.12.15 Stack 과 Queue
  5. 2016.12.14 연결 리스트
  6. 2016.12.12 배열과 문자열

정렬 및 검색


  1. 참고

  1. 정렬

    • 내부 정렬: 정렬되는 자료가 적어 자료 전체의 정렬이 주 기억장치에서 이뤄짐
    • 외부 정렬: 정렬되는 자료가 많아 보조 기억장치를 통해 정렬이 이루어짐
    • 기본 정렬에 대한 소개 및 코드화

        버블 정렬:
        • 데이터를 차례대로 정렬하는 과정이 수중 거품의 움직임과 유사하여 거품 정렬이라고도 부른다
        • 시간복잡도: O(n^2)
        •   public void bubbleSort(int[] array){
                for(int i=0; i<array.length-1; i++){
                    for(int j=i; j<array.length-1-i; j++){
                           if( array[j] > array[j+1] ){
                            int temp = array[j];
                            array[j] = array[j+1];
                            array[j] = temp;
                        }
                    }
                }
            }
          
        선택 정렬:
        • 해당 위치에 맞는 자료를 선택하여 위치를 교환하는 정렬 방식
        • 시간복잡도: O(n^2)
        •   public void selectionSort(int[]array){
                for(int i=0; i<array.length; i++){
                    int maxValue = Integer.MIN_VALUE;
                    int maxIndex = -1;
                    for(int j=0; j<array.length-i; j++){
                           if( maxValue < array[j] ){
                            maxIndex = j;
                            maxValue = array[j]
                        }
                    }
                    if(maxIndex != array.length-1-i){
                        int temp = array[maxIndex];
                        array[maxIndex] = array[array.length-1-i];
                        array[array.length-1-i] = temp;
                    }
                }
            }
          

        삽입 정렬:

        • 정렬할 새로운 데이터를 뽑아 적당한 새 위치에 삽입하는 알고리즘
        • 시간복잡도: O(n^2)
        • public void insertionSort(int [] array){
                for(int i=0; i < array.length; i++){
                    int temp = array[i];
                    int tempIndex = -1;
                    for(int j=i-1; j>=0 ; j--){
                        if (array[j] > temp) {
                            tempIndex = j;
                            array[j + 1] = array[j];
                        }else{
                            break;
                        }
                    }
                    if(tempIndex != -1) {
                        array[tempIndex] = temp;
                    }
                }
            }
          
      • 퀵 정렬:

        • 정리잘되어 있음 정리잘하신분
        • 분할 작업을 순환적으로 반복하면서 pivot 의 왼쪽 왼쪽 부분 집합과 오른쪽 부분집합을 정렬 하는 방법
        • 시간복잡도: O(nlogn)

          •   public void quickSort(int[] data, int l, int r) {
                int left = l;
                int right = r;
                int pivot = data[(l + r) / 2];
            
                do {
            
                    // pivot 기준으로 왼쪽 값이 더 커지면 stop
                    while (data[left] < pivot) {
                        left++;
                    }
                    // pivot 기준으로 오른쪽 값이 더 작아지면 stop
                    while (data[right] > pivot) {
                        right--;
                    }
                    if (left <= right) {
                        int temp = data[left];
                        data[left] = data[right];
                        data[right] = temp;
                        left++;
                        right--;
                    }
                }
                // left index 가 right index 보다 작은 구간에서만 동작한다
                while (left <= right);
            
                // 우측 list 기준으로 기준을 새로이 잡고 재귀로 호출
                if (l < right) {
                    quickSort(data, l, right);
                }
                // 좌측 list 기준으로 기준을 새로이 잡고 재귀로 호출
                if (r > left) {
                    quickSort(data, left, r);
                }
            }
            
    • 성능비교 :
      • 속도: 버블 정렬 == 선택 정렬 < 삽입 정렬 < 퀵 정렬
  2. 검색
    • 특정 아이템, 자료를 찾아내는 방식으로 정렬된 자룔를 이용한다
    • 종류
      • 선형 검색
      • 이진 검색
      • 피보나츠 검색
      • 보간 검색
      • 블록 검색
      • 이진탐색 트리 검색



'알고리즘 관련 > 자료구조' 카테고리의 다른 글

트리와 그래프  (0) 2017.01.04
Stack 과 Queue  (0) 2016.12.15
연결 리스트  (0) 2016.12.14
배열과 문자열  (0) 2016.12.12
Posted by 감각적신사
,

비트 연산

알고리즘 관련 2017. 1. 13. 08:29

비트 연산


  1. 참고

  2. bit

    • 1자리수의 2진숫자(0 또는 1)를 뜻하는 binary digit의 약어
    • 2진수 1자리수에 상당하는 데이터량을 나타내는 정보의 단위
    • byte 는 비트가 여러 개 모인 것으로, 8 bit 가 1 byte 이다
  3. 비트 연산자

          // 논리곱
         int a = 170, b = 245;
         // a   = 1 0 1 0 1 0 1 0
         // b   = 1 1 1 1 0 1 0 1
         // a&b = 1 0 1 0 0 0 0 0
    
         System.out.print("a&b: ");
         System.out.println(a&b); // a&b: 160
    
         // 논리합
         a = 170; b = 245;
         // a   = 1 0 1 0 1 0 1 0
         // b   = 1 1 1 1 0 1 0 1
         // a|b = 1 1 1 1 1 1 1 1
    
         System.out.print("a|b: ");
         System.out.println(a|b); // a|b: 255
    
         // 배타적 논리합
         a = 170; b = 245;
         // a   = 1 0 1 0 1 0 1 0
         // b   = 1 1 1 1 0 1 0 1
         // a^b = 0 1 0 1 1 1 1 1
    
         System.out.print("a^b: ");
         System.out.println(a^b); // a^b: 95
    
         // 1의 보수 표현
         a = 170;
         // a   = 1 0 1 0 1 0 1 0
         // ~a  = 0 1 0 1 0 1 0 1
         System.out.print("~a: ");
         System.out.println(~a); // ~a: -171
    
  4. 시프트 연산자

         // 왼쪽 시프트 연산자 <<
         /**
          *
          10110010
          1011001000
          11001000
          왼쪽으로 두칸 밀면서, 비게 되는 오른쪽 두칸은 0 으로 채운다.
          그런데, 문제는 왼쪽으로 밀면서 기존의 크기를 넘어서기 때문에 왼쪽으로 넘어선 2개의 비트는 삭제된다.
          따라서, 10110010 을 왼쪽으로 밀면 왼쪽 두개 비트인 10 은 삭제되고, 오른쪽의 2개 비트는 0으로 채워져
          결과값은 11001000 이 된다.
          */
             int c = 178;
             System.out.println("before << : "+ c); // before << : 178
             c = c << 2;
             System.out.println(" after << : "+ c); //  after << : 712
    
         // 오른쪽 시프트 연산자 >>
         /**
          *
          10110010
          1110110010
          11101100
          오른쪽으로 2비트 이동한후, 비게되는 왼쪽의 2개비트는 1로 채워지고, 오른쪽에서 2비트 넘어간 부분은 삭제된다.
          따라서, 10110010 을 오른쪽으로 2비트 시프트하면, 11101100 이 된다.
          그런데, 주의할점은, 오른쪽으로 밀면서 왼쪽에 비게되는 비트부분이 무조건 1 로 채워지는 것이 아니라,
          밀기전의 최초 첫째자리 값과 동일한 값으로 채워진다는 것이다.
          여기에서는 밀기전의 첫째자리값이 1 이었으므로, 1 로 채워진 것이다.
          */
             c = 178;
             System.out.println("before >> : "+ c); // before >> : 178
             c = c >> 2;
             System.out.println(" after >> : "+ c); //  after >> :  44
    
         // 논리 오른쪽 시프트 연산자 >>>
         /**
          *
         10110010
         0010110010
         으로 되는 것으로, 역시 오른쪽으로 밀려난 2개 비트 10 은 삭제되고, 비게되는 왼쪽 2비트는 무조건 0으로 채워진다.
         따라서 10110010 을 오른쪽으로 논리 시프트 하면, 00101100 이 된다.
          */
             c = 178;
             System.out.println("before >>> : "+ c); // before >>> : 178
             c = c >>> 2;
             System.out.println(" after >>> : "+ c); //  after >>> :  44
    
  5. 비트 연산 의 활용

    • G.771 코덱 커스터마이징
    • 대칭형 암호화: ^ 를 두번 연속 사용하면 원래의 값이 나온다 는 성질을 이용


Posted by 감각적신사
,

트리 와 그래프


  1. 트리

    • 트리 참고

    • 개념:
      • 차수(degree): 하나의 node 의 child node 의 수, 트리의 차수는 최대 child node 의 수
      • 레벨(level):
        • A node = 1
        • B node = 2
        • D node = 3
    • Left Child-Right Sibling 표현법:

      • 왼쪽에 child node , 오른쪽에 sibling node (형제노드)

      • JAVA 구현
      •   class TreeNode {
              int index;
              boolean isRootNode;
              TreeNode[] childNode;
        
              boolean hasChild(){
                  if (childNode == null || childNode.length() == 0){
                      return true;
                  }else{
                      return false;
                  }
              }
        
              void appendChild(TreeNode insertNode){
                  // childNode 가 없다면
                  if (childNode == null){
                      childNode = new TreeNode[](1);
                      childNode[0] = insertNode;
                  }
                  // 기존의 childNode 가 존재한다면
                  else {
                      TreeNode[] newChildNode = Arrays.copyOf(childNode, childNode.length() + 1);
                      newChildNode[newChildNode.length()-1] = insertNode;
                      childNode = newChildNode;
                  }
              }
          }
        
  2. 그래프

    • 그래프 참고
    • 그래프 참고2
    • 정의: 현실세계의 사물이나 추상적인 개념 간의 연결 관계를 표현
      ex) 여러 도시들을 연결하는 도로망, 사람들 간의 지인 관계, 웹사이트 간의 링크 관계
    • 구성요소: G(V, E): 그래프는 Vertex와 Edge들의 집합
      • 정점 (Node, Vertex)
      • 간선 (Edge): 정점간의 관계 나타냄 (비용, 개수 등등)
    • 종류:
      • 유향 그래프: 그래프에 방향이 있는 그래프
      • 가중치 그래프: 간선에 가중치가 있는 그래프 ex) 정점 이동간에 드는 비용
      • 다중 그래프: 두 정점 사이에 두 개 이상의 간선이 있을 수 있는 그래프 ex) 도로망
      • 트리 혹은 루트 없는 트리: 부모 자식 관계가 없을 뿐, 간선들의 연결 관계만 보면 트리와 같은 무향 그래프
      • DAG(Directed acyclic graph): 한 점에서 출발해 자기 자신으로 돌아오는 경로가 존재하지 않는 방향 그래프, 위 그림에서 무향일 경우에는 cycle이 존재할 수 있음
  3. 이진 트리

    • 이진 트리
      • 정의:
        • 한 노드가 최대 두 개의 자식 노드를 가지는 트리
      • 속성 값 정의:
        • 방향 간선(directed edge): 부모에서 자식으로 가는 경로를 가리킨다
        • 루트 노드(root node): 부모가 없는 노드 로, 트리는 하나의 루트 노드만을 가진다
        • 단말 노드(leaf node): 자식이 없는 노드
        • 노드의 깊이(depth): 루트 노드에서 자신까지 가는 경로의 길이 == 레벨(level) 과 비슷
          • 루트 노드의 깊이: 0
        • 트리의 높이(height): 루트 노드에서 가장 깊이 있는 노드까지 가는 경로의 길이
        • 형제(sibling)은 같은 부모를 가지는 노드
        • 노드의 크기(size): 자신을 포함한 모든 자손 노드의 개수
        • 노드의 진입차수(In-degree): 노드에 들어오는 모든 간선의 수
        • 노드의 진출차수(Out-degree)는 노드에서 나가는 모든 간선의 수
      • 종류:
        • 루트를 가진 이진 트리(rooted binary tree): 모든 노드의 자식이 최대 2개인 트리
        • 정 이진 트리(full binary tree): 단말 노드가 아닌 모든 노드가 2개의 자식을 가진 트리
        • 포화 이진 트리(perfect binary tree): 모든 단말 노드의 깊이가 같은 정 이진 트리
        • 완전 이진 트리(complete binary tree): 끝 부분(마지막 레벨)을 제외하고 모든 노드가 채워진(마지막 레벨을 제외하고는 모든 노드가 자식노드를 2개를 가진) 이진 트리. 마지막 레벨의 노드들은 왼쪽으로 채워져 있다. 마지막 레벨이 다 채워질 수도 있다.
      • 이진 트리 탐색
        • 정의: 이진 트리의 모든 노드를 방문하는 것 혹은 방문하여 어떤 작업을 하는 것을 이진 트리 탐색이라고 한다
        • 속성:
          • 각 노드에 값이 있다
          • 각 노드의 키값은 모두 달라야 한다
          • 값들은 전순서가 있다
          • 노드의 왼쪽 서브트리에는 그 노드의 값보다 작은 값들을 지닌 노드들로 이루어져 있다
          • 노드의 오른쪽 서브트리에는 그 노드의 값보다 큰 값들을 지닌 노드들로 이루어져 있다
          • 좌우 하위 트리는 각각이 다시 이진 탐색 트리여야 한다
          • 중복된 노드가 없어야 한다
        • 방법:
          • in-order : 왼쪽 자식노드, 내 노드, 오른쪽 자식노드 순서로 방문
          • pre-order : 내 노드, 왼쪽 자식노드, 오른쪽 자식노드 순서로 방문
          • post-order : 왼쪽 자식노드, 오른쪽 자식노드, 내 노드 순서로 방문
          • level-order : 내 노드, 내 노드로부터 깊이 1인 노드들, 내 노드로부터 깊이 2인 노드들, … , 내 노드로부터 깊이 N인 노드들 (N: 나(트리)의 깊이)
        • 특징:
          • 데이터의 이동이 많은 동적인 데이터들의 집합에 적합한 탐색 방법
          • VS 배열을 이용한 이진탐색: 수행속도는 빠르나 데이터의 삽입과 삭제가 일어날 때, 배열 내의 데이터들을 이동해야하는 문제점이 있음
          • 트리 구조를 이용하여 데이터의 삽입과 삭제가 필요할 때, 전체적인 데이터의 이동이 없이 포인터만 연결 시켜주면서 간단하게 해결
  4. 문제풀이

    • 균형 이진 트리 란: 단말 노드 간의 depth 차이가 1 이하 인 이진트리 찾기
    • 단순 구현

        class Node {
            int index;
            Node leftChild;
            Node rightChild;
      
            boolean isLeafNode(){
                if(leftChild == null && rightChild == null){
                    return true;
                }else{
                    return false;
                }
            }
      
        }
      
        public NodeTest{
      
            Node [] tree;
      
            //TODO 구현 필요
            int getLevel(Node[]tree, Node){
                return 0;
            }
      
            // DFS 구현 필요
      
            public static void main(String[]args){
      
                int minLeafNodeLevel = tree.size();
                int maxLeafNodeLevel = -1;
      
                for (Node singleNode : tree){
                    if( singleNode.isLeafNode() ){
      
                        int level = getLevel(singleNode);
      
                        if (level > maxLeafNodeLevel){
                            level = maxLeafNodeLevel;
                        }else if (level < minLeafNodeLevel){
                            level = minLeafNodeLevel;
                        }
                    }
      
                }
      
                if((maxLeafNodeLevel - minLeafNodeLevel) <= 1){
                    System.out.println("균형 이진 트리");
                }else{
                    System.out.println("균형 이진 트리 아님");
                }
      
            }
        }


'알고리즘 관련 > 자료구조' 카테고리의 다른 글

정렬 및 검색  (0) 2017.04.10
Stack 과 Queue  (0) 2016.12.15
연결 리스트  (0) 2016.12.14
배열과 문자열  (0) 2016.12.12
Posted by 감각적신사
,

Stack 과 Queue


  1. Stack

    • LIFO ( Last In First Out ): 후입선출
    • 함수:
      • top
      • push
      • pop
    • 용도:
      • 복귀주소 저장시 (서브 프로그램 호출, 인터럽트 발생 등)
      • 재귀 프로그램의 순서 제어
      • 후위표기법으로 산출된 산술식 연산
  2. Queue

    • FIFO ( First In First Out ): 선입선출
    • 함수:
      • put: enqueue
      • get: dequeue
    • 용도:
      • 대기행렬 처리
      • 운영체제의 작업 스케줄링
  3. 문제 풀이

    • 크기가 제한된 Stack 구현하기
    • 풀기 전 확인사항
      • 스택의 갯수 제한 여부, 확장성
      • 스택에 쌓이는 접시 무더기의 경우 가중치가 다른지 (차지하는 공간이 일정한가? 아닌가?)
      • ArrayList 의 경우 insert 한 순서를 유지 하기 때문에 LinkedList 에 비해 구현이 용이할 것 같다>> ArrayList 와 LinkedList 는 데이터의 삽입, 검색의 성능 차이가 있을 뿐 ordering 과는 무관하다
    • 풀이

        class Dish{
            // int val; // 가중치가 부여된다고 생각했을 때...
        }
      
        class SimpleStack{
            int maxSize;
            ArrayList<Dish> dishList;
      
            public SimpleStack(int maxSize){
                self.maxSize = maxSize;
            }
      
            public Dish pop(){
                Dish d = dishList.get(dishList.size()-1)
                dishList.remove(dishList.size()-1)
                return d;
            }
      
            public void push(Dish d) throws Exception{
                if(dishList.size() >= maxSize){
                    throw new Exception();
                }else{
                    dishList.add(d);
                }
            }
        }
      
        public SimpleStackTest{
      
            int stackMaxSize;
            ArrayList<SimpleStack> stackList;
      
            public SimpleStackTest(int stackMaxSize){
                stackList = new ArrayList<SimpleStack>();
                stackList.add(new SimpleStack(stackMaxSize))
            }
      
            public Dish pop(){
      
                SimpleStack s = stackList.get(stackList.size()-1);
                Dish d = s.pop()
                if(s.dishList.size()==0){
                    stackList.remove(stackList.size()-1)
                }
                return d;
            }
      
            public void push(Dish d) throws Exception{
      
                SimpleStack s = stackList.get(stackList.size()-1);
                try {
                    s.push(d);
                }catch (Exception e){
                    SimpleStack s1 = new SimpleStack(stackMaxSize);
                    s1.push(d);
                    stackList.add(s1);
                }
            }
        }


'알고리즘 관련 > 자료구조' 카테고리의 다른 글

정렬 및 검색  (0) 2017.04.10
트리와 그래프  (0) 2017.01.04
연결 리스트  (0) 2016.12.14
배열과 문자열  (0) 2016.12.12
Posted by 감각적신사
,

연결 리스트


  1. 개념:
    • 등장배경:
      • 순차 선형 리스트(배열)는 논리적인 순서와 물리적인 순서가 같기 때문에 원소의 위치를 찾아 액세스하기 쉽다는 장점이 있지만, 삽입 연산이나 삭제 연산에 원소들을 이동시키는 추가적인 작업과 시간이 필요함
      • 원소의 개수가 많고, 삽입, 삭제 연산이 많이 발생하는 경우에는 원소들의 이동 작업으로 인한 오버헤드가 증가, 결국, 메모리 사용의 비효율성의 문제를 갖음.
    • 단위:
      • 노드: 연결 자료구조 방식에서 원소는 연결될 다음 원소에 대한 주소를 저장해야 하기 때문에, <원소, 주소> 단위로 저장
        • 원소의 값을 저장하는 데이터 필드(Data Field)
        • 다음 노드의 주소를 저장하는 링크 필드(Link Field)
  2. 종류:

    • 단순 연결 리스트:
      • 노드가 하나의 링크 필드에 의해서 다음 노드와 연결되는 구조를 가진 연결 리스트
      • 데이터의 삽입: 노드 중간에 삽입될 경우, 1. 이전노드의 다음노드 주소를 받고 2. 이전노드에 삽입되는 노드의 주소를 전달한다
    • 원형 연결 리스트
      • 장점: 하나의 노드에서 모든 다른 노드로의 접근 가능
      • head 를 두어 시작 노드와 끝 노드를 정의해야 한다
      • 특정 노드를 검색할 때 만일 그 노드가 연결 리스트에 포함되어 있지 않은 노드라면, 무한 루프(loop)에 빠질 가능성 있어, 검색을 끝낼 수 있는 노드를 지정해 두는 것이 좋음
    • 이중 연결 리스트
      • 노드가 두개의 링크 필드를 가지고 있어, 이전 노드와 다음 노드의 정보를 가지고 있다
      • 장점: 양방향 탐색
      • 단점: 변수(링크 필드)를 하나 더 사용 == 메모리를 더 많이 사용한다는 의미
      • 현실에서 사용하는 연결 리스트는 대부분 이중 연결 리스트
    • 이중 원형 연결 리스트
  3. 비교 리스트 종류 간 비교

    • 배열 과 연결리스트:
      • 배열은 할당받은 메모리 내 에서 동작
      • 연결리스트는 동적으로 메모리 할당 후 동작, 메모리 주소에 대한 참조를 하기 때문에 추가 메모리 사용
    • 단순 연결 리스트 VS 이중 연결 리스트
      • 데이터 검색, 삭제 성능: 단순 연결 리스트 < 이중 연결 리스트
      • 메모리 추가 사용: 단순 연결 리스트 < 이중 연결 리스트
    • 이중 연결 리스트 VS 원형 연결 리스트
      • 구조가 유사
      • 데이터 삽입 시, 이중 연결 리스트의 경우 마지막 노드를 찾는데 O(N) 이 소요되나 원형 연결 리스트의 경우 시작 노드에서 마지막 노드 를 바로 찾을 수 있다
  4. JAVA 의 Vector, ArrayList, LinkedList 차이

    • 차이
    • Vector:
      • 구버젼 호환용
      • 동기화 처리가 내부적으로 일어남으로 다른 객체보다 무겁다 == 성능 저하
    • ArrayList:
      • 배열의 복사에 의한 데이터 저장처리를 내부적으로 행한다
      • 각 데이터에 대한 인덱스를 가지고 있기때문에 검색이 매우 빠르다
      • 많은 데이터의 추가 / 삭제시에는 배열의 복사가 빈번하게 일어나, 성능이 떨어지는 단점이 있다
    • LinkedList:
      • 다음 자료의 위치정보를 가지며, 내부적인 인덱스는 가지고 있지 않다
      • 데이터의 추가 / 삭제는 위치정보의 수정만으로 가능하기 때문에 많은 정보의 추가 / 삭제처리가 필요할때 유용하다
      • 데이터가 많은 경우의 검색시 처음 자료로부터 순차적으로 찾아 나가야 하기 때문에 느려지는 단점이 있다
    • 데이터 추가 / 삭제: ArrayList < LinkedList
    • 데이터 검색: ArrayList > LinkedList


'알고리즘 관련 > 자료구조' 카테고리의 다른 글

정렬 및 검색  (0) 2017.04.10
트리와 그래프  (0) 2017.01.04
Stack 과 Queue  (0) 2016.12.15
배열과 문자열  (0) 2016.12.12
Posted by 감각적신사
,

배열과 문자열


참고

  1. 기본 자료 구조 비교

    • 배열(array):
      • + 내부 인덱스를 이용하여 자료의 검색이 한번에 이루어지기 때문에 빠른 검색 속도
      • - 데이터의 삽입, 삭제시 많은 데이터가 밀리거나 빈자리를 채우기 위해 이동해야 하기 때문에 많은 시간이 소요된다
    • 리스트(list):
      • + 삽입, 삭제시 인근 노드들의 참조값만 수정해 줌으로써 빠른 처리가 가능
      • - 데이터의 수가 많아질수록 효율이 떨어진다
    • hash:
      • 배열(array), 리스트(list)의 한계를 극복하기 위한 자료구조
      • 내부적으로 배열을 사용하여 데이터를 저장하기 때문에 빠른 검색 속도를 갖는다
      • 데이터의 삽입과 삭제시 기존 데이터를 밀어내거나 채우는 작업이 필요 없도록 특별한 알고리즘을 이용하여 데이터와 연관된 고유한 숫자를 만들어 낸뒤 이를 인덱스로 사용한다
      • 특정 데이터가 저장되는 인덱스를 그 데이터만의 고유한 위치이기 때문에 삽입시 다른 데이터의 사이에 끼어들거나 삭제시 다른 데이터로 채울 필요가 없으므로 삽입과 삭제시 데이터의 이동이 없도록 만들어진 구조다
    • JAVA 기준으로 각 자료 구조의 특징 정리
      • ArrayList: 배열 기반, 데이터의 추가와 삭제 유용하지 못함, 순차적인 추가 삭제는 제일 빠름, 인덱스가 있어 임의의 요소에 대한 접근성이 뛰어남
      • LinkedList: 연결 기반, 데이터의 추가와 삭제에 유용함, 임의의 요소에 대한 접근성이 좋지 못함
      • HashMap: 배열과 연결이 결합된 형태, 추가, 삭제, 검색, 접근성이 모두 뛰어남, 검색에는 최고 성능을 보인다
  2. hash table

    • key-value 의 쌍
    • key 의 유일성이 보장되어야 데이터가 안전하게 저장된다
    • 이진 탐색 트리 를 사용한 hash table 의 경우 시간복잡도 O(logN) 을 보장한다
    • JAVA 에서의 hashtable
      • HashTable(o), HashMap(x): thread safe 한지 하지않은지 로 나뉜다
  3. ArrayList

    • 동적으로 크기가 조정되는 배열
    • 일반적으로 배열의 크기가 증가할 때, 배열의 크기를 늘리는 시간은 O(N)
    • 자주 일어나는 일이 아니므로 O(1) 로 생각한다
  4. StringBuffer

    • String 과 비교: append 작업시 O(xN2) 만큼 차이를 보인다
    •   for(String a:aLists){
            string = string + a; // 계속해서 새로운 객체를 생성하기 때문이다
            stringBuffer.append(a);
        }
      
  5. 문제풀이

    • 문제 풀기 전 확인하고 싶은 사항
      • 같은 문자는 대소문자 구분이 없는가
      • 문자열의 길이 제한이 있는가
    •   StringBuffer result = "";
        String previousChar = "";
        int sameCnt = 0;
        for(int i=0;i<str.length();i++){
            if (result.toString().length() > str.length()){
                return str;
            }else{
                if(previousChar.equel(str.indexOf(i))){
                    sameCnt++;
      
                    if(){
      
                    }
                }else{
                    if(sameCnt!=0){
                        // result.append(previousChar+sameCnt);
                        result.append(previousChar);
                        result.append(sameCnt);
                    }
      
                    previousChar = str.indexOf(i)
                    sameCnt = 1;
                }
            }
        }


'알고리즘 관련 > 자료구조' 카테고리의 다른 글

정렬 및 검색  (0) 2017.04.10
트리와 그래프  (0) 2017.01.04
Stack 과 Queue  (0) 2016.12.15
연결 리스트  (0) 2016.12.14
Posted by 감각적신사
,