Post on 14-Jan-2017
1 0 1 0 1 0 1 0 1 0 1 0 0 0 0 0
0 1 0 1 0 1 0 1 0 1 0 1 0 0 0 1
0 1 0 1 0 1 0 1 0 0 1 0 1 0 1 0
1 0 1 0 1 0 1 0 1 0 1 0 0 1 0 1
DATA STRUCTURES
@Override
public void add(Node<T> node) {
Node pointer = header;
while (pointer.next != null) {
pointer = pointer.next;}pointer.next = node;
size++;}
기본정렬 · 효율정렬 · 초효율정렬
A
B
H
G
front
rear
TABLE OF CONTENTS
SHOUT OUR PASSION TOGETHER DATA STRUCTURES INDEX
006
007
010
011
013
014
016
017
019
020
023
선택정렬 - 개요
선택정렬 - 연산
선택정렬 - 코드분석
선택정렬 - 성능분석
삽입정렬 - 개요
삽입정렬 - 연산
삽입정렬 - 코드분석
삽입정렬 - 성능분석
버블정렬 - 개요
버블정렬 - 연산
버블정렬 - 코드분석
024버블정렬 – 성능 분석
TABLE OF CONTENTS
SHOUT OUR PASSION TOGETHER DATA STRUCTURES INDEX
026
027
029
031
032
033
041
042
045
046
047
병합정렬 – 개념
병합정렬 - 수행과정
병합정렬 - 코드분석
병합정렬 - 성능분석
퀵정렬 - 개념
퀵정렬 - 수행과정
퀵정렬 - 코드분석
퀵정렬 - 성능분석
기수정렬 - 개념
기수정렬 - 특징
기수정렬 - 수행과정
061기수정렬 – 코드 분석
TABLE OF CONTENTS
SHOUT OUR PASSION TOGETHER DATA STRUCTURES INDEX
063
064
066
067
068
069
076
078
기수정렬 – 적용사례
기수정렬 - 성능분석
계수정렬 - 개념
계수정렬 - 원리
계수정렬 - 특징
계수정렬 - 수행과정
계수정렬 - 코드분석
계수정렬 - 성능분석
선택정렬개념 · 코드 분석 · 성능분석
Study - Data Structures
선택정렬개요
전체원소들중위치에맞는원소를선택해자리를교환하는방식으로정렬
Study - Data Structures
선택정렬연산
69 10 30 2 16 8 31 22
1. 주어진리스트에서최소값을선택
target
Study - Data Structures
2 10 30 69 16 8 31 22
선택정렬연산
69 10 30 2 16 8 31 22
2. 그값을맨앞에위치한값과교체
before
after
2 10 30 69 16 8 31 22
Study - Data Structures
2 8 30 69 16 10 31 22
선택정렬연산
3. 정렬된원소를제외한나머지리스트를대상으로교체를 반복
before
after
Study - Data Structures
public class Selection_sort<E> {//selection sortpublic static <E extends Comparable<E>> void
selectionSort(E[] list) {
for(int i=0; i<list.length -1; i++) {
int iSmallest = i;
for(int j=i+1; j<list.length; j++) {if(list[iSmallest].compareTo((list[j])) > 0
) {iSmallest = j;
}}
E iSwap = list[iSmallest];list[iSmallest] = list[i];list[i] = iSwap;
}}
}
선택정렬코드분석
주어진리스트에서 최소값을 찾는다 (isSmallest)
찾은최소값을 리스트의맨 앞의원소와교체
교체된맨 앞의원소를 제외한 나머지 리스트를대상으로반복 실행
Study - Data Structures
선택정렬성능분석
메모리사용공간
연산시간
1단계 : 첫번째원소를기준으로 n 개의원소비교2단계 : 두번째원소를기준으로마지막원소까지 n – 1개의원소비교3단계 : 세번째원소를기준으로마지막원소까지 n – 2개의원소비교
…
i 단계 : i 번째원소를기준으로마지막원소까지 n – i 개의원소비교
평균시간복잡도
O (n²)
O (n) : n 개의원소에대하여 n 개의메모리사용
삽입정렬개념 · 코드 분석 · 성능분석
Study - Data Structures
삽입정렬개요
정렬되어있는부분집합에새로운원소의위치를찾아삽입하는방식으로정렬
Study - Data Structures
삽입정렬연산
1. 두번째리스트를첫번째리스트와비교하여 적절한위치에삽입
첫번째리스트는하나이기때문에정렬이되어있다고가정하고두번째리스트부터시작한다
10 69 30 2 16 8 31 22
69 10 30 2 16 8 31 22before
after
Study - Data Structures
삽입정렬연산
2. 위와같은리스트가끝날때까지계속해서삽입
10 30 69 2 16 8 31 22
69 10 30 2 16 8 31 22before
after
Study - Data Structures
public class Insertion_sort<T> {
public <T extends Comparable<T>> void doInsertionSort(T[] input) {
if (input == null) {throw new RuntimeException("Input array
cannot be null");}int length = input.length;if (length == 1) return;int i, j;T temp;for (i = 1; i < length; i++) {
temp = input[i];
for (j = i; (j > 0 && (temp.compareTo(input[j - 1]) < 0)); j--) {
input[j] = input[j - 1];}
input[j] = temp;}
}}
삽입정렬코드분석
두번째원소 부터앞의 정렬된리스트와비교하여적절한자리에 삽입정렬하고자하는 원소를 temp에 임의저장
삽입된 후다음 원소(세번째원소)를 대상으로반복실행
Study - Data Structures
삽입정렬성능분석
메모리사용공간
O (n) : n 개의원소에대하여 n 개의메모리사용
연산시간
평균시간복잡도
O (n²) : 평균비교횟수는 n (n-1) / 4
1. 최선의경우
원소들이이미정렬되어있어서비교횟수가최소인경우, 바로앞자리원소와한번만비교한다전체비교횟수는 n – 1이며, 시간복잡도는 O (n)이다
2. 최악의경우
모든원소가역순으로되어있는경우비교횟수가최대이므로전체비교횟수는 n (n – 1) / 2이며, 시간복잡도는 O (n²)이다
버블정렬개념 · 코드 분석 · 성능분석
Study - Data Structures
버블정렬개요
인접한두개의원소를비교하여자리를교환하는정렬
Study - Data Structures
버블정렬연산
1. 인접한두인덱스를비교해서정렬이되어있지않을 경우정렬
10 69 30 2 16 8 31 22
69 10 30 2 16 8 31 22before
after
Study - Data Structures
버블정렬연산
2. 1을반복하여가장큰 원소를가장마지막으로정렬
10 30 69 2 16 8 31 22
10 69 30 2 16 8 31 22
10 30 2 16 8 31 22 69
before
result
after
Study - Data Structures
버블정렬연산
3. 마지막에정렬한요소를제외한나머지리스트로위 과정을반복
10 2 16 8 30 22 31 69
10 30 2 16 8 31 22 69
2 8 10 16 22 30 31 69
before
result
after
Study - Data Structures
public class Bubble_sort<E> {
public static <E> void bubbleSort(E[] unsorted) {
for(int iter =1; iter< unsorted.length; iter++){
for(int inner = 0; inner < unsorted.length - iter; inner ++){
if((((Comparable)(unsorted[inner])).compareTo(unsorted[inner+1])) > 0){
E tmp = unsorted[inner];unsorted[inner] = unsorted[inner + 1];unsorted[inner + 1] = tmp;
}}
}}
}
버블정렬코드분석
리스트의첫 원소부터바로 인접한다음원소와비교
두원소를 비교하여더 큰원소를temp 에저장하고 둘중 뒤에배열
같은방법으로 가장큰 수가리스트의가장마지막에 정렬될때까지 반복실행
정렬된 리스트를제외한 나머지를대상으로반복실행
Study - Data Structures
버블정렬성능분석
메모리사용공간
O (n) : n 개의원소에대하여 n 개의메모리사용
연산시간
1. 최선의경우 : 자료가이미정렬되어있음전체비교횟수는 n (n – 1) / 2이며, 자리교환횟수는없다
2. 최악의경우 : 자료가역순으로정렬되어있음전체비교횟수는 n (n – 1) / 2이며, 자리교환횟수또한 n (n – 1) / 2이다
평균시간복잡도
O (n²)
병합정렬개념 · 코드 분석 · 성능분석
Study - Data Structures
병합정렬개념
분할정복기법을사용한다
집합을분할하고 각부분 집합에대해정렬 작업을완성한후 다시병합하는 과정반복
여러개의정렬된자료의집합을병합하여한개의정렬된집합으로만드는정렬방식이다
Study - Data Structures
병합정렬수행과정
1
7
6
3
8
4
5
2
5
2
1
2
3
4
5
6
7
8
1
7
6
3
8
4
5
2
1
7
6
3
8
4
5
2
8
4
6
3
1
7
1
7
3
6
4
8
2
5
1
3
6
7
2
4
5
8
Study - Data Structures
병합정렬수행과정
1
7
6
3
8
4
5
2
5
2
1
2
3
4
5
6
7
8
1
7
6
3
8
4
5
2
1
7
6
3
8
4
5
2
8
4
6
3
1
7
1
7
3
6
4
8
2
5
1
3
6
7
2
4
5
8
1.분할 : 전체자료의집합에 대해최소원소의 부분집합이될 때까지작업반복
2.병합 : 2개의부분집합을정렬하면서하나의 집합으로병합하며,모든 요소를병합할때까지 반복
병합정렬
Study - Data Structures
최소원소를 가질때 까지두부분으로 분할
public class MergeSort<T> {
public <T extends Comparable<T>> void MergeSort(T[] a) {MergeSort(a, 0, a.length - 1);
}
public <T extends Comparable<T>> void MergeSort(T[] a, int left, int right){
if (right - left < 1) return;int mid = (left + right) / 2;
MergeSort(a, left, mid); MergeSort(a, mid + 1, right);
merge(a, left, mid, right);}
코드분석
Study - Data Structures
병합정렬코드분석
public <T extends Comparable<T>> void merge(T[] a, int left, int mid, int right) {
Object[] tmp = new Object[right - left + 1];int L = left; int R = mid + 1; int S = 0;
while (L <= mid && R <= right) { if (a[L].compareTo(a[R]) <= 0)
tmp[S] = a[L++]; else
tmp[S] = a[R++]; S++;
}
if (L <= mid && R > right) { while (L <= mid)
tmp[S++] = a[L++];} else {
while (R <= right)tmp[S++] = a[R++];
}
for (S = 0; S < tmp.length; S++) { a[S + left] = (T) (tmp[S]);
}
}}
왼쪽, 오른쪽파트 중한쪽이 다정렬될 때까지부분집합의 원소를비교하며 병합
오른쪽파트가먼저 정렬이끝난 경우
데이터이동
왼쪽파트가먼저 정렬이끝난 경우
Study - Data Structures
병합정렬성능분석
메모리사용공간
O (n) : n 개의원소에대하여 n 개의메모리사용, 경우에따라 log (n) 개의추가메모리필요
연산시간
1. 분할 : n 개의원소에대해평균적으로 log (n) 번분할수행
2. 병합 : 부분집합의원소를비교하면서병합하는단계에서최대 n 번의비교연산수행
평균시간복잡도
O (n log n)
퀵정렬개념 · 코드 분석 · 성능분석
Study - Data Structures
퀵정렬개념
피봇 (= 기준값)을중심으로왼쪽 · 오른쪽집합으로분할하고정렬한다
분할정복기법을사용한다
평균적으로매우빠른수행속도를자랑하는정렬방식이다
왼쪽부분집합에는피봇보다작은값을, 오른쪽부분집합에는피봇보다큰값을넣는다
피봇은일반적으로가운데에위치한원소를선택한다
Study - Data Structures
퀵정렬수행과정
4 5 3 6 2 1 10 9
Study - Data Structures
퀵정렬수행과정
4 5 3 6 2 1 10 9
P : 비교 기준이되는피벗을 설정한다
R : 피벗기준으로 오른쪽에둘요소들을 포인팅한다
L : 피벗 기준으로왼쪽에둘 요소들을포인팅한다
Study - Data Structures
퀵정렬수행과정
4 5 3 6 2 1 10 9
P R
L
L을만날때까지오른쪽으로이동한다
R을만날때까지왼쪽으로이동한다
Study - Data Structures
퀵정렬수행과정
4 5 3 6 2 1 10 9
P R
L
L과 R이만나기전에다음조건을만족하면두값을바꿔준다
- 기준값이 L보다큰경우- 기준값보다 R의값이큰경우
Study - Data Structures
퀵정렬수행과정
4 1 3 6 2 5 10 9
P R
L
Study - Data Structures
퀵정렬수행과정
4 1 3 6 2 5 10 9
P R
L
Study - Data Structures
퀵정렬수행과정
4 1 3 2 6 5 10 9
P R
L
Study - Data Structures
퀵정렬수행과정
4 1 3 2 6 5 10 9
P R
L
L <= R 을 만족할경우, 서브리스트로 위과정을반복한다
Study - Data Structures
L은 오른쪽이동하며 Pivot보다크거나같은 값찾기
R은왼쪽이동하며 Pivot 보다작은값 찾기
퀵 정렬코드분석
public class QuickSort<T> {
public <T extends Comparable<T>> void QuickSort(T[] array) {quick_sort(array, 0, array.length - 1);
}
public static <T extends Comparable<T>> void quick_sort(T[] arr, int left, int right) {
if (left < right) {int L = left, R = right;T pivot = arr[(L + R) / 2];
do {while (arr[L].compareTo(pivot) < 0) L++;
while (pivot.compareTo(arr[R]) < 0) R--;
if (L <= R) {T tmp = arr[L];arr[L] = arr[R];arr[R] = tmp;L++;R--;
}
} while (L <= R);
quick_sort(arr, left, R);quick_sort(arr, L, right);
}}
}
서브리스트로 위과정을 반복
Pivot 값을 임의지정
L과 R이가르키는값바꾸기
Study - Data Structures
퀵정렬성능분석
메모리사용공간
O (n) : n 개의원소에대하여 n 개의메모리사용
연산시간
1. 최선의경우 : 피봇에대해원소들이정확히 n / 2 크기의 2개의집합으로나눠짐
전체비교횟수는 n – 1이다
2. 최악의경우 : 자료가역순으로정렬되어있음
전체비교횟수는 n (n – 1) / 2이다
평균시간복잡도
O (n log n) : 같은시간복잡도를가지는다른정렬방법에비해자리교환횟수를줄여서더성능이좋음
기수정렬개념 · 코드 분석 · 사용사례 · 성능 분석
Study - Data Structures
기수정렬개념
Bucket을사용하여원소를정렬하며주로큐를사용한다
원소의키값을나타내는기수를이용한정렬방법이다
정렬할원소의키값에해당하는 Bucket에원소를분배하고 Bucket의순서대로꺼내정렬한다
Study - Data Structures
기수정렬특징
장점
단점
안정적인정렬이다 - 키값이같은원소의순서에대해정렬후에도순서가유지된다
정렬방식의이론적하한선 - O (n log n)의성능을능가하는효율적인정렬
정렬할수있는데이터의타입이한정되어있다
버켓을구현하기위한별도의메모리를필요로한다
Study - Data Structures
기수정렬수행과정
1. 원소의키값에해당하는큐에원소를분배
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
69 10 30 2 16before
after
Study - Data Structures
기수정렬수행과정
1. 원소의키값에해당하는큐에원소를분배
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
69
69 10 30 2 16before
after
Study - Data Structures
기수정렬수행과정
1. 원소의키값에해당하는큐에원소를분배
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
10 69
69 10 30 2 16before
after
Study - Data Structures
기수정렬수행과정
1. 원소의키값에해당하는큐에원소를분배
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
10 69
30
69 10 30 2 16before
after
Study - Data Structures
기수정렬수행과정
1. 원소의키값에해당하는큐에원소를분배
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
10 2 69
30
69 10 30 2 16before
after
Study - Data Structures
기수정렬수행과정
1. 원소의키값에해당하는큐에원소를분배
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
10 2 16 69
30
69 10 30 2 16before
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
10 2 16 69
30
69 10 30 2 16
10
before
after
2. 버켓의순서대로원소를꺼내재분배
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
30 2 16 69
69 10 30 2 16
10 30
before
2. 버켓의순서대로원소를꺼내재분배
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
2 16 69
69 10 30 2 16
10 30 2
before
2. 버켓의순서대로원소를꺼내재분배
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
16 69
69 10 30 2 16
10 30 2 16
before
2. 버켓의순서대로원소를꺼내재분배
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
69
69 10 30 2 16
10 30 2 16 69
before
2. 버켓의순서대로원소를꺼내재분배
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
69 10 30 2 16
10 30 2 16 69
before
2. 버켓의순서대로원소를꺼내재분배
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
2 10 30 69
16
10 30 2 16 69before
3. 키값의자릿수만큼위의과정을반복
after
Study - Data Structures
기수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
2 10 30 69
16
10 30 2 16 69
2 10 16 30 69
before
3. 키값의자릿수만큼위의과정을반복
after
Study - Data Structures
기수정렬코드분석
원소들의 최대 자릿수를 구해줌
큐 생성
큐에 넣어주는 과정
public void radixsort(T[] arr){int max_digit = 0;//최대 자릿수를 구해줌for(int i=0; i< arr.length; i++) {
if(arr[i].toString().length() > max_digit)max_digit =arr[i].toString().length();
}
Queue<T>[] queues = new Queue[52];for(int i=0; i<queues.length;i++){
queues[i] = new Queue<T>();}
for(int i=0;i<max_digit;i++) {
for (int j = 0; j < arr.length; j++) {Node<T> node = new Node(arr[j]);int digit = arr[j].toString().length() -
(i+1);if(digit<0){
queues[0].enqueue(node);}else {
String idx = arr[j].toString().substring(digit, digit + 1);
char[] chars = idx.toCharArray();if(chars[0]>=48 && chars[0]<=57) { //
숫자일 경우
queues[Integer.parseInt(idx)].enqueue(node);}else{ //문자일 경우
queues[alphaToInt(chars[0])].enqueue(node);}
}}
비교할 자릿수를 구해줌(digit)
숫자일 경우와 문자일 경우로 나누어enqueue 해줌
Study - Data Structures
기수정렬코드분석
큐에서 차례대로 꺼내어 정렬
int newArrayIndex=0;for (int j = 0; j < queues.length; j++) {
while (!queues[j].isEmpty()) {arr[newArrayIndex++] =
queues[j].dequeue().t;}
}}
}private int alphaToInt(char alphabet){
if(alphabet>=65 && alphabet<=90) return (alphabet-65); // 대문자
else return (alphabet-97+26); //소문자}
기수정렬적용사례
Study - Data Structures
전화번호 정렬 날짜 정렬 주민번호 정렬
Study - Data Structures
기수정렬성능분석
메모리사용공간
O (n) : n 개의원소에대하여버킷을포함한 2n 개의메모리사용
연산시간
1. 실제 : kn
최대자릿수를 k라할때, k번동안 n개의원소가큐에대입되고꺼내어져정렬
2. 이론 : n
대부분의컴퓨터가다룰수있는자릿수가 n에비해현저하게작으므로,고려되지않음
평균시간복잡도
O (n)
계수정렬개념 · 원리 ·특징 · 수행 과정 · 코드분석 · 성능 분석
Study - Data Structures
계수정렬개념
각원소가몇개씩있는지세는과정을통해원소를정렬하는방식이다
Study - Data Structures
계수정렬원리
자기자신보다작은원소의갯수를알면해당원소의위치가결정된다
Study - Data Structures
계수정렬특징
장점
단점
안정적인정렬이다 - 키값이같은원소의순서에대해정렬후에도순서가유지된다
속도가비교적빠른편이다
버켓을사용하므로, 정렬할수있는데이터의타입이한정되어있다
기수정렬과마찬가지로버켓을구현하기위한별도의메모리를필요로한다
Study - Data Structures
계수정렬수행과정
1. 해당원소의값을인덱스로하는 count 배열을사용하여각 원소의개수를셈
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 0 0 0 0 0 0 0 0 0
9 1 7 2 1 8 1 2before
after
Study - Data Structures
계수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 3 2 0 0 0 0 1 1 1
9 1 7 2 1 8 1 2before
count
after
1. 해당원소의값을인덱스로하는 count 배열을사용하여각 원소의개수를셈
Study - Data Structures
계수정렬수행과정
2. count 배열의첫원소부터차례대로갯수를세어재배치
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 3 2 0 0 0 0 1 1 1
9 1 7 2 1 8 1 2
1 1 1
before
after
count
Study - Data Structures
계수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 3 2 0 0 0 0 1 1 1
9 1 7 2 1 8 1 2
1 1 1 2 2
before
after
count
2. count 배열의첫원소부터차례대로갯수를세어재배치
Study - Data Structures
계수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 3 2 0 0 0 0 1 1 1
9 1 7 2 1 8 1 2
1 1 1 2 2 7
before
after
count
2. count 배열의첫원소부터차례대로갯수를세어재배치
Study - Data Structures
계수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 3 2 0 0 0 0 1 1 1
9 1 7 2 1 8 1 2
1 1 1 2 2 7 8
before
after
count
2. count 배열의첫원소부터차례대로갯수를세어재배치
Study - Data Structures
계수정렬수행과정
queue[0] queue[1] queue[2] queue[3] queue[4] queue[5] queue[6] queue[7] queue[8] queue[9]
0 3 2 0 0 0 0 1 1 1
9 1 7 2 1 8 1 2
1 1 1 2 2 7 8 9
before
after
count
2. count 배열의첫원소부터차례대로갯수를세어재배치
Study - Data Structures
계수정렬코드분석
HashMap생성
Map에있으면 추가,�없으면 만들어서 추가
정렬된 item�순서대로 출력
public static void sort(ArrayList<ICompare> source) {
HashMap<Integer, ArrayList<ICompare>> map = new HashMap<>();
for (ICompare item : source) {if (map.containsKey(item.identifier()))
{
map.get(item.identifier()).add(item);} else {
ArrayList<ICompare> line = new ArrayList<>();
line.add(item);map.put(item.identifier(), line);
}}
for (int key : map.keySet())for (ICompare item : map.get(key))
System.out.println(item);}
public class Data implements ICompare<Data> {
private static Random random = new Random();
public int id;public String name;public String association;
public Data(String name, String association) {this.name = name;this.association = association;
this.id = random.nextInt(10);}
@Overridepublic int identifier() { return id; }@Overridepublic boolean equals(Object obj) {
if (!(obj instanceof Data)) return false;return obj == this || this.id == ((Data)
obj).id;}@Overridepublic String toString() {
return "id : " + id + " / " + name + " / " + association;
}}
Study - Data Structures
계수정렬코드분석
public interface ICompare<T> {
int identifier();}
ICompare를 implements한 Data클래스
생성자
Override한 메소드
Study - Data Structures
계수정렬성능분석
메모리사용공간
O (n + k) : n 개의원소에대하여 n 개 + 원소의범위에해당하는 k 개의메모리사용
연산시간
전체원소의범위를체크하고갯수를측정하는횟수는 n 번이며
위에서측정한내용을기반으로정렬결과를구성하는연산은 k 번실행된다
평균시간복잡도
O (n) : 원래시간복잡도는O (n + k)이나, k가O(n)이하의작은범위에서사용되므로O(n)에근사한다