출처
 http://www.mungchung.com/xe/protip/3484
 http://withwani.tistory.com/150


HashTable implements Map

자바 1.1버전부터 사용되왔던 자료구조 클래스로 Map 인터페이스를 확장한다.

-키값의 중복을 허용하지 않는다
-key와 value 쌍으로 데이터를 저장한다
-FILO의 스택과 같은 구조로 저장되어있다. 마지막 넣은 항목이 index 0
-입력 : put(키,값) 
-값 가져오기 : get(키)


HashMap implements Map

1.5버전부터 도입된 자료구조로서 헤시테이블과 그 기능이 유사하나
무조건적으로 동기화 되는 헤시테이블과 비교되어 상황에 따라 더욱 가볍게 사용할 수 있다.

-해시테이블과 다르게 FIFO 의 구조로 데이터가 저장된다. 처음 넣은 항목이 index 0
-나머지는 동일

TreeMap implements Map, SortedMap

1.5버전 이후로 도입된 자료구조

-SortedMap을 확장하여 key값에 의한 정렬이 가능하다.
-key값에 의해 자동 정렬 된다.


AVA에서 기본적인 자료 구조를 제공하기 위한 환경을 JAVA Collection Framework라고 한다.

다음은 JAVA Collection Framework의 상속 기본 구조이다.

  

   

  1. Collection

    Collection 인터페이스를 상속받아 List와 Set 인터페이스가 된다. List는 순서가 있는 Collection, 그리고 List는 Data 중복을 허락한다. 하지만 Set은 순서의 의미가 없으며 Data를 중복해서 포함할 수 없다.

  • List 인터페이스의 특징
    • 순서가 있는 Collection.(이 순서는 삽입된 순서를 의미한다.)
    • Data를 중복해서 포함할 수 있다.
    • Stack의 특징
      • Data의 삽입과 추출이 후입선출(Last-In First-Out) 구조로 되어 있다.
      • push() method : Data 삽입할 때 사용
      • pop() method : Data 추출할 때 사용
      • peek() method : 추출할 Data를 삭제하지 않고 Data만을 가져 올 때 사용
      • search() method : Stack으로부터 Data를 검색할 때 사용
    • Vector의 특징
      • 자동으로 동기화를 보장해준다.
      • ArrayList에 동기화가 보장되도록 최적화한 클래스이다.
      • JAVA 5.0 이 후로는 AutoBoxing/AutoUnBoxing을 지원한다.
        • AutoBoxing이란? 기본 Data 타입을 Wrapper 클래스형의 객체로 자동으로 변환해주는 기능. AutoUnBoxing은 AutoBoxing의 반대 개념
        • JAVA 1.4까지

Vector v = new Vector();
v.addElement(new Integer(100));

  • JAVA 5.0이후

Vector v = new Vector();
v.addElement(100); // AutoBoxing 발생, 자동으로 Wrapper class인 Integer로 변경

  • addElement() method : Data를 삽입할 때 사용
  • elementAt() method : Data를 추출할 때 사용, Index에 해당하는 객체를 얻어냄
  • size() method : Vector 내에 존재하는 객체의 수를 얻어낼 대 사용
  • insertElementAt() method : Vector 내에 중간 삽입할 때 사용
  • setElementAt() method : Vector 내에 존재하는 Data를 수정할 때 사용
  • indexOf() method : Vector 내에 Data를 검색할 때 사용, Index를 반환
  • contains() method : Data의 존재 유무를 알기 위해 사용.
  • ArrayList의 특징
    • 동기화를 보장해주지 않는다.
    • 배열에 동적 메모리 증가 기능을 구현한 클래스이다.
    • 동기화 지원 방법 : List list = Collections.synchronizeList(new ArrayList(…));
    • add() method : Data 삽입할 때 사용
    • get(0 method : Data 추출할 때 사용
    • toArray() method : ArrayList로부터 배열 얻어낼 때 사용
    • contains() method : Data의 존재 유무를 알기 위해 사용
    • size() method : ArrayList의 요소 개수를 얻어낼 때 사용
  • Set 인터페이스의 특징
    • 집합적인 개념의 Collection
    • 순서의 의미가 없다.
    • Data를 중복해서 포함할 수 없다.
    • HashSet의 특징
      • add() method : Data 삽입할 때 사용
      • next() method : Data 추출할 때 사용
        • HashSet의 Data 추출은 Iterator을 이용하면 된다. Iterator는 Collection내의 모든 Data에 접근할 수 있는 특징이 있다. 그리고 Data의 마지막에 상관하지 않고 검색하기 위한 인터페이스이다. Set의 Iterator() method로 Iterator를 얻어 낼 수 있으며, Iterator의 hasNext() method를 이용해서 Data 끝을 만날 때까지 next() method를 호출해서 Data를 추출할 수 있다.

Iterator<String iter = set.iterator();
while(iter.hasNext()) {
String temp = iter.next();

System.out.print(temp + ", ");
}

  • remove() method : Data를 삭제할 때 사용
  • contains() method : Data의 포함여부를 알기 위해 사용
  • size() method : HashSet의 요소 개수를 얻어낼 때 사용

       

  1. Map

    List와 Set이 순서나 집합적인 개념의 인터페이스라면 Map은 검색의 개념이 가미된 인터페이스이다. Map 인터페이스는 데이터를 삽입할 때 Key와 Value의 형태로 삽입되며, Key를 이용해서 Value를 얻을 수 있다.

  • Hashtable, HashMap의 공통점
    • 내부적으로 모두 Hash 기법을 이용한다.
    • Map 인터페이스를 구현하고 있다.
    • Key와 Value를 이용해서 Data를 관리한다.
  • Hashtable, HashMap의 차이점
    • Hashtable은 동기화가 보장된다.
    • HashMap은 동기화가 보장되지 않는다.
    • HashMap의 동기화 지원 방법 : Map m = Collections.synchronizedMap(New HashMap(…));
  • Hashtable, HashMap과 HashSet과의 관계
    • Hashtable과 HashMap은 둘 다 Map 인터페이스를 구현하고 있다.
    • HashSet은 내부적으로 Hash기법을 사용하지만 Set인터페이스를 구현하고 있다.
  • HashMap
    • 객체 생성 : Map<String, Integer> map = new HashMap<String, Integer>();
    • put() method : Data 삽입할 때 사용
    • get() method : Data를 추출할 때 사용, argument값은 Key를 사용
  • Hashtable
    • 객체 생성 : Hashtable<String, Object> h = new Hashtable<String, Object>();
    • put() method : Data 삽입할 때 사용
    • get() method : Data를 추출할 때 사용, argument값은 Key를 사용

   

  1. Sorted

    Set과 Map 인터페이스를 상속받아 정렬 기능이 추가된 SortedSet과 SortedMap 인터페이스가 된다. 그리고 이들은 각각 TreeSet 클래스와 TreeMap 클래스로 구성된다. TreeSet과 TreeMap은 Set과 Map의 기능을 가지고 있으면서 정렬 기능이 가미되었다는 것이 특징이다.

  • Sorted를 지원하지 않는 클래스
    • HashSet, HashMap
  • Sorted를 지원하는 클래스
    • TreeSet, TreeMap
  • TreeMap
    • Key와 Value로 Data를 관리
    • Key를 기준으로 오름차순으로 정렬된다.
    • Map 인터페이스를 상속한 SortedMap 인터페이스를 구현한 클래스
  • TreeSet
    • Set 인터페이스를 상속한 SortedSet 인터페이스를 구현한 클래스
    • 데이터들이 자동으로 오름차순으로 정렬된다.
  • Comparator
    • TreeSet과 TreeMap은 사용자가 직접 정렬의 방식을 지정할 수 있다.
    • TreeSet과 TreeMap은 정렬을 위한 Comparator 인터페이스를 구현하면 된다.
    • TreeSet에 Data를 집어 넣으면 기본적으로 오름차순(Ascending) 정렬이 되지만 그것도 문자열이나 기본 데이터 타입과 같은 단순한 것에만 해당된다. 이에 사용자가 직접 비교법을 넣어주기 위해 사용하는 것이 Comparator 인터페이스이다.
    • Comparator의 구현 방법 : Comparator 내부에 compare() method를 구현하면 된다.

class Mycomparator<T> implements Comparator<T> {
public int compare(T o1, T o2) {
// 비교방법 구현
}

  • Comparator가 추가된 TreeSet의 생성

TreeSet<Score> tset = new TreeSet<Score>(new MyComparator<Score>());

  • Comparator가 추가된 TreeMap의 생성

TreeMap<Score, String> tset = new TreeMap<Score, String>(new MyComparator<Score>());

  • 일반적인 정렬기능의 사용
    • HashSet이나 HashMap을 정렬 기능이 지원되는 TreeSet이나 TreeMap으로 변환해서 사용
    • HashSet을 이용한 TreeSet 생성

Set<String> set = new HashSet<String>();
...
TreeSet<String> ts = new TreeSet<String>();
ts.addAll(set);

  • HashMap을 이용한 TreeMap 생성

Map<String, Integer> map = new HashMap<String, Integer>();
...
Map<String, Integer> sortedMap = new TreeMap<String, Integer>();
sortedMap.putAll(map);

   


제네릭이란 ? 
: 클래스 내부에서 사용할 변수들의 데이터 타입을 외부에서 지정하는 기법, 자바 1.5버전부터 도입된 개념이다


제네릭을 사용하는 이유?

: 비슷한 코드를 중복을 줄이면 코드수도 줄어들고 그만 큼 유지보수가 쉬워진다.

가령 Info라는 변수를 가진 person이라는 클레스가 있다고 생각해보자

class Person{

...
StudentInfo info = new StudentInfo();
or
EmployeeInfo info = new EmployeeInfo(); 

...

}


위와같은 형식으로 Person의 info가 학생(학번,학년,이름,담당교수 등의 정보를 가지고있음)에 대한것 일 수도 있고 직장인(직원ID, 부서, 사무실위치 등의 정보를 가지고있음)에 대한 것일 수도 있다.
때문에 다음과 같이 표현해 보았다.

Object info ;

public void setInfo(Object info){
    info = this.info

}

위와같이 모든 클레스의 조상인 Object를 사용하므로서 StudentIfo와 EmployeeInfo 둘다 받을 수 있게 작성하였다. 하지만 info 자리에 사용자의 부주의에 따라 "부장" 이라는 String이 들어올수도 있고 123이라는 Integer형식이 들어올 수도 있다. 즉 원치않는 데이터타입이 들오게 되지만 이는 컴파일 타임에러에서 검출할 수 없다.

자바는 컴파일 언어이다. 실제로 코드가 프로그램이 되기 전에 사용자의 착오를 미리 검출해주는 기능을 제공한다. 모든 에러가 컴파일 타임수준에서 검출될 수 있도록 코드를 작성해야 자바가 제공해주는 혜택을 누릴 수 있다는 것이다.

쉽게말해 저 코드는 사용자가 원치 않는 데이터타입이 들어가도 오류없이 진행되기 때문에 버그를 찾아내기가 힘들다는 말이다.


실제로 1.4버전까지 다양한 콜렉션들이 데이터를 저장하기위해 Object 형을 썻고 의도치 않는 다른 데이터타입의 삽입/삭제로 인해 일어나는 런타임 에러로 고생한 경험이 많다고 한다.


하지만 제네릭을 사용한다면

class Person<T>{

T info;

public void setInfo(T info extends Info_Interface){

this.info = new Info;

}

}

그리고 StudentInfo와 EmployeeInfo가 Info_interface를 확장하고 있다면 제너럴 T가 받을 수 있는 데이터 타입은 개발자가 의도한 이 두가지 타입밖에 없을것이다. 만약 그 외의 데이터 타입을 넣으려고 시도한다면 컴파일러가 컴파일 에러를 검출 할 것이다.

다시말해 코드의 중복을 없에고 데이터 타입의 안정화를 위해 제네릭을 사용한다. 라고 이해하면 되겠다.

제네릭의 제한

<T extends Info>
// 다음과 같은 제네릭에서 제네릭에 올수있는 데이터 타입은 Info의 자식 클레스만 올 수 있다.
=> 제네릭 범위 안에서 extends키워드는 "부모가 누구다"라는 것을 명시해 주기때문에 Info가 인터페이스라도implements 대신 expends를 쓴다.


제네릭의 중복
한 클래스 안에 복수의 변수타입을 외부에서 지정하고 싶을 경우가 있을 것이다. <T,S,U>와 같은 형식으로 사용하면 된다. 제네릭은 따로 그 모양세의 규정은 없지만 암묵적으로 TSU..순으로 대문자 알파벳을 사용하는 것 같다.(찾아보시길..)

제네릭이 받을 수 없는 변수타입, 기본 데이터타입
제목 그대로 int, double, boolean 과 같은 기본 데이터타입은 제네릭의 인자로 들어갈 수 없다. 떄문에 레퍼클레스(wrapper class)를 사용해야한다. Integer, Double 과 같은 클래스를 이용해 인스턴스화 해서 사용하자

객체명.intValue(); 와 같은 함수를 이용하여 원시 데이터타입의 데이터를 얻을 수 있다.

제네릭의 생략
매개변수를 통해 변수의 타입을 알수 있는 경우 제네릭을 생략할 수 있다.


참고

http://civan.tistory.com/170

http://opentutorials.org/module/516/6237 (비중있게 참고)

vector : 구버전 호환용. 
           무조건 동기화 => 다른객체들보다 무거움


밑에껀 선택적으로 동기화 가능

Collection.synchronizedCollection(Collection c) 이용

ArrayList : 배열의 삽입 삭제에 대한 인덱스 정렬등의 처리를 내부적으로 실행함
              인덱스를 이용한 검색은 매우 빠름
              많은 데이터의 삽입/삭제시 성능저하 우려


LinkedList : 다음자료의 위치정보를 가지며 내부적인 인덱스는 없음
                데이터의 삽입/삭제는 위치정보의 수정만으로 가능하기 때문에
                많은양의 데이터 삽입/삭제가 있을 때 유용
                 다만 데이터의 수가 많은 경우 순차적으로 찾아나가야 하기때문에
                 성능저하 우려


참고 : http://seeit.kr/36#.U6FJP_l_s04


추가 

hash table 역시 vector 와 함께 옛날꺼, 무조건동기화, 무거움
hash map : hash계의 ArrayList랄까

디스크에 접근하는 것은 메인 메모리의 접근에 비해 엄청난 시간이 든다.
디스크에 데이터를 읽고 쓰기 위해서는 블록 단위로 접근을 한다.
이 블록을 보통 소프트웨어에서 페이지 라고 한다.

검색트리가 방대하면 메모리에 모두 올려놓고 사용할 수 없다.
결국 검색트리가 디스크에 있는 상태에서 작업을 해야한다.(cpu가 디스크에 접근을 해야함)
검색트리가 균형을 완벽하게 이루고 있고(각 노드가 자식을 최대한으로 가지고 있고), 또한 분기 수(자식수)가 많을 수록 트리의 레벨은 낮아질 것이고 중앙처리장치가 디스크에 접근해야 하는 부담을 덜어줄 수 있을 것이다.

검색트리가 디스크에 있는 상태로 사용되면 이를 외부검색트리 라고 함
분기(자식노드)의 수가 2개를 넘으면 다진검색트리라고 함
B트리는 디스크 환경에서 사용하기에 적합한 외부 다진검색 트리이다.


B-트리는 다음과 같은 성질(조건)을 만족한다.

 1. 루트를 제외한 모든 노드는 k/2 ~ k 개의 키를 갖는다. k= 각 노드가 가지고있는 키의 갯수
 2. 모든 리프 노드는 같은 깊이를 가진다.
 3. 모든 노드는 자식노드를 가질 시 2개 이상의 자식노드를 갖는다.

4진 검색트리를 예로 삽입/삭제/검색 과정을 살펴본다.


검색

BST와 유사하지만 각 각 노드에서 키의 갯수만큼의 상수시간이 걸린다.


삽입 자식이 4개있는 예제, 각 노드에 키가 3개

모든 트리 검색 후 리프노드에 삽입
삽입 후 오버플로우가 발생한다면 적절히 조절해준다.

(123456을 삽입)

1

12

123

1234

12345 => 오버플로우 발생,
             형제 레벨의 노드에 여유가 있다면 남은 키를 넘김, 없다면 가운데 키를 부모노드로 넘긴다

3
12/45


12/456

(6,7,8 삽입)

3
12 / 4567

3
12 / 45678 = >오버플로우,
                   이웃한 형제레벨에 여유가 있다면 넘긴다, 그렇지 않으면적당히 가운데 키를 부모노드로 넘긴다.

4
123 / 5678

4
123 / 56789 =>오버플로우

5
1234/6789

5
1234/6789 10 =>오버플로우

58
1234/67/9 10


삭제 자식이 5개있는 예제, 각 노드에 키가 4개

1.삭제하려는 값을 검색
2. 리프노드라면 삭제
3. 아니라면 해당 원소의 왼쪽자식노드의 제일 큰값이나 오른쪽 자식의 가장 작은값과 교환하여 (왼쪽일지 오른쪽일지는 코드작성 전에 미리 정해두어야 한다.)리프노드에서 삭제.

                          5
            4 8          /           19 22
1 2 3 / 5 6 / 9 10  // 16 18 / 20 21 / 24 25 26

(4 삭제)
4의 오른쪽 트리에서 가장 작은값과 교환

                          5
            5 8          /           19 22
1 2 3 / 4 6 / 9 10  // 16 18 / 20 21 / 24 25 26

(4 삭제)

                          5
            5 8          /           19 22
1 2 3 /  6 / 9 10  // 16 18 / 20 21 / 24 25 26
           ㄴ> 언더플로우 발생

                          5
            3 8          /           19 22
1 2  / 5 6 / 9 10  // 16 18 / 20 21 / 24 25 26
         ㄴ> 이웃한 형제노드에서 원소를 가져온다

(9삭제)

                          5
            3 8          /           19 22
1 2  / 5 6 /  10  // 16 18 / 20 21 / 24 25 26
                 ㄴ>언더플로우, 형제노드의 원소갯수 역시 최소갯수인 2개

                          5
            3           /           19 22
1 2  / 5 6 8 10  // 16 18 / 20 21 / 24 25 26          => 병합을 했더니 3에서 언더플로우 발생

                      
                3   5   19  22
1 2  / 5 6 8 10  /16 18 / 20 21 / 24 25 26             => 병합



B+트리

b트리와 달리 트리의 최하위 레벨의 리프노드에만 데이터 들이 정렬되어있음. 
나머지 노드들은 키값만 가지고 있다.
파일시스템 같은 블록기반 스토리지에서 저장데이터의 효율적인 검색에 유용함

58
1234/567/89 10

이와같이 인덱스에 사용되던 키값마저 리프노드에 중복되어있다.
또한 1->2->3->4->5->.,...->10순으로 각 리프로드가 링크되어 linked list를 구성하고 있기 때문에
데이터의 순차적 처리가 가능하다.


이진검색트리 ( binary search tree)

기본적으로 레코드는 데이터를 저장하는 필드를 가지고 있다.
그리고 다른 레코드와의 구분을 위해 한개 그이상의 필드 조합으로 이루어진 필드를 검색키 또는 라고한다.

이진검색트리를 탐색에 사용하기 위한 몇가지 특성(조건)을 가지고있다.

1.이진트리의 각 노드는 키값을 하나씩 갖는다. 각노드의 키값은 중복되지 않는다.
2.최상위 레벨에 루트노드가 있고, 각 노드는 최대 두개의 자식노드를 갖는다.
3.임의의 노드의 키값은 자신의 왼쪽 자식노드의 키값보다 크고, 오른쪽 자식 노드의 키값 보다 작다.

탐색방법
    입력 : 루트노드와 찾고자하는 키값
    1.루트노드 = 키값 => 루트 반환
    2.키값이 루트보다 작으면 왼쪽탐색, 키값이 루트보다 크면 오른쪽 탐색
    3.반복

    탐색시간
    최악의 경우 (ㅇ-ㅇ-ㅇ-ㅇ 과 같이 일자형 구조로 이루어진경우) Θ(n)의 시간이 걸린다.
    최적의 경우 (힙의 모양) Θ(log n)의 시간이 걸린다. (트리의 높이만큼의 시간)
     ex) 4~7개의 노드로 이루어진 힙의 구조를 가진 BST에서는 높이가 트리의 높이가 3임으로 총 2의
       탐색시간이 걸린다.

삽입
    입력 : 루트노드와 삽입하고자 하는 노드의 키값
    1. 루트노드 키값이 작으면 왼쪽, 크면 오른쪽 탐색
    2. 반복 후 리프노드 도달시 리프노드보다 크면 왼쪽, 크면 오른쪽에 삽입
     (힙의 구조가 아니기 때문에 별다른 트리의 수정이 필요하지 않다.)

삭제
   입력 : 루트노드와 삭제하고자 하는 노드의 키값
   1. 삭제하고자 하는 키값을 탐색
   2. 삭제
     2-1 삭제하고자 하는 키값이 리프노드일 경우 : 바로 삭제
     2-2 삭제하고자 하는 키값이 자식을 하나 가질 경우
         :해당 노드를 삭제한 후 그 자식을 삭제한 노드 위치에 배치한다.
     2-3 삭제하고자 하는 키값이 자식을 둘 가질 경우
         :해당 노드를 삭제하고
         1.왼쪽 자식 중 가장 큰값으로 대체하거나
         2. 오른쪽 자식중 가장 작은 값으로 대체한다.
         3. 대체한 값(가장 크거나 작은)이 역시 자식노드를 가지고 있다면 2-3의 과정을 반복한다.






  

원시 정렬 알고리즘

선택정렬 : Θ(n*n)
버블정렬 : 최악 Θ(n*n) 최상 Θ(n)
삽입정렬 : Θ(n*n)


선택정렬 알고리즘 : 

123456 -> 이건 인덱스
936405  : 가장큰수 9를 찾는다 n
536409 : 맨 뒤에 숫자와 바꾼다 1
            가장큰수 6를 찾는다 n-1
530469 : n-1번째 숫자와 바꾼다.

n+(n-1)+(n-2) ... +1 의 시간이 걸림

= n(n+1)/2 이므로 Θ(n*n) 이다.


버블정렬 알고리즘 :

956405 : 맨앞부터 두개씩 비교해나간다. 01 12 23 34...
596405 : 순서대로 되어있지 않으면 바꾼다 ...............상수
569405
564905
564095
564059 : 요까지 n-1 , 1바퀴

반복한다

n-1 + n-2 + n-3 + ... + 1 = n(n-1)/2 = 
Θ(n*n)

하지만 맨앞부터 두자리씩 비교하내가다가 결국 m바퀴 째에서 우연히 순서가 잘못되어 있는 것이 없다면
그 시점에서 정렬은 종료된다. 운이좋다면 처음부터 정렬되어 있는 배열일수도 있고 이때 시간은 
Θ(n)이다,
최악의 경우(역순으로 정렬되어있을경우)에 
Θ(n*n)의 시간이 걸린다.


삽입정렬 알고리즘 :
앞에서부터 적당한 위치를 찾아 정리한다.

956405 ... 9를 어디에 넣을것인가? .... 1
596405 ... 5를 어디에 넣을것인가?
569405 ... 6을 어디에 넣을것인가?
456905 ... 4을 어디에 넣을것인가? .... n-3
045695 ... 0을 어디에 넣을것인가? .... n-2
045569 ... 5를 어디에 넣을것인가? .... n-1

n-1 + n-2 + n-3 + ... + 1 = n(n-1)/2 = Θ(n*n)


고급정렬 알고리즘

병합정렬 Θ(n log n)
퀵정렬 평균 Θ(n*n) , O(n*n)
힙정렬 Θ(n log n)

병합정렬

9 23 96 3 2 7 49 33 12
        (mergeSort1)
9 23 96 3     2
7 49 33 12
 (mS2)           (mS7) 

9 23         96 3        2 7       49 33 12
(mS3)     (mS5)      (mS8)     (mS10) 
9    23      96  3        2    7     49    33 12

                                                  (mS11) 

                                                 33     12
                                                 (merge12)
                                                     12 33

(merge4)  (merge6)  (merge9)   (merge13)
9 23            3 96          2 7          12 33 49
      (merge3)                   (merge14)
       3 9 23 96                      2 7 12 33 49
                      (merge15)
                     2 3 7 9 12 23 33 49


퀵정렬
9 23 96 3 2 7 49 33 12

9 23 96 3 2 7 49 33 12   맨 뒤에 숫자를 기준으로 
9 3 2 7 12 23 96 49 33   작은 숫자는 왼쪽, 큰숫자는 오른쪽에 배치

9 3 2 7 12 23 96 49 33   왼쪽, 오른쪽 각각 독립적으로 위의 과정을 반복
3 2 7 9 12 23 33 96 49 

3 2 7 9 12 23 33 96 49
2 3 7 9 12 23 33 49 96  이렇게


힙정렬

 



                 



배열 (Array List)

장점 : 직관적이고 데이터의 접근속도가 빠르다. 비교적 다른 자료구조에 의해 저장공간의 낭비가 없다.
단점 : 삽입과 삭제에 엄청난 시간이 소모된다. 크기가 정적이기 때문에 데이터 포화시 크기를 재조정 하는 연산을 해주어야 하며, 적지않은 비용이 소모된다.

배열의 삽입

1234567   ->나름 인덱스
abcefgh  이곳에 빠진 d를 삽입해봅시다.

12345678
abcefg h
abcef gh
abce fgh
abc efgh
abcdefgh  음... 이와같이 총 5번의 작업을 하게됨. 만약 배열의 길이가 100만 넘어가도 후월털러털..

삭제는 안함


링크드리스트 (Linked List)

:여러게의 노드가 선형으로 이루어져있으며, 각 노드는 데이터와 다음 노드를 가리키는 링크로 이루어져있다.

장점 :  데이터 크기와 상관없이 삽입과 삭제에 있어서 용이하다. 2단계의 수행단계면 충분. 연속적인 기억장소의 할당이 필요하지 않다. 시작 주소만 알고있으면 연속된 데이터에 접근하기가 쉽다.
단점 : i번째 데이터를 추출할 시에 head부터 n-1번만큼 링크를 타고들어가야 하기 때문에 탐색속도에서 약점을 가지고 있다. 포인터의 사용으로 저장공간의 낭비를 초래할 수 있다.



head....a-b,,,, tail    에 노드  c를 삽입

c 링크를 b로 설정
a 링크를 c로 설정 (과 동시에 a-b링크는 삭제)

a-c-b 에서 c를 삭제 시

a링크를 b링크에 연결
c링크를 null로 설정


그런데..
배열이나 링크드 리스트에서 값이 100인 값을 찾고싶을땐 뭐 비슷한 시간이 걸리겠지..?
가 아니라 배열은 메모리에 연속적으로 적재가 된다. 반면 링크드 리스트는 노드 하나하나가 드레곤볼처럼 여기저기에 저장이 되기 떄문에 포인터로 다음 노드를 찾는데 그만큼에 탐색시간이 오버플로우 된다는 것이다.

여튼 색인탐색에서는 배열 O(1) vs 링크드 리스트 O(n) 이고
값탐색(?) 에서는 배열 O(n) vs 링크드리스트 O(n)+알파 라는 것이다.

무튼 탐색은 배열 / 삽입삭제는 링크드리스트, 따라서 경우에 따라 더좋은 자료구조를 선택하도록 하자


트랜젝션의 네가지 속성


Atomicity (원자성) : 트랜잭션 내에 모든 작업이 완료되거나 모든 작업이 완료되지 않아야 한다.(?)
즉, 트랜잭션 내의 작업중 하나라도 에러가 발생하면 트랜잭션 내의 모든 작업이 롤백(Rollback) 되어야 한다.


Consistency(일관성) : 트랜잭션 중에 오류 없이 유효한 데이터만 데이터베이스에 저장되어야 한다.


Isolation(격리성) : 트랜잭션 중에 변경된 내용이 트랜잭션이 완료되기 전까지 다른 트랜잭션에 영향을 미쳐서는 안된다.


Durability(지속성) 트랜잭션이 완료된 경우 시스템 고장이나 네트워크 에러 등으로 데이터가 유실되지 않고 정상적으로 기록되어야 한다.





'~ 2014 > Database' 카테고리의 다른 글

클러스터드 인덱스 / 넌클러스터드 인덱스 / primary 인덱스  (0) 2014.06.15
트리거 trigger  (0) 2014.06.14
DDL / DML / DCL  (0) 2014.06.13


'~ 2014 > 기본개념' 카테고리의 다른 글

처리장치 속도  (0) 2014.06.15
캐스팅 / 박싱  (0) 2014.06.14
RGB 색상 수  (0) 2014.06.12
프로그래밍(절차지향, 객체지향, 모듈)  (0) 2014.06.12

캐시 : cpu가 주기억장치에서 처리할 데이터를 미리 읽어다주는 역할을 했던가..? 무튼 비쌈
    L1 캐시(캐시) : cpu 내부에 달려있는 캐쉬메모리 겁나빠르다
    L2 캐시(2차캐시): cpu 외부에 달려있는 캐쉬메모리 일반적으로 말하는 cpu와 구분되는 캐시

cpu(중앙처리장치) : 캐시메모리보다 느림. 근대 빠름.

주기억장치 : 램(휘발), 롬(읽지전용, 비휘발, 부팅등 환경설정에 필요한 데이터를 써놓는용도)등

보조키억장치 : usb, cd, 플로피티드스, 하드디스크(자기테잎) 등


위에서부터 빠른순

'~ 2014 > 기본개념' 카테고리의 다른 글

운영체제 스케쥴링 정책  (0) 2014.06.15
캐스팅 / 박싱  (0) 2014.06.14
RGB 색상 수  (0) 2014.06.12
프로그래밍(절차지향, 객체지향, 모듈)  (0) 2014.06.12

+ Recent posts