자료구조 배열

자료구조에 대해 간단하고 빠르게 정리한다.

 

패캠, doit자료구조를 본 내용으로 정리했다.

 

 

배열?

= 같은 자료형의 변수로 이루어진 구성요소가 모인 것이다.

 

배열의 구성요소는 자동으로 0으로 초기화 되는 규칙이 있다.

 

배열의 장점

-구현이 쉽다.

-인덱스를 이용한 접근이 가능하기 떄문에 빠른 성능을 기대할 수 있다.

-참조를 위한 추가적인 메모리 할당이 필요 없다.

 

배열의 단점

- 자료의 삽입과 삭제에 비효율적이다. 삽입과 삭제 시 다음 항목의 모든 요소를 이동시켜야한다. 

- 크기를 바꿀 수 없다.

- 메모리의 재사용이 불가능하다.

 

 

배열을 사용해 최댓값 구하기

fun main(args: Array<String>) {

    val sc = Scanner(System.`in`)
    println("키의 최대값을 구합니다.")
    println("사람 수:")

    val num = sc.nextInt()
    val array = IntArray(num)

    for (i in 0 until num) {
        println("height: $i")
        array[i] = sc.nextInt()
    }

    println("최대값은?: ${getMax(array)}")
}

fun getMax(array: IntArray): Int {
    var max = array[0]

    for (i in 1 until array.size) {
        if (array[i] > max) {
            max = array[i]
        }
    }

    return max
}

 

 

배열을 사용해 5, 10, 73, 2, -5, 42의 배열의 값들을 역순으로 정렬하고 모든 요소의 합계를 반환하는 메서드 만들기

fun main(args: Array<String>) {
    val array = intArrayOf(5, 10, 73, 2, -5, 42)
    arrayReserve(array)

    for (i in array.indices) {
        println("index: $i, result: ${array[i]}")
    }

    println("this array sum: ${arraySum(array)}")
}

fun arraySwap(array: IntArray, first: Int, second: Int) {
    val temp = array[first]
    array[first] = array[second]
    array[second] = temp
}

fun arrayReserve(array: IntArray) {
    for (i in 0 until array.size / 2) {
        arraySwap(array, i, array.size -i - 1)
    }
}

fun arraySum(array: IntArray): Int {
    var sum = 0
    for (i in array.indices) {
        sum += array[i]
    }

    return sum
}

 

 

배열 a, b를 비교하는 메서드를 작성하고,

배열 b의 모든 요소를 배열 a에 복사하는 메서드 copy를 작성하고,

배열 b의 모든 요소를 배열 a에 역순으로 복사하는 rcopy 메서드를 작성

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)

    println("a의 배열의 사이즈를 지정하십시오")
    val numberA = sc.nextInt()
    val aArray = IntArray(numberA)

    println("a 배열의 요소를 넣어주세요")
    for (i in 0 until numberA) {
        aArray[i] = sc.nextInt()
        println("insert -> index: $i, result: ${aArray[i]}")
    }

    println("b의 배열의 사이즈를 지정하십시오")
    val numberB = sc.nextInt()
    val bArray = IntArray(numberB)

    println("b 배열의 요소를 넣어주세요")
    for (i in 0 until numberB) {
        bArray[i] = sc.nextInt()
        println("insert -> index: $i, result: ${bArray[i]}")
    }

    if (bothArrayEqulas(aArray, bArray)) println("a와 b는 같습니다")
    else println("a와 b는 같지 않습니다")

    copy(aArray, bArray)
    rcopy(aArray, bArray)

    for (i in aArray.indices) {
        println("i: $i, r: ${aArray[i]}")
    }
}

fun bothArrayEqulas(first: IntArray, second: IntArray): Boolean {
    if (first.size != second.size) {
        return false
    }

    for (i in first.indices) {
        if (first[i] != second[i]) return false
    }

    return true
}

fun copy(a: IntArray, b: IntArray) {
    val num = if (a.size <= b.size) {
        a.size
    } else {
        b.size
    }

    for (i in 0 until num) {
        a[i] = b[i]
    }
    println("from b to a copy success!")
}

fun rcopy(a: IntArray, b: IntArray) {
    val num = if (a.size <= b.size) {
        a.size
    } else {
        b.size
    }

    reserve(a, b, num)
}

fun reserve(a: IntArray, b: IntArray, num: Int) {
    for (i in 0 until num) {
        a[i] = b[b.size -i - 1]
    }

    println("from b to a rcopy success!")
}