반응형

 

안녕들 하시죠!

이번시간에는 기초 알고리즘 단골 문제인 입력받은 숫자 n까지의 소수갯수 구하기를 Java언어로 풀어보겠습니다.

 

문제

1부터 입력받은 숫자 n까지의 소수의 갯수를 구해라. 

 

풀이

입력받은 숫자까지의 모든 숫자를 나누기 연산을 통해 비교한다.

 

입력받은 n이 5라면, 2부터 시작해서 일일이 나누어본다.

2%2 , 3%2, 3%3, 4%2, 4%3, 4%4, 5%2, 5%3 ...

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
import java.util.Scanner;
 
public class Test1 {
 
    public static int getCount(int n) { // 입력받은 숫자까지의 소수를 계산하는 메소드
        int total = 0;
        int num = 2;
        
        while (num <= n) {
            for (int i = 2; i <= num; i++) {
                if (num % i == 0 && i != num) { // 입력받은 숫자 이외에 다른 숫자로 나누어 떨어질 경우 ( 소수가 아님 ) break
                    break;
                }
                if (num % i ==0 && i == num) { // for문의 i가 증가해 본인과 같아져 나누어 떨어질 경우 ( 소수 )
                    total++// 소수의 갯수를 count하는 total 증가
                }
            }
            num++;
        }
        return total;
    }
 
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int result = getCount(n);
        System.out.println(result);
    }
}
cs

 

문제점

 

숫자가 커지면 커질수록 일일이 비교하는 것은 효율성이 떨어집니다.

100000 정도의 숫자만 입력해도 계산시간이 꽤나 걸립니다.

아래에서 시간복잡도를 통한 비교를 해보겠습니다.

 

시간복잡도
1
2
3
4
5
6
7
8
9
10
11
12
 
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
 
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int result = getCount(n);
        System.out.println(result);
 
        long end = System.currentTimeMillis();
        System.out.println("수행시간 : " + (end - start)/1000.0);
    }
cs

 

 

 

에라토스테네스의 체 알고리즘

 

고대 그리스 수학자 에라토스테네스가 발견한 제곱근을 이용한 소수를 구하는 방법.

소수를 구하는 최적의 알고리즘이라고 합니다.

 

소수는 n의 배수가 아니고 입력받은 수를 그 수보다 작은 수들로 나누어서 떨어지면 소수가 아니다.

그러므로, 모두 나누어 볼 필요없이 n 제곱근 까지만 나누어서 떨어지면 소수가 아니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
import java.util.Scanner;
 
public class Test1 {
 
    public static int getCount(int n) { // 입력받은 숫자까지의 소수를 계산하는 메소드
        int[] arr = new int[n + 1];
        int c = 0;
        for (int i = 2; i <= n; i++) { // 입력받은 숫자까지의 모든 숫자들을 배열에 초기화한다.
            arr[i] = i;
        }
 
        int Sqrt = (int) Math.sqrt(n);
        for (int i = 2; i <= Sqrt; i++) { // 제곱근 까지만 계산
            if (arr[i] == 0) { // 0으로 초기화 되어있는 숫자들은 건너뛴다.
                continue;
            }
            for (int j = i + i; j <= n; j += i) { // 현재 숫자(i)를 제외한 제곱수들은 모두 0으로 초기화.
                arr[j] = 0// 0이 들어있는 번지는 소수가 아니다.
            }
        }
        for (int i = 2; i <= n; i++) {
            if (arr[i] != 0) {
                c++;
            }
        }
        return c;
 
    }
 
    public static void main(String[] args) {
        long start = System.currentTimeMillis();
 
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int result = getCount(n);
        System.out.println("개수 : " + result);
 
        long end = System.currentTimeMillis();
        System.out.println("수행시간 : " + (end - start) / 1000.0);
    }
}
cs

 

수행시간   

 

오늘은 여기까지입니다 감사합니다.

'알고리즘' 카테고리의 다른 글

Java 원형큐 구현  (0) 2019.06.23
Java 링크드리스트 구현  (0) 2019.06.22
백준 10828번 (스택)  (0) 2019.05.10
백준 2750번 (버블정렬)  (0) 2019.05.01
백준 1000번  (0) 2019.04.16
반응형

안녕들 하시죠!

이번시간에는 Java 언어를 이용하여 원형큐를 구현해보겠습니다.

아래에 인터페이스에 있는 메소드를 오버라이딩하여 사용해보겠습니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
interface QueueInterface {
 
    public void newQueue(int Qsize); // 새로운 큐를 생성하는 메소드
 
    public abstract boolean isFull(); // 큐가 포화상태인지 검사하는 메소드
 
    public abstract boolean isEmpty(); // 큐가 비어있는지 검사하는 메소드
 
    public abstract boolean enqueue(Object ob); // 큐에 데이터를 삽입하는 메소드
 
    public abstract Object dequeue(); // 큐에 들어있는 데이터를 삭제하는 메소드
 
    public abstract Object peek(); // 다음번 dequeue 될 데이터 출력하는 메소드
}
cs

 

- 변수 선언과 public void newQueue

 

1
2
3
4
5
6
7
8
9
10
11
12
13
private int front; // 출력 포인터
private int rear; // 삽입 포인터
private int Qsize; // 전체 큐의 사이즈
private char[] QArray; // Qsize를 이용하여 전체 배열 생성
 
@Override
public void newQueue(int Qsize) { // 큐를 생성하는 메소드
    front = 0//
    rear = 0// 맨처음 출력,삽입 포인터가 큐의 0번지를 가리키고 있다.
    this.Qsize = Qsize;
    QArray = new char[Qsize];
    System.out.println("사이즈는 : " + Qsize);
}
cs

 

- public boolean isFull(), public boolean isEmpty()

 

1
2
3
4
5
6
7
8
9
10
11
12
@Override
public boolean isFull() { // 큐가 포화 상태인지 검사하는 메소드
    if (((rear + 1) % this.Qsize) == front) { // 원형큐의 핵심 코드, 아래에서 그림과 함께 설명.
        return true;
    } else {
        return false;
    }
}
@Override
public boolean isEmpty() { // 큐가 이어있는지 검사하는 메소드.
    return rear == front; // rear와 front는 데이터가 삽입되기 전에만 같은 위치를 가리키기 때문에 큐가 비어있는 상태검사에 사용.
}
cs

 

 

 

- public boolean enqueue

 

1
2
3
4
5
6
7
8
9
10
11
12
@Override
public boolean enqueue(Object ob) {
    if (isFull()) { // 큐가 가득차 있지 않다면 삽입.
        System.out.println("큐가 꽉 차 있습니다.");
        return false;
    } else {
        rear = (++rear) % this.Qsize; // 아래 그림에서 설명
        QArray[rear] = (char) ob; // 삽입포인터 rear가 가리키는 공간에 데이터 삽입.
        System.out.println(ob + "를 " + rear + "번째에" + " 삽입");
        return true;
    }
}
cs

 

- 원형큐의 원리

맨처음 삽입포인터(rear) 와 출력포인터(front)는 [0]번지를 가리키고 있습니다. ( 1번그림 )

맨처음 데이터가 삽입되게되면 삽입포인터(rear)가 [1]번지로 이동하게되고 출력포인터(front)는 [0]번지를 그대로 가리키고있습니다. ( 2번그림 )

 

1번, 2번 그림

 

데이터가 계속 삽입되며 [3]번지까지 차게되면 포화상태가 됩니다. ( 4번그림 )

 

3번, 4번 그림

이렇게 포화가 된 상태에서 dequeue() 메소드를 이용해 데이터를 삭제하려고 한다면,

출력포인터(front) 가 [1]번지로 이동하고 데이터를 삭제하게 됩니다. ( 5번그림 )

 

5번, 6번 그림

 

이제 [1]번지의 데이터가 삭제되었으니 데이터를 추가할 공간이 생겼습니다.

enqueue() 메소드를 이용해 데이터를 삽입하려고 한다면,

삽입포인터(rear) 가 [0]번지로 이동하고 데이터를 삽입하여 다시 포화상태가 됩니다. ( 6번그림 )

 

* 핵심코드

 

6번그림에서 [3]번지를 가리키고있던 삽입포인터(rear) 가 [0]번지로 이동하려면,

 

1
rear = (++rear) % this.Qsize;
cs

 

이라는 코드가 필요하게됩니다.

[3]번지에 데이터를 삽입한 후 (++rear) 연산을 통해서 rear는 4가 되어있습니다.

4를 나머지연산(%)를 통해서 Qsize인 4로 나누게 되면 0이 나오기 때문에 다시 [0]번지로 이동하여 데이터를 삽입할 수 있습니다.

 

- public Object dequeue()

 

1
2
3
4
5
6
7
8
9
10
11
12
@Override
public Object dequeue() {
    if (isEmpty()) {
        System.out.println("큐가 비어있습니다.");
        return -1;
    } else {
        front = (++front) % this.Qsize;
        System.out.println(QArray[(front) % Qsize] + "를 삭제");
        return QArray[front];
    }
}
 
cs

 

- public Object peek() 

 

1
2
3
4
5
@Override
public Object peek() {
    System.out.println(QArray[(front + 1) % this.Qsize]);
    return QArray[(front + 1) % this.Qsize];
}
cs

 

원형큐 전체코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
interface QueueInterface {
    
    public void newQueue(int Qsize); // 새로운 큐를 생성하는 메소드
 
    public abstract boolean isFull(); // 큐가 포화상태인지 검사하는 메소드
 
    public abstract boolean isEmpty(); // 큐가 비어있는지 검사하는 메소드
 
    public abstract boolean enqueue(Object ob); // 큐에 데이터를 삽입하는 메소드
 
    public abstract Object dequeue(); // 큐에 들어있는 데이터를 삭제하는 메소드
 
    public abstract Object peek(); // 다음번 dequeue 될 데이터 출력하는 메소드
    
}
 
public class MyQueue implements QueueInterface {
 
    private int front; // 출력 포인터
    private int rear; // 삽입 포인터
    private int Qsize; // 전체 큐의 사이즈
    private char[] QArray; // Qsize를 이용하여 전체 배열 생성
 
    @Override
    public void newQueue(int Qsize) { // 큐를 생성하는 메소드
        front = 0//
        rear = 0// 맨처음 출력,삽입 포인터가 큐의 0번지를 가리키고 있다.
        this.Qsize = Qsize;
        QArray = new char[Qsize];
        System.out.println("사이즈는 : " + Qsize);
    }
 
    @Override
    public boolean isFull() { // 큐가 포화 상태인지 검사하는 메소드
        if (((rear + 1) % this.Qsize) == front) { // 원형큐의 핵심 코드, 아래에서 그림과 함께 설명.
            return true;
        } else {
            return false;
        }
    }
 
    @Override
    public boolean isEmpty() { // 큐가 이어있는지 검사하는 메소드.
        return rear == front; // rear와 front는 데이터가 삽입되기 전에만 같은 위치를 가리키기 때문에 큐가 비어있는 상태검사에 사용.
    }
 
    @Override
    public boolean enqueue(Object ob) {
        if (isFull()) { // 큐가 가득차 있지 않다면 삽입.
            System.out.println("큐가 꽉 차 있습니다.");
            return false;
        } else {
            rear = (++rear) % this.Qsize; // 아래 그림에서 설명
            QArray[rear] = (char) ob; // 삽입포인터 rear가 가리키는 공간에 데이터 삽입.
            System.out.println(ob + "를 " + rear + "번째에" + " 삽입");
            return true;
        }
    }
 
    @Override
    public Object dequeue() {
        if (isEmpty()) {
            System.out.println("큐가 비어있습니다.");
            return -1;
        } else {
            front = (++front) % this.Qsize;
            System.out.println(QArray[(front) % Qsize] + "를 삭제");
            return QArray[front];
        }
    }
 
    @Override
    public Object peek() {
        System.out.println(QArray[(front + 1) % this.Qsize]);
        return QArray[(front + 1) % this.Qsize];
    }
}
cs

 

오늘은 여기까지입니다 갑사합니다 !

반응형

안녕들 하시죠!

이번시간에는 Java 언어를 사용해 링크드리스트(이중 연결 리스트)를 구현해보겠습니다.

아래에는 제가 사용할 클래스와 메소드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class LinkedList {
    
        Node head;
        Node rear;
        int size = 0;
    
        void firstNode(int data) {} // 첫번째 Node 생성
        void addRearNode(int data) {} // 뒷단에 Node 삽입
        void addHeadNode(int data) {} // 앞단에 Node 삽입
        int readData(int index) {} // 특정 데이터 읽기
        void printData() {} // 전체 데이터 출력
        boolean removeNode(int index) {} // 특정 노드 삭제
        boolean removeAllNode() {} // 전체 노드 삭제
        
        class Node {
            Node(int data) {
                this.data = data;
            }
            int data;
            Node front = null;
            Node back = null;
        }
}
cs

 

기본적인 Node의 구성입니다.

값이 들어있는 data, 앞에있는 Node를 가리키고 있는 front, 뒤에있는 Node를 가리키고 있는 back

 

앞에있는 Node를 head, 뒤에있는 Node를 rear라고 구성합니다.

 

- void firstNode

 

1
2
3
4
5
6
7
void firstNode(int data) {
        Node newNode = new Node(data);
        head = newNode;
        rear = newNode;
        size++;
        System.out.println("firstNode(int data) 실행");
    }
cs

 

Node가 한개도 없는 상황에서 첫번째 Node를 생성하는 메소드입니다.

앞,뒤에 어떤 Node도 존재하지 않기 때문에 head와 rear 둘다 첫번째 Node를 가리키게 됩니다.

Node가 생성되었으니 size를 증가시켜줍니다.

 

 

- void addRearNode

1
2
3
4
5
6
7
8
9
10
11
12
void addRearNode(int data) {
        if (size != 0) {
            Node newNode = new Node(data);
            rear.back = newNode; // ①
            newNode.front = rear; // ②
            rear = newNode; // ③
            size++;
            System.out.println("addRearNode(int data) 실행");
        } else {
            System.out.println("firstNode(int data) 실행시켜주세요");
        }
    }
cs

 

맨뒤에 Node를 삽입하는 메소드입니다.

 

간단하게 생각하면,

현재 맨뒤를 가리키고 있는 rear의 뒷자리에 새로운 Node를 삽입하고 서로 가리키고있는 화살표를 바꿔주고 맨뒤에 새로 삽입된 Node를 rear로 만들어주는 과정입니다.

 

 

① : rear의 back의 뒤로 향하는 화살표를 새로 삽입될 newNode를 가리키게 만든다. ( rear.back = newNode )

② : 새로 삽입될 newNode의 앞으로 향하는 화살표를 현재 rear를 가리키게 만든다. ( newNode.front = rear )

③ : 화살표를 바꿔 서로 가리키게 만들었으니 새로 삽입될 newNode를 맨뒤(rear)로 만들어준다. ( rear = newNode )

 

- void addHeadNode

앞에서 설명한 addRearNode와 비슷하게 이번엔 맨앞단에 Node를 삽입하는 메소드입니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
void addHeadNode(int data) {
        if (size != 0) {
            Node newNode = new Node(data);
            head.front = newNode; // 현재 가장 앞에있는 head Node의 앞으로 향하는 화살표가 새로 삽입될 newNode를 가리키게 만든다.
            newNode.back = head; // 새로 삽입될 newNode의 뒤로 향하는 화살표가 현재 head인 Node를 가리키게 만든다.
            head = newNode; // 새로 삽입될 newNode를 맨앞(head)로 만들어준다. 
            size++;
            System.out.println("맨앞에 " + data + " 들어감");
        } else {
            firstNode(data); // 현재 삽입되어있는 Node가 없다면 새로 추가.
        }
    }
cs

 

 

 

- int readData

특정 Node의 data 읽기.

1
2
3
4
5
6
7
8
9
10
11
12
13
int readData(int index) {
        int result = 0;
        try {
            Node node = head; // 맨앞 Node 부터 시작.
            for (int i = 1; i < index; i++) {
                node = node.back; // 한칸씩 뒤로 이동하며 특정위치(index)를 찾고, 값을 result에 저장.
            }
            result = node.data;
        } catch (Exception e) {
            System.out.println("Exception 발생");
        }
        return result;
    }
cs

 

- void printData

전체 Node의 data 출력.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void printData() { 
        if (size > 0) {
            try {
                Node node = head; // 맨앞 Node부터 시작.
                for (int i = 0; i < size; i++) {
                    System.out.print(node.data + " ");
                    node = node.back; // 한칸씩 뒤로 이동하며 모든 Node의 data 출력.
                }
            } catch (Exception e) {
                System.out.println("Exception 발생");
            }
        } else {
            System.out.println("출력데이터가 없습니다.");
        }
    }
cs

 

- boolean removeNode

특정위치의 Node 삭제.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
boolean removeNode(int index) {
        if ((index <= size && index > 0&& size > 0) {
            if (index == 1) {// head를 지울때
                head = head.back; // head를 뒤로 한칸 옮긴다.
                head.front = null;
            } else if (index == size) {// rear를 지울때
                rear = rear.front; // rear를 한칸 앞으로 옮긴다.
                rear.back = null;
            } else { // head나 rear가 아닌 중간에 있는 Node를 지울때
                Node node = head;
                for (int i = 1; i < index; i++) {
                    node = node.back;
                }
                node.front.back = node.back; // ①
                node.back.front = node.front;
            }
            size--;
            return true;
        } else {
            System.out.println("index 범위X");
            return false;
        }
    }
cs

 

 

① : 중간에 있는 Node를 삭제했으니, 앞 뒤의 Node들을 화살표로 연결해 주는 과정입니다.

 

- boolean removeAllNode

전체 Node 삭제.

1
2
3
4
5
6
boolean removeAllNode() {
        head = null;
        rear = null;
        size = 0;
        return true;
    }
cs

 

LinkedList 전체 코드

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
public class Linkedlist {
 
    Node head;
    Node rear;
    int size = 0;
    
    // 아무것도 없는 상태에서 새로운 Node 추가
    void firstNode(int data) {
        Node newNode = new Node(data);
        head = newNode;
        rear = newNode;
        size++;
        System.out.println("firstNode(int data) 실행");
    }
 
    // 뒷단에 Node 추가
    void addRearNode(int data) {
        if (size != 0) {
            Node newNode = new Node(data);
            rear.back = newNode; // ①
            newNode.front = rear; // ②
            rear = newNode; // ③
            size++;
            System.out.println("addRearNode(int data) 실행");
        } else {
            System.out.println("firstNode(int data) 실행시켜주세요");
        }
    }
 
    // 맨앞단에 Node 추가
    void addHeadNode(int data) {
        if (size != 0) {
            Node newNode = new Node(data);
            head.front = newNode; // 현재 가장 앞에있는 head Node의 앞으로 향하는 화살표가 새로 삽입될 newNode를 가리키게 만든다.
            newNode.back = head; // 새로 삽입될 newNode의 뒤로 향하는 화살표가 현재 head인 Node를 가리키게 만든다.
            head = newNode; // 새로 삽입될 newNode를 맨앞(head)로 만들어준다. 
            size++;
            System.out.println("맨앞에 " + data + " 들어감");
        } else {
            firstNode(data); // 현재 삽입되어있는 Node가 없다면 새로 추가.
        }
    }
 
    // 특정 위치(index) Node Data 읽기
    int readData(int index) { // 특정 노드의 data 읽기
        int result = 0;
        try {
            Node node = head; // 맨앞 Node 부터 시작.
            for (int i = 1; i < index; i++) {
                node = node.back; // 한칸씩 뒤로 이동하며 특정위치(index)를 찾고, 값을 result에 저장.
            }
            result = node.data;
        } catch (Exception e) {
            System.out.println("Exception 발생");
        }
        return result;
    }
 
    // 전체 노드의 data 출력
    void printData() { 
        if (size > 0) {
            try {
                Node node = head; // 맨앞 Node부터 시작.
                for (int i = 0; i < size; i++) {
                    System.out.print(node.data + " ");
                    node = node.back; // 한칸씩 뒤로 이동하며 모든 Node의 data 출력.
                }
            } catch (Exception e) {
                System.out.println("Exception 발생");
            }
        } else {
            System.out.println("출력데이터가 없습니다.");
        }
    }
 
    // 특정 위치(index) Node 삭제
    boolean removeNode(int index) {
        if ((index <= size && index > 0&& size > 0) {
            if (index == 1) {// head를 지울때
                head = head.back; // head를 뒤로 한칸 옮긴다.
                head.front = null;
            } else if (index == size) {// rear를 지울때
                rear = rear.front; // rear를 한칸 앞으로 옮긴다.
                rear.back = null;
            } else { // head나 rear가 아닌 중간에 있는 Node를 지울때
                Node node = head;
                for (int i = 1; i < index; i++) {
                    node = node.back;
                }
                node.front.back = node.back; // ①
                node.back.front = node.front; // ②
            }
            size--;
            return true;
        } else {
            System.out.println("index 범위X");
            return false;
        }
    }
 
    // 전체 Node 삭제
    boolean removeAllNode() {
        head = null;
        rear = null;
        size = 0;
        return true;
    }
 
    class Node {
        Node(int data) {
            this.data = data;
        }
 
        int data;
        Node front = null;
        Node back = null;
    }
}
cs

 

오늘은 여기까지입니다 감사합니다 !

'알고리즘' 카테고리의 다른 글

Java) 입력받은 숫자 n까지의 소수갯수 구하기 + 최적 알고리즘  (0) 2019.09.27
Java 원형큐 구현  (0) 2019.06.23
백준 10828번 (스택)  (0) 2019.05.10
백준 2750번 (버블정렬)  (0) 2019.05.01
백준 1000번  (0) 2019.04.16
반응형

안녕들 하시죠!

이번시간에는 백준 10828번 스택 문제를 풀어보겠습니다.

 

스택 이란?

제일 먼저 입력된 데이터가 맨 아래에 쌓이고 가장 최근에 입력된 데이터가 가장 위에 쌓이는 후입 선출(LIFO : Last-in First-out) 구조이다.

 

 

 

위에 있는 스택의 특성을 이용하여 코드를 작성했고, 함수를 이용했습니다.

코드에 문제가 있다면 댓글로 피드백 부탁드리겠습니다.  

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
import java.util.Scanner;
 
public class hello {
    // 전역 변수 선언부
    static Scanner sc = new Scanner(System.in);
    static int totalNum = sc.nextInt(); // 명령의 수
    static int[] totalArr = new int[totalNum]; // 명령의 갯수만큼 배열 생성
    static int top = -1;
    //
    static void push() {
        top++;
        totalArr[top] = sc.nextInt();
    }
 
    static void pop() {
        if (top == -1) {
            System.out.println("-1");
        } else {
            System.out.println(totalArr[top]);
            top--;
        }
    }
 
    static void size() {
        System.out.println(top + 1);
    }
 
    static void empty() {
        if (top == -1) {
            System.out.println("1");
        } else {
            System.out.println("0");
        }
    }
 
    static void top() {
        if (top != -1) {
            System.out.println(totalArr[top]);
        } else {
            System.out.println("-1");
        }
    }
 
    public static void main(String[] args) {
 
        String comm; // 사용자가 입력하는 명령을 저장하는 변수
        for (int i = 0; i < totalNum; i++) {
            comm = sc.next();
 
            if (comm.equals("push")) {
                push();
            }
 
            else if (comm.equals("pop")) {
                pop();
            }
 
            else if (comm.equals("size")) {
                size();
            }
 
            else if (comm.equals("empty")) {
                empty();
            }
 
            else if (comm.equals("top")) {
                top();
            }
        }
 
    }
}
cs

 

오늘은 여기까지입니다 감사합니다 !

 

참고서적 천인국, 공용해, 하상호 「c언어로 쉽게 풀어쓴 자료구조」

'알고리즘' 카테고리의 다른 글

Java) 입력받은 숫자 n까지의 소수갯수 구하기 + 최적 알고리즘  (0) 2019.09.27
Java 원형큐 구현  (0) 2019.06.23
Java 링크드리스트 구현  (0) 2019.06.22
백준 2750번 (버블정렬)  (0) 2019.05.01
백준 1000번  (0) 2019.04.16
반응형

안녕들 하시죠 !

이번시간에는 백준 2750번 정렬문제를 풀어보겠습니다.

 

이번 정렬문제에는 버블정렬을 사용하겠습니다.

 

버블 정렬

 

인접한 2개의 레코드를 비교하여 크기가 순서대로 되어 있지 않으면 서로 교환하는 비교-교환 과정을 리스트의 왼쪽 끝에서 시작하여 오른쪽 끝까지 진행한다.

한 번의 스캔에 의해 가장 큰 레코드가 리스트의 오른쪽 끝으로 이동하게 된다.

 

 

버블 정렬을 적용하여 백준 2750번 문제를 풀어보겠습니다.

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
import java.util.Scanner;
 
public class hello {
    public static void main(String[] args) {
        
        Scanner sc = new Scanner(System.in);
        int[] number = new int[sc.nextInt()]; // 배열 크기를 입력받는다
        int sort = 0// 앞뒤 정수의 교환을 위한 변수
 
        for (int i = 0; i < number.length; i++) {
            number[i] = sc.nextInt(); // 각 배열에 정수 저장
        }
 
        for (int k = 0; k < number.length; k++) {
            for (int j = 0; j < number.length - 1; j++) { 
                if (number[j] > number[j + 1]) { // ex) 12 8 과 같이 앞에 있는 정수가 더 크다면 둘을 교환
                    sort = number[j];
                    number[j] = number[j + 1];
                    number[j + 1= sort;
                }
            }
        }
 
        for (int i = 0; i < number.length; i++) {
            System.out.println(number[i]);
        }
    }
}
cs

length 필드 사용법은 아래글을 참고하시면 됩니다.

2019/04/29 - [Java] - Java의 length필드 사용법

 

Java의 length필드 사용법

안녕들 하시죠! 이번시간에는 Java의 length필드 사용법에 대해 알아보겠습니다. 자바에서 length 필드란 배열의 저장 공간과 합계 배열의 크기 값을 가진 공간입니다. 1 int LArray[] = new int[4]; cs 위의 그..

hongpossible.tistory.com

 

버블정렬 출력에 성공했습니다.

오늘은 여기까지입니다 감사합니다 !

 

참고서적 천인국, 공용해, 하상호 「c언어로 쉽게 풀어쓴 자료구조」

'알고리즘' 카테고리의 다른 글

Java) 입력받은 숫자 n까지의 소수갯수 구하기 + 최적 알고리즘  (0) 2019.09.27
Java 원형큐 구현  (0) 2019.06.23
Java 링크드리스트 구현  (0) 2019.06.22
백준 10828번 (스택)  (0) 2019.05.10
백준 1000번  (0) 2019.04.16
반응형

 

안녕들 하시죠 !

 

오늘은 백준 1000번 문제를 풀어보겠습니다.

 

https://www.acmicpc.net/problem/1000

 

문제

 

 

 

코드

 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import java.util.Scanner;
 
public class Main {
    public static void main(String[] args) {
        // TODO Auto-generated method stub
    
        Scanner sc = new Scanner(System.in); // sc객체 생성  
        
        int A = sc.nextInt(); // A에 첫 번째 정수 저장
        int B = sc.nextInt(); // B에 두 번째 정수 저장
        sc.close(); // sc 객체 닫기
        
        System.out.println(A + B); // 두 정수를 더하여 출력
 
    }
}
cs

 

출력

 

 

성공~

+ Recent posts