재귀, 이차원 배열 delta, 정렬

재귀

재귀 호출을 해도 항상 동일한 값을 가짐

static void m1(){
	int i = 0;
	System.out.println("m1() i : "+ i++);
	m1();
}

=> 데이터 공유를 하기 위해서는?

1. static 변수로 정의

static int m1_cnt = 0;

2. 파라미터

static void m1_2(int i){
	System.out.println("m1_2() i : "+ i++);
	m1_2(i);
}

스택 오버 플로우 에러

=> 조건 넣기

static int m2_cnt = 5;
static void m2(){
    System.out.println("front m2() m2_cnt : "+ m2_cnt);
    if(m2_cnt>0){
        m2_cnt--;
        m2();
    }
    System.out.println("back m2() m2_cnt : "+ m2_cnt);
}

result

front m2() m2_cnt : 3
front m2() m2_cnt : 2
front m2() m2_cnt : 1
front m2() m2_cnt : 0
back m2() m2_cnt : 0
back m2() m2_cnt : 0
back m2() m2_cnt : 0
back m2() m2_cnt : 0
back m2() m2_cnt : 0
back m2() m2_cnt : 0

==

static int m4_cnt = 5;
static void m4(){
    if(m4_cnt==0){
        return;
    }
    System.out.println("front m4() m4_cnt : "+ m4_cnt);

    m4_cnt--;
    m4();
    m4_cnt++;
    System.out.println("back m4() m4_cnt : "+ m4_cnt);
}

result

front m4() m4_cnt : 5
front m4() m4_cnt : 4
front m4() m4_cnt : 3
front m4() m4_cnt : 2
front m4() m4_cnt : 1
back m4() m4_cnt : 1
back m4() m4_cnt : 2
back m4() m4_cnt : 3
back m4() m4_cnt : 4
back m4() m4_cnt : 5

변형

m4_cnt--;
m4();
m4_cnt++;

=>

m5(m5_cnt - 1);
------------------
m5(m5_cnt--); => 호출하고 감소하기에 stack overflow 발생

m5(--m5_cnt); 
=>
실행은 되지만
5,4,3,2,1, 0,1,2,3,4로 출력됨

=>

m5(--m5_cnt);
m5_cnt++;

팩토리얼

package basic.recursive;

public class ResursiveCall2 {
    public static void main(String[] args) {
        f(5);
    }

    static int result = 1;
    static void f(int n){
        if(n==1){
            System.out.println(result);
            return;
        }

        result = result*n;
        f(n-1);
    }
}

==

static void f3(int n, int result){
    if(n==1){
        System.out.println("1="+result);
        return;
    }

    System.out.print(n+"*");
    f3(n-1, n*result);
}

이차원 배열

package basic.delta;

import java.util.Arrays;

public class Delta2 {

    static char[][] map = new char[5][5];
    static int[] dx = {0,0,-1,1};
    static int[] dy = {-1,1,0,0};

    public static void main(String[] args) {
        // 2차원 배열
        char ch = 'A';
        for(int i=0;i<5;i++){
            for(int j=0;j<5;j++){
                map[i][j] = ch++;
            }
        }

        for(int i=0;i<5;i++){
            System.out.println(Arrays.toString(map[i]));
        }

        delta_4_end(2,2);
    }

    static void delta_4_end(int x, int y){
        System.out.print(map[x][y]+" : ");

        for(int i=0;i<4;i++){
            int nx = x;
            int ny = y;

            while(true){
                nx += dx[i];
                ny += dy[i];

                if(nx<0 || nx>=5 || ny<0 || ny>=5) break;
                System.out.print(map[nx][ny]);
            }

        }
        System.out.println();
    }
}

정렬

int[] intArray = {3,5,2,7,8,4};
Arrays.sort(intArray);
System.out.println(Arrays.toString((intArray)));

String[] strArray = {"Hello", "hello", "ABC0", "World", "Uplus"};
Arrays.sort(strArray, Collections.reverseOrder());
System.out.println(Arrays.toString((strArray)));

1. comparable

static class Item implements Comparable<Item>{
    int id;
    String name;

    Item(int id, String name){
        this.id = id;
        this.name = name;
    }

    @Override
    public String toString(){
        return "item [id="+id+", name="+name+"]";
    }

    @Override
    public int compareTo(Item o){
        int first = this.id - o.id;
        if (first != 0) return first;
        return this.name.compareTo(o.name);
    }
}

2. comparator

Arrays.sort(itemArray, new Comparator<Item>() {
    @Override
    public int compare(Item o1, Item o2) {
//                return o1.id-o2.id;
        return Integer.compare(o1.id,o2.id);
    }
});

3. lamda

Arrays.sort(itemArray, (o1,o2) -> o1.id- o2.id);

Arrays.sort(itemArray, (o1,o2) -> o1.id == o2.id ? o1.name.compareTo(o2.name) : o1.id-o2.id);