728x90
using System;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
List<int> list; //빨간줄
}
}
}
List에 마우스를 올려보니 class 라고 뜬다.
즉 List는 class이니 참조형태이다.
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
}
}
}using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
list[0] = 1; //에러
}
}
}
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
//int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
//arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
//list[0] = 1; //에러
for (int i = 0; i < 5; i++)
{
list.Add(i);
}
}
}
}
제대로 들어간 것을 확인 함
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
//int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
//arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
//list[0] = 1; //에러
// 동적배열(List) - 넣기
// [ 0 1 2 3 4 ]
for (int i = 0; i < 5; i++)
{
list.Add(i);
}
//c++ 출력방법
for (int i = 0; i < 5; i++)
{
Console.WriteLine(list[i]);
}
//c# 출력방법
foreach (int num in list)
{
Console.WriteLine(num);
}
}
}
}
배열(Array)에는 없지만, 동적배열(List)에는 있는 기능들
1. 삽입
2. 삭제
1. 삽입
list.Insert() 까지 써서 마우스를 Insert()위로 올려보면
어떻게 코드를 짜야 하는지 나온다.
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
//int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
//arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
//list[0] = 1; //에러
// 동적배열(List) - 넣기
// [ 0 1 2 3 4 ]
for (int i = 0; i < 5; i++)
{
list.Add(i);
}
// 동적배열(List) - 삽입
// [ 0 1 2 3 4 ] -> [ 0 1 999 2 3 4 ] 로 만들고 싶다면?
list.Insert(2, 999);
//넣기와 삽입은 다른 개념이다. 넣기는 차례대로 그냥 넣는 것이고,
//삽입은 중간에 데이터를 비집고 넣어 버리는 것이다. (뒤의 데이터들은 +1씩 뒤로 간다)
//c++ 출력방법
for (int i = 0; i < 5; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
//c# 출력방법
foreach (int num in list)
{
Console.WriteLine(num);
}
}
}
}
근데 출력값이 이상하다?
C++ 출력방법과 C# 출력방법의 결과값이 다르다.
<C++ 출력방법의 경우>
0
1
999
2
3
5개 밖에 없고
<C# 출력방법의 경우>
0
1
999
2
3
4
6개가 정상적으로 나온다.
문제점 발견
그러므로 C++출력방법을 i<5에서 i<6으로 수정하였다
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
//int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
//arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
//list[0] = 1; //에러
// 동적배열(List) - 넣기
// [ 0 1 2 3 4 ]
for (int i = 0; i < 5; i++)
{
list.Add(i);
}
// 동적배열(List) - 삽입
// [ 0 1 2 3 4 ] -> [ 0 1 999 2 3 4 ] 로 만들고 싶다면?
list.Insert(2, 999);
//넣기와 삽입은 다른 개념이다. 넣기는 차례대로 그냥 넣는 것이고,
//삽입은 중간에 데이터를 비집고 넣어 버리는 것이다. (뒤의 데이터들은 +1씩 뒤로 간다)
//c++ 출력방법
for (int i = 0; i < 6; i++)
{
Console.WriteLine(list[i]);
}
//c# 출력방법
foreach (int num in list)
{
Console.WriteLine(num);
}
}
}
}
하지만 이런 하드코딩은 오류를 진짜 알아채기가 힘드므로,
최적화 해 줄 필요가 있다.
list.Count
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
//int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
//arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
//list[0] = 1; //에러
// 동적배열(List) - 넣기
// [ 0 1 2 3 4 ]
for (int i = 0; i < 5; i++)
{
list.Add(i);
}
// 동적배열(List) - 삽입
// [ 0 1 2 3 4 ] -> [ 0 1 999 2 3 4 ] 로 만들고 싶다면?
list.Insert(2, 999);
//넣기와 삽입은 다른 개념이다. 넣기는 차례대로 그냥 넣는 것이고,
//삽입은 중간에 데이터를 비집고 넣어 버리는 것이다. (뒤의 데이터들은 +1씩 뒤로 간다)
//c++ 출력방법
for (int i = 0; i < list.Count; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
//c# 출력방법
foreach (int num in list)
{
Console.WriteLine(num);
}
}
}
}
하드코딩으로 오류날까 조마조마 하지말고
for ( int i=0 ; i < list.Count ; i++)을 쓰자...!
2. 삭제
list.Remove()의 경우, index번호는 없고, 값만 지울 수 있는데,
중요한 건 첫 번째로 만나는 값을 지운다는 코드이다.
List의 단점
using System;
using System.Collections.Generic;
namespace Csharp
{
class Program
{
static void Main(string[] args)
{
//한 줄 요약 : 배열 한계점 -> List 출현
//맵 크기가 정해져있을 때에는 배열이 정말 유용한데,
//정말 아쉬운 점은 처음 사용할 때부터 크기가 고정되어 있다는게 큰 단점
//여유있게 배열 크기 최댓값 1000개로 해볼까? -> 메모리 낭비
//int[] arr = new int[1000];
//작은 사이즈의 배열로 시작했다가, 데이터가 커지면 커질수록 사이즈를 유동적으로 늘릴 수 있는
//새로운 형태의 배열을 'List'라 한다.
//List <- 동적 배열
//참조형태이므로 new를 이용해서 만들자
List<int> list = new List<int>();
//배열 같은 경우에는, 이렇게 바로 접근을 했는데,
//arr[0] = 1;
//List의 경우 다르다. List는 현재 빈 상태이다.
//list[0] = 1; //에러
// 1. 동적배열(List) - 넣기
// [ 0 1 2 3 4 ]
for (int i = 0; i < 5; i++)
{
list.Add(i);
}
// 2. 동적배열(List) - 삽입
// [ 0 1 2 3 4 ] -> [ 0 1 999 2 3 4 ] 로 만들고 싶다면?
list.Insert(2, 999);
//넣기와 삽입은 다른 개념이다. 넣기는 차례대로 그냥 넣는 것이고,
//삽입은 중간에 데이터를 비집고 넣어 버리는 것이다. (뒤의 데이터들은 +1씩 뒤로 간다)
// 3. 동적배열(List) - 삭제1 (value)
// [ 0 1 2 3 3 2 ] -> [ 0 1 3 3 2 ]
bool success = list.Remove(2);
// 3. 동적배열(List) - 삭제2 (index)
// [ index0 index1 index2 index3 ... ]
// index0번 삭제
list.RemoveAt(0);
// 4. 동적배열(List) - 초기화(= 전체삭제)
list.Clear();
//c++ 출력방법
for (int i = 0; i < list.Count; i++)
{
Console.WriteLine(list[i]);
}
Console.WriteLine();
//c# 출력방법
foreach (int num in list)
{
Console.WriteLine(num);
}
//List의 단점 - 비효율적(=복사의 필연성)
// [ 0 1 999 2 3 4 ] -> [ 0 1 2 3 4 4 ] -> [ 0 1 2 3 4 ] 로 만들 때,
// 뒤에 있던 데이터들이 다 같이 왼쪽으로 한 칸씩 이동 시켜 입력시키고,
// 맨 마지막 값은 삭제 시키는 이 과정 자체가 비효율적임
}
}
}
728x90
'● > 섹션 6. 자료구조 맛보기' 카테고리의 다른 글
| 05.Dictionary (0) | 2021.07.13 |
|---|---|
| 02.연습문제 (0) | 2021.07.13 |
| 01.배열 (0) | 2021.07.13 |