강의로 돌아가기
-

결과값은 올바른데 어째서 통과를 못하는지 모르겠습니다

haveExtend()라는 함수를 구현하여
size가 더 커진 경우
Object[] cp = new Object[size + 50]
this.elemet = cp
의 방식으로 배열 크기를 늘려주는 방식을 사용했습니다
값 추가시 해당 함수를 부르도록 했구요
출력 결과 배열의 크기가 늘어났으며 값 또한 올바르게 들어갔는데
어째서 제출 시 통과하지 못했는지 궁금합니다.
test와 ArrayList의 구현은 통과했다고 메시지가 출력됩니다.

작성중인 코드―ArrayList.java
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
public class ArrayList {
    private int size = 0;
    private Object[] elementData = new Object[100];

    public ArrayList() {

    }

    public void haveExtend() {
        if(size > elementData.length-1) {
          Object[] cp = new Object[size+50];
          for(int i = 0; i < size; i++)
            cp[i] = elementData[i];
            this.elementData = cp;
        }
    }

    public boolean addLast(Object element) {
        haveExtend();
        elementData[size] = element;
        size++;
        return true;
    }

    public boolean add(int index, Object element) {
        haveExtend();
        // 엘리먼트 중간에 데이터를 추가하기 위해서는 끝의 엘리먼트부터 index의 노드까지 뒤로 한칸씩 이동시켜야 합니다.
        for (int i = size - 1; i >= index; i--) {
            elementData[i + 1] = elementData[i];
        }
        // index에 노드를 추가합니다.
        elementData[index] = element;
        // 엘리먼트의 숫자를 1 증가 시킵니다.
        size++;
        return true;
    }

    public boolean addFirst(Object element){
        return add(0, element);
    }

    public String toString() {
        String str = "[";
        for (int i = 0; i < size; i++) {
            str += elementData[i];
            if (i < size - 1)
                str += ",";
        }
        return str + "]";
    }

    public Object remove(int index) {
        // 엘리먼트를 삭제하기 전에 삭제할 데이터를 removed 변수에 저장합니다.
        Object removed = elementData[index];
        // 삭제된 엘리먼트 다음 엘리먼트부터 마지막 엘리먼트까지 순차적으로 이동해서 빈자리를 채웁니다.
        for (int i = index + 1; i <= size - 1; i++) {
            elementData[i - 1] = elementData[i];
        }
        // 크기를 줄입니다.
        size--;
        // 마지막 위치의 엘리먼트를 명시적으로 삭제해줍니다. 
        elementData[size] = null;
        return removed;
    }   

    public Object removeFirst(){
        return remove(0);
    }

    public Object removeLast(){
        return remove(size-1);
    }

    public Object get(int index) {
        return elementData[index];
    }

    public int size() {
        return size;
    }

    public int indexOf(Object o) {
        for (int i = 0; i < size; i++) {
            if (o.equals(elementData[i])) {
                return i;
            }
        }
        return -1;
    }

    public ListIterator listIterator() {
        // ListIterator 인스턴스를 생성해서 리턴합니다.
        return new ListIterator();
    }



    class ListIterator {
        // 현재 탐색하고 있는 순서를 가르키는 인덱스 값
        private int nextIndex = 0;

        // next 메소르를 호출할 수 있는지를 체크합니다.
        public boolean hasNext() {
            // nextIndex가 엘리먼트의 숫자보다 적다면 next를 이용해서 탐색할 엘리먼트가 존재하는 것이기 때문에 true를 리턴합니다. 
            return nextIndex < size();
        }

        // 순차적으로 엘리먼트를 탐색해서 리턴합니다. 
        public Object next() {
            // nextIndex에 해당하는 엘리먼트를 리턴하고 nextIndex의 값을 1 증가 시킵니다.
            return elementData[nextIndex++];
        }

        // previous 메소드를 호출해도 되는지를 체크합니다.
        public boolean hasPrevious(){
            // nextIndex가 0보다 크다면 이전 엘리먼트가 존재한다는 의미입니다.
            return nextIndex > 0;
        }

        // 순차적으로 이전 노드를 리턴합니다.
        public Object previous(){
            // 이전 엘리먼트를 리턴하고 nextIndex의 값을 1감소합니다. 
            return elementData[--nextIndex];
        }

        // 현재 엘리먼트를 추가합니다. 
        public void add(Object element){
            ArrayList.this.add(nextIndex++, element);
        }

        // 현재 엘리먼트를 삭제합니다. 
        public void remove(){
            ArrayList.this.remove(nextIndex-1);
            nextIndex--;
        }


    }

}
작성중인 코드―MainRunner.java
1
2
3
4
5
6
7
8
9
10
11
12
// 실행을 위한 코드입니다. 수정하지 마세요.
public class MainRunner 
{
    public static void main(String[] args)
    {
        ArrayList arraylist = new ArrayList();
        for(int i=0; i<1000; i++){
            arraylist.addLast(i);
        }
        return ;
    }
}
1 개의 답변
프로그래머스

채점 로직을 수정하였습니다.
다시 제출해주세요.

답변 쓰기
이 입력폼은 마크다운 문법을 지원합니다. 마크다운 가이드 를 참고하세요.