[sopt] 데이터 구조 및 알고리즘 스터디 - #03 : 정렬 (기본, 효율, 초효율

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


026

027

029

031

032

033

041

042

045

046

047

병합정렬 – 개념

병합정렬 - 수행과정

병합정렬 - 코드분석

병합정렬 - 성능분석

퀵정렬 - 개념

퀵정렬 - 수행과정

퀵정렬 - 코드분석

퀵정렬 - 성능분석

기수정렬 - 개념

기수정렬 - 특징

기수정렬 - 수행과정

061기수정렬 – 코드 분석

TABLE OF CONTENTS


063

064

066

067

068

069

076

078

기수정렬 – 적용사례

기수정렬 - 성능분석

계수정렬 - 개념

계수정렬 - 원리

계수정렬 - 특징

계수정렬 - 수행과정

계수정렬 - 코드분석

계수정렬 - 성능분석

선택정렬개념 · 코드 분석 · 성능분석

Study - Data Structures

선택정렬개요

전체원소들중위치에맞는원소를선택해자리를교환하는방식으로정렬


선택정렬연산

69 10 30 2 16 8 31 22

1. 주어진리스트에서최소값을선택

target


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


2 8 30 69 16 10 31 22

선택정렬연산

3. 정렬된원소를제외한나머지리스트를대상으로교체를 반복

before

after


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)

찾은최소값을 리스트의맨 앞의원소와교체

교체된맨 앞의원소를 제외한 나머지 리스트를대상으로반복 실행


선택정렬성능분석

메모리사용공간

연산시간

1단계 : 첫번째원소를기준으로 n 개의원소비교2단계 : 두번째원소를기준으로마지막원소까지 n – 1개의원소비교3단계 : 세번째원소를기준으로마지막원소까지 n – 2개의원소비교

…

i 단계 : i 번째원소를기준으로마지막원소까지 n – i 개의원소비교

평균시간복잡도

O (n²)

O (n) : n 개의원소에대하여 n 개의메모리사용

삽입정렬개념 · 코드 분석 · 성능분석


삽입정렬개요

정렬되어있는부분집합에새로운원소의위치를찾아삽입하는방식으로정렬


삽입정렬연산

1. 두번째리스트를첫번째리스트와비교하여 적절한위치에삽입

첫번째리스트는하나이기때문에정렬이되어있다고가정하고두번째리스트부터시작한다

10 69 30 2 16 8 31 22

69 10 30 2 16 8 31 22before

after


삽입정렬연산

2. 위와같은리스트가끝날때까지계속해서삽입

10 30 69 2 16 8 31 22

69 10 30 2 16 8 31 22before

after


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에 임의저장

삽입된 후다음 원소(세번째원소)를 대상으로반복실행


삽입정렬성능분석



연산시간


O (n²) : 평균비교횟수는 n (n-1) / 4

1. 최선의경우

원소들이이미정렬되어있어서비교횟수가최소인경우, 바로앞자리원소와한번만비교한다전체비교횟수는 n – 1이며, 시간복잡도는 O (n)이다

2. 최악의경우

모든원소가역순으로되어있는경우비교횟수가최대이므로전체비교횟수는 n (n – 1) / 2이며, 시간복잡도는 O (n²)이다

버블정렬개념 · 코드 분석 · 성능분석


버블정렬개요

인접한두개의원소를비교하여자리를교환하는정렬


버블정렬연산

1. 인접한두인덱스를비교해서정렬이되어있지않을 경우정렬

10 69 30 2 16 8 31 22

69 10 30 2 16 8 31 22before

after


버블정렬연산

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


버블정렬연산

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


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 에저장하고 둘중 뒤에배열

같은방법으로 가장큰 수가리스트의가장마지막에 정렬될때까지 반복실행

정렬된 리스트를제외한 나머지를대상으로반복실행


버블정렬성능분석



연산시간

1. 최선의경우 : 자료가이미정렬되어있음전체비교횟수는 n (n – 1) / 2이며, 자리교환횟수는없다

2. 최악의경우 : 자료가역순으로정렬되어있음전체비교횟수는 n (n – 1) / 2이며, 자리교환횟수또한 n (n – 1) / 2이다


O (n²)

병합정렬개념 · 코드 분석 · 성능분석


병합정렬개념

분할정복기법을사용한다

집합을분할하고 각부분 집합에대해정렬 작업을완성한후 다시병합하는 과정반복

여러개의정렬된자료의집합을병합하여한개의정렬된집합으로만드는정렬방식이다


병합정렬수행과정

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

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개의부분집합을정렬하면서하나의 집합으로병합하며,모든 요소를병합할때까지 반복

병합정렬


최소원소를 가질때 까지두부분으로 분할

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);}

코드분석


병합정렬코드분석

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]);

}

}}

왼쪽, 오른쪽파트 중한쪽이 다정렬될 때까지부분집합의 원소를비교하며 병합

오른쪽파트가먼저 정렬이끝난 경우

데이터이동

왼쪽파트가먼저 정렬이끝난 경우


병합정렬성능분석


O (n) : n 개의원소에대하여 n 개의메모리사용, 경우에따라 log (n) 개의추가메모리필요

연산시간

1. 분할 : n 개의원소에대해평균적으로 log (n) 번분할수행

2. 병합 : 부분집합의원소를비교하면서병합하는단계에서최대 n 번의비교연산수행


O (n log n)

퀵정렬개념 · 코드 분석 · 성능분석


퀵정렬개념

피봇 (= 기준값)을중심으로왼쪽 · 오른쪽집합으로분할하고정렬한다

분할정복기법을사용한다

평균적으로매우빠른수행속도를자랑하는정렬방식이다

왼쪽부분집합에는피봇보다작은값을, 오른쪽부분집합에는피봇보다큰값을넣는다

피봇은일반적으로가운데에위치한원소를선택한다


퀵정렬수행과정

4 5 3 6 2 1 10 9



4 5 3 6 2 1 10 9

P : 비교 기준이되는피벗을 설정한다

R : 피벗기준으로 오른쪽에둘요소들을 포인팅한다

L : 피벗 기준으로왼쪽에둘 요소들을포인팅한다



4 5 3 6 2 1 10 9

P R

L

L을만날때까지오른쪽으로이동한다

R을만날때까지왼쪽으로이동한다



4 5 3 6 2 1 10 9

P R

L

L과 R이만나기전에다음조건을만족하면두값을바꿔준다

- 기준값이 L보다큰경우- 기준값보다 R의값이큰경우



4 1 3 6 2 5 10 9

P R

L



4 1 3 2 6 5 10 9

P R

L



4 1 3 2 6 5 10 9

P R

L

L <= R 을 만족할경우, 서브리스트로 위과정을반복한다


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이가르키는값바꾸기


퀵정렬성능분석



연산시간

1. 최선의경우 : 피봇에대해원소들이정확히 n / 2 크기의 2개의집합으로나눠짐

전체비교횟수는 n – 1이다

2. 최악의경우 : 자료가역순으로정렬되어있음

전체비교횟수는 n (n – 1) / 2이다


O (n log n) : 같은시간복잡도를가지는다른정렬방법에비해자리교환횟수를줄여서더성능이좋음

기수정렬개념 · 코드 분석 · 사용사례 · 성능 분석


기수정렬개념

Bucket을사용하여원소를정렬하며주로큐를사용한다

원소의키값을나타내는기수를이용한정렬방법이다

정렬할원소의키값에해당하는 Bucket에원소를분배하고 Bucket의순서대로꺼내정렬한다


기수정렬특징

장점

단점

안정적인정렬이다 - 키값이같은원소의순서에대해정렬후에도순서가유지된다

정렬방식의이론적하한선 - O (n log n)의성능을능가하는효율적인정렬

정렬할수있는데이터의타입이한정되어있다

버켓을구현하기위한별도의메모리를필요로한다


기수정렬수행과정

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





69

69 10 30 2 16before

after





10 69

69 10 30 2 16before

after





10 69

30

69 10 30 2 16before

after





10 2 69

30

69 10 30 2 16before

after





10 2 16 69

30

69 10 30 2 16before

after




10 2 16 69

30

69 10 30 2 16

10

before

after

2. 버켓의순서대로원소를꺼내재분배




30 2 16 69

69 10 30 2 16

10 30

before


after




2 16 69

69 10 30 2 16

10 30 2

before


after




16 69

69 10 30 2 16

10 30 2 16

before


after




69

69 10 30 2 16

10 30 2 16 69

before


after




69 10 30 2 16

10 30 2 16 69

before


after




2 10 30 69

16

10 30 2 16 69before

3. 키값의자릿수만큼위의과정을반복

after




2 10 30 69

16

10 30 2 16 69

2 10 16 30 69

before

3. 키값의자릿수만큼위의과정을반복

after


기수정렬코드분석

원소들의 최대 자릿수를 구해줌

큐 생성

큐에 넣어주는 과정

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 해줌


기수정렬코드분석

큐에서 차례대로 꺼내어 정렬

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); //소문자}

기수정렬적용사례


전화번호 정렬 날짜 정렬 주민번호 정렬


기수정렬성능분석


O (n) : n 개의원소에대하여버킷을포함한 2n 개의메모리사용

연산시간

1. 실제 : kn

최대자릿수를 k라할때, k번동안 n개의원소가큐에대입되고꺼내어져정렬

2. 이론 : n

대부분의컴퓨터가다룰수있는자릿수가 n에비해현저하게작으므로,고려되지않음


O (n)

계수정렬개념 · 원리 ·특징 · 수행 과정 · 코드분석 · 성능 분석


계수정렬개념

각원소가몇개씩있는지세는과정을통해원소를정렬하는방식이다


계수정렬원리

자기자신보다작은원소의갯수를알면해당원소의위치가결정된다


계수정렬특징

장점

단점

안정적인정렬이다 - 키값이같은원소의순서에대해정렬후에도순서가유지된다

속도가비교적빠른편이다

버켓을사용하므로, 정렬할수있는데이터의타입이한정되어있다

기수정렬과마찬가지로버켓을구현하기위한별도의메모리를필요로한다


계수정렬수행과정

1. 해당원소의값을인덱스로하는 count 배열을사용하여각 원소의개수를셈


0 0 0 0 0 0 0 0 0 0

9 1 7 2 1 8 1 2before

after




0 3 2 0 0 0 0 1 1 1

9 1 7 2 1 8 1 2before

count

after

1. 해당원소의값을인덱스로하는 count 배열을사용하여각 원소의개수를셈



2. count 배열의첫원소부터차례대로갯수를세어재배치


0 3 2 0 0 0 0 1 1 1

9 1 7 2 1 8 1 2

1 1 1

before

after

count




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





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





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





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



계수정렬코드분석

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;

}}


계수정렬코드분석

public interface ICompare<T> {

int identifier();}

ICompare를 implements한 Data클래스

생성자

Override한 메소드


계수정렬성능분석


O (n + k) : n 개의원소에대하여 n 개 + 원소의범위에해당하는 k 개의메모리사용

연산시간

전체원소의범위를체크하고갯수를측정하는횟수는 n 번이며

위에서측정한내용을기반으로정렬결과를구성하는연산은 k 번실행된다


O (n) : 원래시간복잡도는O (n + k)이나, k가O(n)이하의작은범위에서사용되므로O(n)에근사한다

[sopt] 데이터 구조 및 알고리즘 스터디 - #03 : 정렬 (기본, 효율, 초효율

Software