Home > Archive > Leet-Code > ๐Ÿ“ ๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰ vs ๋ฐฐ์—ด์˜ ๊ธธ์ด

๐Ÿ“ ๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰ vs ๋ฐฐ์—ด์˜ ๊ธธ์ด
algorithm datastructure

Array Capacity VS Length

๋งŒ์•ฝ ๋ˆ„๊ตฐ๊ฐ€๊ฐ€ ๋‹น์‹ ์—๊ฒŒ DVD ๋ฐฐ์—ด์˜ ๊ธธ์ด๊ฐ€ ์–ผ๋งˆ๋‚˜ ๋˜๋Š”์ง€ ๋ฌผ์–ด๋ณธ๋‹ค๋ฉด, ๋‹น์‹ ์˜ ๋Œ€๋‹ต์€ ๋ฌด์—‡์ผ๊นŒ์š”?



๋‹น์‹ ์€ ๋‘ ๊ฐ€์ง€ ๋‹ค๋ฅธ ๋Œ€๋‹ต์„ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.


  1. ์ƒ์ž๊ฐ€ ๊ฐ€๋“ ์ฐจ์žˆ์„ ๊ฒฝ์šฐ, ์ƒ์ž๊ฐ€ ๋‹ด์„ ์ˆ˜ ์žˆ๋Š” DVD์˜ ์ˆ˜, ๋˜๋Š”
  2. ํ˜„์žฌ ์ƒ์ž์— ๋“ค์–ด์žˆ๋Š” DVD์˜ ์ˆ˜.


    ์ด ๋‘ ๋‹ต๋ณ€์€ ๋ชจ๋‘ ์ •ํ™•ํ•˜๋ฉฐ, ๋งค์šฐ ๋‹ค๋ฅธ ์˜๋ฏธ๋ฅผ ๊ฐ€์ง‘๋‹ˆ๋‹ค!

    ์ด ๋‘˜์˜ ์ฐจ์ด๋ฅผ ์ดํ•ดํ•˜๊ณ  ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ์‚ฌ์šฉํ•˜๋Š” ๊ฒƒ์ด ์ค‘์š”ํ•ฉ๋‹ˆ๋‹ค.

    ์šฐ๋ฆฌ๋Š” ์ฒซ ๋ฒˆ์งธ๋ฅผ ๋ฐฐ์—ด์˜ โ€˜์šฉ๋Ÿ‰โ€™์ด๋ผ๊ณ  ๋ถ€๋ฅด๊ณ , ๋‘๋ฒˆ์งธ๋ฅผ โ€˜๊ธธ์ดโ€™๋ผ๊ณ  ๋ถ€๋ฆ…๋‹ˆ๋‹ค.

Array Capacity

DVD[] array = new DVD[6]

array[6]์— ์š”์†Œ๋ฅผ ์‚ฝ์ž…ํ•˜๋Š” ๊ฒƒ์ด ์œ ํšจํ•œ ์ž‘์—…์ผ๊นŒ์š”?

array[10]์€ ์–ด๋–จ๊นŒ์š”?



์•„๋‹ˆ์š”, ์ด ๋‘ ๊ฒฝ์šฐ ๋ชจ๋‘ ์œ ํšจํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

๋ฐฐ์—ด์„ ์ƒ์„ฑํ•  ๋•Œ, ์ด ๋ฐฐ์—ด์ด ์ตœ๋Œ€ 6 ๊ฐœ์˜ DVD๋ฅผ ๋‹ด์„ ์ˆ˜ ์žˆ๋‹ค๊ณ  ์ง€์ •ํ–ˆ์Šต๋‹ˆ๋‹ค.

์ด๊ฒƒ์ด ๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰์ž…๋‹ˆ๋‹ค.



์ธ๋ฑ์‹ฑ์ด 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•œ๋‹ค๋Š” ๊ฒƒ์„ ๊ธฐ์–ตํ•œ๋‹ค๋ฉด, ์šฐ๋ฆฌ๋Š” ์˜ค์ง array[0], array[1], array[2], array[3], array[4] ๊ทธ๋ฆฌ๊ณ  array[5]์—๋งŒ ํ•ญ๋ชฉ์„ ์‚ฝ์ž…ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

array[-3], array[6], array[100]๊ณผ ๊ฐ™์ด ๋‹ค๋ฅธ ๊ณณ์— ์š”์†Œ๋ฅผ ๋„ฃ์œผ๋ ค๊ณ  ํ•˜๋ฉด ArrayIndexOutOfBoundsExecption์œผ๋กœ ์ฝ”๋“œ๊ฐ€ ์ถฉ๋Œํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.



๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰์€ ๋ฐฐ์—ด์ด ์ƒ์„ฑ๋  ๋•Œ ๊ฒฐ์ •๋˜์–ด์•ผ ํ•ฉ๋‹ˆ๋‹ค.

์šฉ๋Ÿ‰์€ ๋‚˜์ค‘์— ๋ณ€๊ฒฝํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

์šฐ๋ฆฌ๊ฐ€ ์‚ฌ์šฉํ•œ ์ข…์ด ์ƒ์ž์— DVD๋ฅผ ๋„ฃ๋Š” ๋น„์œ ๋กœ ๋Œ์•„๊ฐ€ ๋ณด๋ฉด, ๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰์„ ๋ณ€๊ฒฝํ•˜๋Š” ๊ฒƒ์€ ์ข…์ด ์ƒ์ž๋ฅผ ๋” ํฌ๊ฒŒ ๋งŒ๋“ค๋ ค๋Š” ๊ฒƒ๊ณผ ๊ฐ™์Šต๋‹ˆ๋‹ค.

๊ณ ์ •๋œ ํฌ๊ธฐ์˜ ์ข…์ด ์ƒ์ž๋ฅผ ๋” ํฌ๊ฒŒ ๋งŒ๋“œ๋Š” ๊ฒƒ์€ ๋น„ํ˜„์‹ค์ ์ด๋ฉฐ, ์ปดํ“จํ„ฐ์˜ ๋ฐฐ์—ด์—์„œ๋„ ๋งˆ์ฐฌ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค!



๊ทธ๋ ‡๋‹ค๋ฉด 7๋ฒˆ์งธ DVD๋ฅผ ์–ป์—ˆ์„ ๋•Œ, ๋ชจ๋“  DVD๋ฅผ ๊ฐ™์€ ๋ฐฐ์—ด์— ๋„ฃ๊ณ  ์‹ถ๋‹ค๋ฉด ์–ด๋–ป๊ฒŒ ํ• ๊นŒ์š”?

๋ถˆํ–‰ํžˆ๋„ ์ข…์ด ์ƒ์ž์˜ ๊ฒฝ์šฐ์™€ ๋งˆ์ฐฌ๊ฐ€์ง€์ž…๋‹ˆ๋‹ค.

๋” ํฐ ์ƒ์ž๋ฅผ ์ƒˆ๋กœ ๊ตฌํ•ด์„œ, ๊ธฐ์กด์˜ DVD๋“ค๊ณผ ์ƒˆ๋กœ์šด ๊ฒƒ์„ ๋ชจ๋‘ ์˜ฎ๊ฒจ์•ผ ํ•ฉ๋‹ˆ๋‹ค



์ž๋ฐ”์—์„œ ๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰์€ ๋ฐฐ์—ด์˜ length ์†์„ฑ๊ฐ’์„ ํ™•์ธํ•จ์œผ๋กœ์จ ์•Œ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ด๋Š” arr.length๋ผ๋Š” ์ฝ”๋“œ๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ํ™•์ธ๋˜๋Š”๋ฐ, ์—ฌ๊ธฐ์„œ arr์€ ๋ฐฐ์—ด์˜ ์ด๋ฆ„์ž…๋‹ˆ๋‹ค.

๋‹ค๋ฅธ ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์–ธ์–ด๋“ค์€ ๋ฐฐ์—ด์˜ ๊ธธ์ด๋ฅผ ํ™•์ธํ•˜๋Š” ๋ฐ ๋‹ค๋ฅธ ๋ฐฉ๋ฒ•์„ ์‚ฌ์šฉํ•ฉ๋‹ˆ๋‹ค.

int capacity = array.length;
System.out.println("The Array has a capacity of " + capacity);

์ด ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ถœ๋ ฅ์ด ๋‚˜์˜ต๋‹ˆ๋‹ค:

The Array has a capacity of 6

capacity property of Swift

Instance Property

capacity

๋ฐฐ์—ด์ด ์ƒˆ๋กœ์šด ์ €์žฅ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•˜์ง€ ์•Š๊ณ  ๋‹ด์„ ์ˆ˜ ์žˆ๋Š” ์š”์†Œ์˜ ์ด ์ˆ˜์ž…๋‹ˆ๋‹ค.

๋ชจ๋“  ๋ฐฐ์—ด์€ ๊ทธ ๋‚ด์šฉ์„ ์ €์žฅํ•˜๊ธฐ ์œ„ํ•ด ํŠน์ • ์–‘์˜ ๋ฉ”๋ชจ๋ฆฌ๋ฅผ ์˜ˆ์•ฝํ•ฉ๋‹ˆ๋‹ค.

๋ฐฐ์—ด์— ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•˜๊ณ  ๊ทธ ๋ฐฐ์—ด์ด ์˜ˆ์•ฝ๋œ ์šฉ๋Ÿ‰์„ ์ดˆ๊ณผํ•˜๊ธฐ ์‹œ์ž‘ํ•˜๋ฉด, ๋ฐฐ์—ด์€ ๋” ํฐ ๋ฉ”๋ชจ๋ฆฌ ์˜์—ญ์„ ํ• ๋‹นํ•˜๊ณ  ๊ทธ ์š”์†Œ๋“ค์„ ์ƒˆ๋กœ์šด ์ €์žฅ ๊ณต๊ฐ„์œผ๋กœ ๋ณต์‚ฌํ•ฉ๋‹ˆ๋‹ค.

์ƒˆ๋กœ์šด ์ €์žฅ ๊ณต๊ฐ„์€ ๊ธฐ์กด ์ €์žฅ ๊ณต๊ฐ„ ํฌ๊ธฐ์˜ ๋ฐฐ์ˆ˜์ž…๋‹ˆ๋‹ค.

์ด ์ง€์ˆ˜์  ์„ฑ์žฅ ์ „๋žต์€ ์š”์†Œ ์ถ”๊ฐ€ ์ž‘์—…์ด ํ‰๊ท ์ ์œผ๋กœ ์ƒ์ˆ˜ ์‹œ๊ฐ„ ๋‚ด์— ์ด๋ฃจ์–ด์ง€๊ฒŒ ํ•˜์—ฌ, ๋งŽ์€ ์ถ”๊ฐ€ ์ž‘์—…์˜ ์„ฑ๋Šฅ์„ ํ‰๊ท ํ™”ํ•ฉ๋‹ˆ๋‹ค.

์žฌํ• ๋‹น์„ ์œ ๋ฐœํ•˜๋Š” ์ถ”๊ฐ€ ์ž‘์—…์—๋Š” ์„ฑ๋Šฅ ๋น„์šฉ์ด ๋“ค์ง€๋งŒ, ๋ฐฐ์—ด์ด ์ปค์ง์— ๋”ฐ๋ผ ๊ทธ๋Ÿฐ ์ž‘์—…์€ ์ ์  ๋œ ์ž์ฃผ ๋ฐœ์ƒํ•ฉ๋‹ˆ๋‹ค.



๋‹ค์Œ ์˜ˆ์‹œ๋Š” ๋ฐฐ์—ด ๋ฆฌํ„ฐ๋Ÿด๋กœ๋ถ€ํ„ฐ ์ •์ˆ˜ ๋ฐฐ์—ด์„ ์ƒ์„ฑํ•œ ๋‹ค์Œ, ๋‹ค๋ฅธ ์ปฌ๋ ‰์…˜์˜ ์š”์†Œ๋“ค์„ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.

์ถ”๊ฐ€ ํ•˜๊ธฐ ์ „์—, ๋ฐฐ์—ด์€ ๊ฒฐ๊ณผ ์š”์†Œ๋“ค์„ ์ €์žฅํ•  ์ˆ˜ ์žˆ์„ ๋งŒํผ ์ถฉ๋ถ„ํžˆ ํฐ ์ƒˆ๋กœ์šด ์ €์žฅ ๊ณต๊ฐ„์„ ํ• ๋‹นํ•ฉ๋‹ˆ๋‹ค.

var numbers = [10, 20, 30, 40, 50]
// numbers.count == 5
// numbers.capacity == 5

numbers.append(contentsOf: stride(from: 60, through: 100, by: 10))
// numbers.count == 10
// numbers.capacity == 10

Array Length

๊ธธ์ด(length) ์˜ ๋˜ ๋‹ค๋ฅธ ์ •์˜๋Š” ๋ฐฐ์—ด์— ํ˜„์žฌ ๋“ค์–ด ์žˆ๋Š” DVD์˜ ์ˆ˜, ๋˜๋Š” ๋‹ค๋ฅธ ํ•ญ๋ชฉ๋“ค์˜ ์ˆ˜์ž…๋‹ˆ๋‹ค

์ด๊ฒƒ์€ ์ง์ ‘ ์ถ”์ ํ•ด์•ผ ํ•  ๊ฒƒ์ด๋ฉฐ, ๊ธฐ์กด DVD๋ฅผ ๋ฎ์–ด์“ฐ๊ฑฐ๋‚˜ ๋ฐฐ์—ด์— ๊ณต๋ฐฑ์„ ๋‚จ๊ฒจ๋‘์–ด๋„ ์˜ค๋ฅ˜๋Š” ๋ฐœ์ƒํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.



์ด์ „ ์˜ˆ์ œ์—์„œ length ๋ณ€์ˆ˜๋ฅผ ์‚ฌ์šฉํ•˜์—ฌ ๋‹ค์Œ ๋น„์–ด ์žˆ๋Š” ์ธ๋ฑ์Šค๋ฅผ ์ถ”์ ํ•˜๊ณ  ์žˆ๋Š” ๊ฒƒ์„ ๋ˆˆ์น˜์ฑ˜์„ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

// ์šฉ๋Ÿ‰์ด 6์ธ ์ƒˆ ๋ฐฐ์—ด์„ ์ƒ์„ฑํ•ฉ๋‹ˆ๋‹ค.
int[] array = new int[6];

// ํ˜„์žฌ ๊ธธ์ด๋Š” 0์ด๋ฉฐ, ์š”์†Œ๊ฐ€ 0๊ฐœ ์žˆ๊ธฐ ๋•Œ๋ฌธ์ž…๋‹ˆ๋‹ค.
int length = 0;

// ๊ทธ ์•ˆ์— 3๊ฐœ์˜ ํ•ญ๋ชฉ์„ ์ถ”๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
for (int i = 0; i < 3; i++) {
    array[i] = i * i;
    // ์š”์†Œ๋ฅผ ์ถ”๊ฐ€ํ•  ๋•Œ๋งˆ๋‹ค ๊ธธ์ด๊ฐ€ 1์”ฉ ์ฆ๊ฐ€ํ•ฉ๋‹ˆ๋‹ค.
    length++;
}

System.out.println("๋ฐฐ์—ด์˜ ์šฉ๋Ÿ‰์€ " + array.length + "์ž…๋‹ˆ๋‹ค.");
System.out.println("๋ฐฐ์—ด์˜ ๊ธธ์ด๋Š” " + length + "์ž…๋‹ˆ๋‹ค.");

์ด ์ฝ”๋“œ๋ฅผ ์‹คํ–‰ํ•˜๋ฉด ๋‹ค์Œ๊ณผ ๊ฐ™์€ ์ถœ๋ ฅ์ด ๋‚˜์˜ต๋‹ˆ๋‹ค:

The Array has a capacity of 6
The Array has a length of 3

count property of Swift

Instance Property

count

๋ฐฐ์—ด์˜ ์š”์†Œ(elements) ์ˆ˜ ์ž…๋‹ˆ๋‹ค.

var count: Int { get }

Handling Array Parameters(๋ฐฐ์—ด ๋งค๊ฐœ๋ณ€์ˆ˜ ์ฒ˜๋ฆฌํ•˜๊ธฐ)

LeetCode์—์„œ์˜ ๋Œ€๋ถ€๋ถ„์˜ ๋ฐฐ์—ด ๋ฌธ์ œ๋Š” โ€œ๊ธธ์ดโ€๋‚˜ โ€œ์šฉ๋Ÿ‰โ€ ๋งค๊ฐœ๋ณ€์ˆ˜ ์—†์ด ๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ๋ฐฐ์—ด์„ ์ „๋‹ฌํ•ฉ๋‹ˆ๋‹ค.

์ด๊ฒŒ ๋ฌด์Šจ ๋œป์ผ๊นŒ์š”?

์˜ˆ๋ฅผ ๋“ค์–ด ์„ค๋ช…ํ•ด ๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

์—ฌ๊ธฐ ๋‹น์‹ ์ด ํ’€๊ฒŒ ๋  ์ฒซ ๋ฒˆ์งธ ๋ฌธ์ œ์˜ ์„ค๋ช…์ด ์žˆ์Šต๋‹ˆ๋‹ค.

โ€˜์ด์ง„ ๋ฐฐ์—ด์ด ์ฃผ์–ด์กŒ์„ ๋•Œ, ์ด ๋ฐฐ์—ด์—์„œ ์—ฐ์†๋œ 1์˜ ์ตœ๋Œ€ ๊ฐœ์ˆ˜๋ฅผ ์ฐพ์•„๋ผ.โ€™

๊ทธ๋ฆฌ๊ณ  ์—ฌ๊ธฐ ์ฃผ์–ด์ง„ ์ฝ”๋“œ ํ…œํ”Œ๋ฆฟ์ด ์žˆ์Šต๋‹ˆ๋‹ค.

class Solution {
    public int findMaxConsecutiveOnes(int[] nums) {
        
    }
}

์œ ์ผํ•œ ๋งค๊ฐœ๋ณ€์ˆ˜๋Š” 'nums' ์ธ๋ฐ, ์ด๋Š” ๋ฐฐ์—ด์ž…๋‹ˆ๋‹ค. 'nums'์˜ ๊ธธ์ด๋ฅผ ๋ชจ๋ฅด๋ฉด ์ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•  ์ˆ˜ ์—†์Šต๋‹ˆ๋‹ค.

๋‹คํ–‰ํžˆ๋„ ์ด๋Š” ๊ฐ„๋‹จํ•ฉ๋‹ˆ๋‹ค.

๋งค๊ฐœ๋ณ€์ˆ˜๋กœ ์ฃผ์–ด์ง„ ๋ฐฐ์—ด์— ๋Œ€ํ•œ ์ถ”๊ฐ€ ์ •๋ณด๊ฐ€ ์—†์„๋•Œ๋Š” ๊ธธ์ด == ์šฉ๋Ÿ‰ (length == capacity) ์ด๋ผ๊ณ  ์•ˆ์ „ํ•˜๊ฒŒ ๊ฐ€์ •ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

์ฆ‰, ๋ฐฐ์—ด์€ ๊ทธ ๋ฐ์ดํ„ฐ๋ฅผ ๋ชจ๋‘ ๋‹ด๊ธฐ์— ์ •ํ™•ํžˆ ์ ํ•ฉํ•œ ํฌ๊ธฐ์ž…๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ .length๋ฅผ ์‚ฌ์šฉํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.



ํ•˜์ง€๋งŒ ์กฐ์‹ฌํ•˜์„ธ์š”, ๋ฐฐ์—ด์€ 0๋ถ€ํ„ฐ ์‹œ์ž‘ํ•˜๋Š” ์ธ๋ฑ์Šค์ž…๋‹ˆ๋‹ค.

์šฉ๋Ÿ‰(capacity)/๊ธธ์ด(length)๋Š” ํ•ญ๋ชฉ์˜ ์ˆ˜์ด์ง€ ์ตœ๊ณ  ์ธ๋ฑ์Šค๊ฐ€ ์•„๋‹™๋‹ˆ๋‹ค.

์ตœ๊ณ  ์ธํ…์Šค๋Š” .lenght -1 ์ž…๋‹ˆ๋‹ค.

๋”ฐ๋ผ์„œ ๋ฐฐ์—ด์˜ ๋ชจ๋“  ํ•ญ๋ชฉ์„ ์ˆœํšŒํ•˜๊ธฐ ์œ„ํ•ด ๋‹ค์Œ๊ณผ ๊ฐ™์ด ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

class Solution {
    public int findMaxConsectiveOnes(int[] nums) {
        // ํžŒํŠธ: ์—ฌ๊ธฐ์— ๋ณ€์ˆ˜๋ฅผ ์ดˆ๊ธฐํ™”ํ•˜๊ณ  ์„ ์–ธํ•˜์—ฌ
        // ์—ฐ์†๋œ 1์ด ๋ช‡ ๊ฐœ์ธ์ง€ ์ถ”์ ํ•ฉ๋‹ˆ๋‹ค.
        for (int i = 0; i < nums.length; i++) {
            // nums[i] ์š”์†Œ๋กœ ๋ฌด์–ธ๊ฐ€๋ฅผ ํ•ฉ๋‹ˆ๋‹ค.
        }
    }
}

์ด๊ฒƒ์ด ๋ฐ”๋กœ ์‹œ์ž‘ํ•˜๊ธฐ ์œ„ํ•ด ํ•„์š”ํ•œ ๋ฐฐ์—ด์˜ ๊ธฐ๋ณธ ์‚ฌํ•ญ์ž…๋‹ˆ๋‹ค!