https://www.udemy.com/course/best-javascript-data-structures/

 

테스트 값

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class SortEx01 {
	public static void main(String[] args) {
		ThreadLocalRandom current = ThreadLocalRandom.current();
		Integer[] array = current.ints(0,300).distinct().limit(10).boxed().toArray(Integer[]::new);
		System.out.println(array.getClass().getSimpleName()+"   "+ Arrays.toString(array));
		
		//정렬들 저장용
		List<SortStategy<Integer>> list = new ArrayList<>();
		
		for(SortStategy<Integer> sort : list) 
			System.out.printf("%-20s  %s%n",sort.getClass().getSimpleName(),
					Arrays.toString(sort.sort(array)));
	}
	
	static interface SortStategy<T>{
		T[] sort(T[] arr);
		//자리 바꿈 메서드
		default void swap(Integer[] clone, int i, int j) {
			Integer tmp = clone[i];
			clone[i] = clone[j];
			clone[j] = tmp;
		}
	}
}

 

버블 정렬

큰 값을 뒤로 보내며, 최대반복 수를 점점 줄여간다.

static class BubbleSort implements SortStategy<Integer>{
    static int cnt = 0;

    public Integer[] sort(Integer[] arr) {
        Integer[] clone = arr.clone();

        for(int i=0;i<clone.length-1;i++) {// n -1 번 수행
            for(int j=1;j<clone.length-i;j++) {
                cnt++;
                if(clone[j]<clone[j-1]) {
                    swap(clone, j-1, j);
                }
            }
            System.out.println(Arrays.toString(clone));
        }
        System.out.print("버블소트 cnt("+cnt+")");
        return clone;
    }
}
Integer[]   [113, 247, 171, 173, 243, 35, 66, 223, 85, 83]
[113, 171, 173, 243, 35, 66, 223, 85, 83, 247]
[113, 171, 173, 35, 66, 223, 85, 83, 243, 247]
[113, 171, 35, 66, 173, 85, 83, 223, 243, 247]
[113, 35, 66, 171, 85, 83, 173, 223, 243, 247]
[35, 66, 113, 85, 83, 171, 173, 223, 243, 247]
[35, 66, 85, 83, 113, 171, 173, 223, 243, 247]
[35, 66, 83, 85, 113, 171, 173, 223, 243, 247]
[35, 66, 83, 85, 113, 171, 173, 223, 243, 247]
[35, 66, 83, 85, 113, 171, 173, 223, 243, 247]
버블소트 cnt(45)BubbleSort            [35, 66, 83, 85, 113, 171, 173, 223, 243, 247]

최대 값이 제일 뒤로 가니, 그에 따라 최대 반복 수를 줄여 정렬한다.

 

버블 정렬 최적화

static class BubbleSortOp implements SortStategy<Integer>{
    Boolean noSwap = false;
    static int cnt = 0;

    public Integer[] sort(Integer[] arr) {
        Integer[] clone = arr.clone();

        for(int i=0;i<clone.length-1;i++) {// n -1 번 수행용 반복문
            noSwap = true;
            for(int j=1;j<clone.length-i;j++) {//자리바꿈 루프
                cnt++;
                if(clone[j]<clone[j-1]) {
                    noSwap = false; // 자리바꿈이 한 번이라도 수행됐다.
                    swap(clone, j-1, j);
                }
            }
            if(noSwap) break; //자리 바꿈이 수행된적이 없으면 수행용 반복은 의미없음
        }
        System.out.print("버블소트 최적화 cnt("+cnt+")");
        return clone;
    }
}

더 이상 교환된 값이 없으면, 더 이상 정렬한 값이 없는 것으로 반복문을 빠져나온다.

Integer[]   [286, 172, 22, 197, 169, 62, 236, 99, 141, 156]
버블소트 cnt(45)BubbleSort            [22, 62, 99, 141, 156, 169, 172, 197, 236, 286]
버블소트 최적화 cnt(39)BubbleSortOp          [22, 62, 99, 141, 156, 169, 172, 197, 236, 286]

선택 정렬

지정된 위치에 최적에 값을 넣는다. 

가장 안 좋은 정렬이다. 어떠한 경우에도 n^2 시간 복잡도를 보인다.

//버블 정렬보다 나은 점은 스왑수 최소화, i루프 마다 단 한번의 스왑만 발생
static class SelectionSort implements SortStategy<Integer>{
    public Integer[] sort(Integer[] arr) {
        Integer[] clone = arr.clone();
        for(int i=0;i<clone.length-1;i++) {
            for(int j=i+1;j<clone.length;j++) {
                if(Integer.compare(clone[i], clone[j])>0) {
                    swap(clone, i, j);
                }
            }
        }
        return clone;
    }
}

삽입 정렬

논리적으로 배열안에 서브 배열을 만들어 점차 정렬해가는 정렬

배열의 요소가 1개면, 자연스럽게 정렬된 상태다. 즉, 배열의 요소가 2개부터 정렬이 가능한 상태로 시작 인덱스는 1로 준다.

배열의 요소가 거의 정렬된 상태일 때 매우 빠른 속도를 보인다.

static class InsertSort implements SortStategy<Integer>{
    //논리적으로 순회 마다 작은 서브배열을 만든다고 가정한다.
    //1부터 시작
    public Integer[] sort(Integer[] arr) {
        Integer[] clone = arr.clone();
        //배열이 단 한개는 이미 정렬된 것이다. (논리적 배열)
        for(int i = 1;i<clone.length;i++) {
            //배열 shift 하는 동안 값 손실 때문이 임시 저장
            Integer newMember = clone[i];
            Integer j = i-1;
            //새로운 멤버 clone[i]
            for(;j>=0 && newMember < clone[j];j--) {
                clone[j+1] = clone[j];
            }
            //들어갈 자리 j-- 보정 값 +1
            clone[j+1] = newMember;
        }
        return clone;
    }
}

전체 코드

package udemyjavascript;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.concurrent.ThreadLocalRandom;

public class SortEx01 {
	public static void main(String[] args) {
		ThreadLocalRandom current = ThreadLocalRandom.current();
		Integer[] array = current.ints(0,300).distinct().limit(10).boxed().toArray(Integer[]::new);
		System.out.println(array.getClass().getSimpleName()+"   "+ Arrays.toString(array));
		
		//정렬들 저장용
		List<SortStategy<Integer>> list = new ArrayList<>();
		list.add(new BubbleSort());
		list.add(new BubbleSortOp());
		list.add(new SelectionSort());
//		list.add(new InsertSort());
		
		for(SortStategy<Integer> sort : list) 
			System.out.printf("%-20s  %s%n",sort.getClass().getSimpleName(),
					Arrays.toString(sort.sort(array)));
	}
	
	static interface SortStategy<T>{
		T[] sort(T[] arr);
		//자리 바꿈 메서드
		default void swap(Integer[] clone, int i, int j) {
			Integer tmp = clone[i];
			clone[i] = clone[j];
			clone[j] = tmp;
		}
	}
	
	static class BubbleSort implements SortStategy<Integer>{
		static int cnt = 0;
		
		public Integer[] sort(Integer[] arr) {
			Integer[] clone = arr.clone();
			
			for(int i=0;i<clone.length-1;i++) {// n -1 번 수행
				for(int j=1;j<clone.length-i;j++) {
					cnt++;
					if(clone[j]<clone[j-1]) {
						swap(clone, j-1, j);
					}
				}
			}
			System.out.print("버블소트 cnt("+cnt+")");
			return clone;
		}
	}
	static class BubbleSortOp implements SortStategy<Integer>{
		Boolean noSwap = false;
		static int cnt = 0;
		
		public Integer[] sort(Integer[] arr) {
			Integer[] clone = arr.clone();
			
			for(int i=0;i<clone.length-1;i++) {// n -1 번 수행용 반복문
				noSwap = true;
				for(int j=1;j<clone.length-i;j++) {//자리바꿈 루프
					cnt++;
					if(clone[j]<clone[j-1]) {
						noSwap = false; // 자리바꿈이 한 번이라도 수행됐다.
						swap(clone, j-1, j);
					}
				}
				if(noSwap) break; //자리 바꿈이 수행된적이 없으면 수행용 반복은 의미없음
			}
			System.out.print("버블소트 최적화 cnt("+cnt+")");
			return clone;
		}
	}
	
	//버블 정렬보다 나은 점은 스왑수 최소화, i루프 마다 단 한번의 스왑만 발생
	static class SelectionSort implements SortStategy<Integer>{
		public Integer[] sort(Integer[] arr) {
			Integer[] clone = arr.clone();
			for(int i=0;i<clone.length-1;i++) {
				for(int j=i+1;j<clone.length;j++) {
					if(Integer.compare(clone[i], clone[j])>0) {
						swap(clone, i, j);
					}
				}
			}
			return clone;
		}
	}
	
	static class InsertSort implements SortStategy<Integer>{
		//논리적으로 순회 마다 작은 서브배열을 만든다고 가정한다.
		//1부터 시작
		public Integer[] sort(Integer[] arr) {
			Integer[] clone = arr.clone();
			//배열이 단 한개는 이미 정렬된 것이다. (논리적 배열)
			for(int i = 1;i<clone.length;i++) {
				//배열 shift 하는 동안 값 손실 때문이 임시 저장
				Integer newMember = clone[i];
				Integer j = i-1;
				//새로운 멤버 clone[i]
				for(;j>=0 && newMember < clone[j];j--) {
					clone[j+1] = clone[j];
				}
				//들어갈 자리 j-- 보정 값 +1
				clone[j+1] = newMember;
			}
			return clone;
		}
	}
}
Integer[]   [297, 76, 286, 161, 206, 20, 61, 160, 3, 9]
버블소트 cnt(45)BubbleSort            [3, 9, 20, 61, 76, 160, 161, 206, 286, 297]
버블소트 최적화 cnt(45)BubbleSortOp          [3, 9, 20, 61, 76, 160, 161, 206, 286, 297]
SelectionSort         [3, 9, 20, 61, 76, 160, 161, 206, 286, 297]

 

정렬 속도 비교

https://www.toptal.com/developers/sorting-algorithms

 

Sorting Algorithms Animations

Animation, code, analysis, and discussion of 8 sorting algorithms on 4 initial conditions.

www.toptal.com

 

'자료구조&알고리즘' 카테고리의 다른 글

달리기 경주  (0) 2023.07.14

코드


import java.util.*;
//오름차순 기준
//삽입정렬은 i 크기만큼 배열만 정렬하고 i를 점점 증가시킨다.
//그래서 맨 처음은 인위적으로 0인덱스 자리를 비운다. i=1 
//1번 째 순회는 길이가 2인 배열 일부를 비교,
//n번 째 순회는 길이가 n+1인 배열 일부를 비교,
//최종으로는 입력받은 배열 전체를 비교하게 된다.
//핵심은 배열의 크기가 점점 커지면서 최종적으로 입력받은 배열 크기를 비교하게 되는데
//이때 이미 내 앞의 요소는 정렬이 되어있음을 보장한다.
//이 구조는 마치 정렬된 배열에 요소를 추가하는 것과 같다.
//이미 정렬이 되어 있는 배열에 새로운 요소를 추가하는데, 순서를 지키고 싶다고 생각해보자
//뒤에서 부터 비교하면서, 나보다 작은 수가 안나올 때까지 비교할 것이다.
//만약 나보다 작은 수가 나온다면, 비교를 멈추고 그 자리에 나를 넣을 것이다.
//따라서 새로운 요소가 가장 작은 수가 아니라면, 전체를 다 순회하지 않는다. 
class 삽입정렬 {
	public static void main(String[] args) {
		// 최대치를 높여가며 뒤부터 앞으로 정렬을 반복
		int[] arr = new Random().ints(10, 50, 100).toArray();
		for(int i = 1;i<arr.length;i++) {
			for(int j = i;j>0;j--) {
				//arr[j]가 기존 배열에 새로 추가할 요소라고 생각해보자.
				System.out.println("i 순회 중 = "+ i);
				if(arr[j]<arr[j-1] ) {
					System.out.println("arr["+j+"-1]="+arr[j-1]+" <==> arr["+j+"]="+arr[j]);
					for(int z=0;z<j-1;z++) System.out.print("    ");
					System.out.println("  *");
					System.out.println(Arrays.toString(arr));
					int tmp= arr[j];
					arr[j] = arr[j-1];
					arr[j-1] = tmp;
					System.out.println(Arrays.toString(arr));
					System.out.println("========================================");
				}else {
					//기존 배열은 정렬을 유지하고 있는 상태이다.
					//따라서, false가 나오면 그만 순회해도 되는 것이다.
					break;
				}
			}
		}
	}
}

결과

i 순회 중 = 1
arr[1-1]=65 <==> arr[1]=54
  *
[65, 54, 50, 81, 51, 65, 90, 61, 86, 62]
[54, 65, 50, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 2
arr[2-1]=65 <==> arr[2]=50
      *
[54, 65, 50, 81, 51, 65, 90, 61, 86, 62]
[54, 50, 65, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 2
arr[1-1]=54 <==> arr[1]=50
  *
[54, 50, 65, 81, 51, 65, 90, 61, 86, 62]
[50, 54, 65, 81, 51, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 3
i 순회 중 = 4
arr[4-1]=81 <==> arr[4]=51
              *
[50, 54, 65, 81, 51, 65, 90, 61, 86, 62]
[50, 54, 65, 51, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
arr[3-1]=65 <==> arr[3]=51
          *
[50, 54, 65, 51, 81, 65, 90, 61, 86, 62]
[50, 54, 51, 65, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
arr[2-1]=54 <==> arr[2]=51
      *
[50, 54, 51, 65, 81, 65, 90, 61, 86, 62]
[50, 51, 54, 65, 81, 65, 90, 61, 86, 62]
========================================
i 순회 중 = 4
i 순회 중 = 5
arr[5-1]=81 <==> arr[5]=65
                  *
[50, 51, 54, 65, 81, 65, 90, 61, 86, 62]
[50, 51, 54, 65, 65, 81, 90, 61, 86, 62]
========================================
i 순회 중 = 5
i 순회 중 = 6
i 순회 중 = 7
arr[7-1]=90 <==> arr[7]=61
                          *
[50, 51, 54, 65, 65, 81, 90, 61, 86, 62]
[50, 51, 54, 65, 65, 81, 61, 90, 86, 62]
========================================
i 순회 중 = 7
arr[6-1]=81 <==> arr[6]=61
                      *
[50, 51, 54, 65, 65, 81, 61, 90, 86, 62]
[50, 51, 54, 65, 65, 61, 81, 90, 86, 62]
========================================
i 순회 중 = 7
arr[5-1]=65 <==> arr[5]=61
                  *
[50, 51, 54, 65, 65, 61, 81, 90, 86, 62]
[50, 51, 54, 65, 61, 65, 81, 90, 86, 62]
========================================
i 순회 중 = 7
arr[4-1]=65 <==> arr[4]=61
              *
[50, 51, 54, 65, 61, 65, 81, 90, 86, 62]
[50, 51, 54, 61, 65, 65, 81, 90, 86, 62]
========================================
i 순회 중 = 7
i 순회 중 = 8
arr[8-1]=90 <==> arr[8]=86
                              *
[50, 51, 54, 61, 65, 65, 81, 90, 86, 62]
[50, 51, 54, 61, 65, 65, 81, 86, 90, 62]
========================================
i 순회 중 = 8
i 순회 중 = 9
arr[9-1]=90 <==> arr[9]=62
                                  *
[50, 51, 54, 61, 65, 65, 81, 86, 90, 62]
[50, 51, 54, 61, 65, 65, 81, 86, 62, 90]
========================================
i 순회 중 = 9
arr[8-1]=86 <==> arr[8]=62
                              *
[50, 51, 54, 61, 65, 65, 81, 86, 62, 90]
[50, 51, 54, 61, 65, 65, 81, 62, 86, 90]
========================================
i 순회 중 = 9
arr[7-1]=81 <==> arr[7]=62
                          *
[50, 51, 54, 61, 65, 65, 81, 62, 86, 90]
[50, 51, 54, 61, 65, 65, 62, 81, 86, 90]
========================================
i 순회 중 = 9
arr[6-1]=65 <==> arr[6]=62
                      *
[50, 51, 54, 61, 65, 65, 62, 81, 86, 90]
[50, 51, 54, 61, 65, 62, 65, 81, 86, 90]
========================================
i 순회 중 = 9
arr[5-1]=65 <==> arr[5]=62
                  *
[50, 51, 54, 61, 65, 62, 65, 81, 86, 90]
[50, 51, 54, 61, 62, 65, 65, 81, 86, 90]
========================================
i 순회 중 = 9

 

'자료구조&알고리즘 > 자바(Java) 알고리즘 문제풀이 : 코딩테스트 대비' 카테고리의 다른 글

LRU(Least Recently Used)  (0) 2022.12.06
버블정렬  (0) 2022.12.04
선택정렬  (0) 2022.12.02
후위연산  (0) 2022.12.01
모든 아나그램 찾기  (0) 2022.11.30

+ Recent posts