Do it 자료구조와 함께 배우는 알고리즘 입문 - 배열, 클래스

Stella·2024년 1월 17일

자료구조
데이터 단위와 데이터 자체 사이의 물리적 또는 논리적인 관계

배열

new를 사용하여 배열 본체를 생성한 뒤, 배열 변수 이름[인덱스]
int[] a = new int[5];

int[] a; 는 선언을 하는 것
a = new int[5]; 배열을 참조하는 것이다.

배열의 길이
a.length

배열 초기화
int a[] = {1, 2, 3, 4, 5};
빈 배열
배열 요소수는 0이어도 된다. 빈 배열이라고 부른다.
배열 복제(클론)
배열 이름.clone() // 배열의 복제

    public static void main(String[] args) {
        int[] a = {1, 2, 3, 4, 5};
        int[] b = a.clone();

        b[3] = 0;

        System.out.println("a = " + Arrays.toString(a));
        System.out.println("b = " + Arrays.toString(b));
    }

접근 제한자

접근 제한자 종류
1) public : 모든 접근 허용
2) protected : 같은 패키지(폴더)의 객체, 상속 관계 객체 허용
3) default : 같은 패키지(폴더)의 객체 허용
4) private : 현재 객체 안에서만 서용
접근 제한자 사용
1) 클래스 : public, default
2) 생성자 : public, protected, default, private
4) 멤버 변수 : public, protected, default, private
5) 멤버 메서드 : public, protected, default, private
6) 지역 변수 : 접근 제한자를 사용할 수 없음

난수 사용하기

import java.util.Random;
Random rand = new Random();
rand.nextInt(90); // 요솟값을 난수로 결정한다.

난수를 생성하는 Random 클래스의 메서드

키의 최댓값을 구하기

import java.util.Scanner;
import java.util.Random;
public class test8 {

        static int maxOf(int[] a){
            int max = a[0];
            for (int i = 1; i<a.length; i++)
                if(a[i]>max)
                    max = a[i];
            return max;
        }

    public static void main(String[] args) {

        Random random = new Random(); //seed를 임의로 생성, seed를 지정
        Scanner sc = new Scanner(System.in);
        System.out.println("키의 최댓값을 구하자.");

        System.out.print("사람 수 : ");
        int num = sc.nextInt();

        int[] height = new int[num]; // 요소수가 num인 배열
        for(int i = 0; i<num; i++){
            System.out.print("height[" + i + "]:");
            height[i] = random.nextInt(90); // 바운더리를 90으로 잡는다.
        }
        System.out.println("최댓값은" + maxOf(height)+ "입니다.");
    }
}

배열 요소를 역순으로 정렬하기

static void swap(int[] a, int idx1, int idx2) {
      int t = a[idx1];
      a[idx1] = a[idx2];
      a[idx2] = t;

      // a[idx1] 과 idx2의 값을 바꾼다.
  }

  static void reverse(int[] a) {
      for(int i = 0; i<a.length/2; i++)
          swap(a, i,a.length-i-1);
  }

  public static void main(String[] args) {
      Scanner sc = new Scanner(System.in);

      System.out.print("요소수: ");
      int num = sc.nextInt();

      int[] x = new int[num]; // 요소수가 num인 배열

      for (int i = 0; i<num; i++){
          System.out.print("x[" + i + "]: ");
          x[i] = sc.nextInt();
      }

      reverse(x); // 배열 x를 역순으로 정리한다.

      System.out.println("요소를 역순으로 정렬했습니다.");
      System.out.println("x = " + Arrays.toString(x)); // for문을 사용하지 않고 메서드를 사용하여 배열의 전체 요솟값을 한번에 표시한다.
  }
}

reverse메서드를 통해 역순으로 정렬한다.
Arrays.toString메서드를 통해 배열의 전체 요솟값을 한번에 표시한다.

문제 1.
1~10의 합은 (1+10) * 5와 같이 구할 수 있다. '가우스의 덧셈'이라고 하는데 이 방법을 이용해서 1부터 n까지의 정수 합을 구하는 프로그램을 작성하세요.

(n*(n+1))/2로 구할 수 있다.

public class test6 {

    public static void main(String[] args) {
        // 1~10의 합은 (1 + 10) * 5와 같이 구할 수 있다.
        Scanner scanner = new Scanner(System.in);

        System.out.println("1에서 n까지의 총합을 구한다.");
        System.out.print("n의 값 : ");
        int n = scanner.nextInt();

        int sum = (n * (n + 1))/2;

        System.out.println("1에서 " + n + "까지의 총합은 " + sum + "입니다.");

    }
}

하지만 가우스의 합 공식은 홀수인 중간값을 고려하지 않았기 때문에
중간값을 추가로 더해준다.
(n + 1) * (n / 2) : 1부터 n까지의 합을 계산한다.

(n % 2 == 1 ? (n+1)/2:0) n이 홀수일 경우, 중간값을 추가로 더하고 아니면 0을 더하는 식을 추가해야 한다. 홀수 일 때 중간값을 정확하게 고려해야 한다.

수정 된 코드
int sum = (n + 1) * (n / 2) + (n % 2 == 1 ? (n + 1) / 2 : 0);

전위형 증가, 후위형 증가 연산자

전위형 증가 연산자 ++a
피연산자 값을 증가시킨다. b = ++a 는 a가 3일때 1이 증가한 4가 된다.
후위형 증가 연산자 a++
b=a++를 실행하면 b는 3이 되고, a는 4가 된다.
2진수 : 0, 1
8진수 : 0 1 2 3 4 5 6 7
10진수 : 0 1 2 3 4 5 6 7 8 9
16진수 : 0 1 2 3 4 5 6 7 8 9 A B C D E F

기수 변환을 수행하는 프로그램 작성하기

곱셈과 나눗셈을 수행한 횟수 구하기

public class test9 {
    public static void main(String[] args) {
        int counter = 0;
        int ptr = 0;
        int[] prime = new int[500];

        // 소수를 저장한다.
        prime[ptr++] = 2; //2는 소수다
        prime[ptr++] = 3;

        for (int n = 5; n <= 1000; n +=2) {
            boolean flag = false;  // 조사 대상은 홀수만 한다.
            for (int i = 1; prime[i] * prime[i] <=n; i++){ // n의 약수를 구하기 위해 1부터 i*i = n이 되는 값까지 구한다.
                counter += 2;
                if(n % prime[i] == 0) { // 소수가 아니기 때문에 멈춘다.
                    flag = true;
                    break;
                }
            }
            if (!flag) { // 나누어 떨어지지 않는다면 -> 소수이기 때문에 배열에 저장한다.
                prime[ptr++] = n;
                counter++; // 나눗셈이 한 번 실행됐기 때문에 counter++;한다.
            }
        }
        for (int i = 0; i<ptr; i++)
            System.out.println(prime[i]);
        System.out.println("곱셈과 나눗셈을 수행한 횟수 : " + counter);
    }
}