basic data structures

arrays

void func3(int arr[]);
void func4(int * arr);
 
int main() {
    int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
    // arr = { 3,3,3,3,3,3,3,3,3,3 }; 재정의 불가
    int * arr2 = new int[10];
    scanf("%d", &arr[1]);
    scanf("%d", &arr2[1]); // 네 동적 할당도 무조건 & 붙여서 주소로 가야됨
    // 아마 포인터긴 한데 arr2[3] 꼴이면 그 자체가 값이어서 그런듯
    func3(arr); // 이거 바뀜.. 정적어레이 함수인자 직접제어 하면 안된다
    //정적배열은 참조(&)가 기본. 참조 넣으면 에러뜸
    func4(arr2); // 이것도 바뀜
    // ** 배열은 함수인자로 보내면 기본으로 바뀜. 안바뀌게 하고싶으면 복사본 써서 작업해야할듯
    for (int i = 0; i < 11; i++) { // 인덱스 초과하면 이상한값읽음
        printf("%d ", arr[i]);
    }
    printf("\n");
    arr2 = new int[10]; // 네 그냥 초기화 됩니다
    for (int i = 0; i < 11; i++) { // 동적할당 초과하면 이상한값읽음
        printf("%d ", arr2[i]); // 초기화안한 부분은 이상한값나옴
    }
    while (1) {}
    return 0;
}
 
void func3(int arr[]) {
    arr[0] = -99;
}
 
void func4(int * arr) {
    arr[0] = -99;
}

    int ** arr = new int*[10];
    for (int i = 0; i < 10; i++) {
        arr[i] = new int[10];
    }
    // 이차원 배열 정의
    int arr3[5][5];
    int brr[5][5];
    //int brr[5][5]; brr = arr3; 이거 안됨
    int arr4[3] = { 1,2,3 };
    int brr4[3] = { 4,5,6 };
    //arr4 = brr4; 이거도 안됨!!

vectors

void func(vector<int> arr);
void func2(vector<int> & arr);
struct sam {
    int a;
    int b;
} hello;
class sam2 {
public:
    int a;
    int b;
    sam2(int aa, int bb);
};
sam2::sam2(int aa, int bb) {
    a = aa;
    b = bb;
}
int main() {
    vector<int> arr1;
    vector<int> arr2(32, 100); // 32개를 100으로 채운다
    vector<int> arr3[10];
    vector<int> * arr4 = new vector<int>[10];
    // arr4[i].push_back(13);
    // arr4[i].at(j)
    vector<sam> arr5;
    sam se = { 1,2 };
    arr5.push_back(se);
    // se와 arr5.at(0)은 완전히 별개가 된다
    vector<sam2> arr6;
    sam2 test(1, 2);
    arr6.push_back(test); // test와 arr6.at(0)은 완전히 별개이다
    
    arr1.push_back(13); // 맨 뒤에 추가
    arr1.insert(arr1.begin() + 1,200); // 1번째 앞에다 200 삽입
    // 즉 얘가 새로운 index 1이 된다
    
    func(arr1); // 참조가 아니라서 효과 X
    func2(arr1); // 참조라서 효과 o
    
    //arr1.erase(arr1.begin() + 1); // index 1번째 원소를 삭제
    // 즉 앞에서 두번째 원소를 삭제함
    //arr1.erase(arr1.end()-1); // 맨뒤원소 삭제
    // arr1.end()는 맨뒤 원소보다 한개 더 뒤
    //arr1.erase(arr1.begin() + 3, arr1.begin() + 5);
    // index 3에서부터 4까지 삭제 5는 삭제안함
    //arr1.erase(arr1.begin(), arr1.end()); // 전체 삭제
    arr1.clear(); // 전체 삭제
    
    arr1.size(); // 벡터 크기
    //arr1.at(0); // index 0번째 접근
    //arr1.front(); // 맨앞 원소 값
    //arr1.back(); // 맨뒤 원소 값
    for (int i : arr1) { // vector for문
        printf("%d ", i);
    }
    printf("done\n");
    while (1) {}
    return 0;
}
void func(vector<int> arr) {
    arr.push_back(11);
}
void func2(vector<int> & arr) {
    arr.push_back(11);
}
 

vector 대입 ( 함수에도 값으로 보내는걸로 봐서 클래스는 스트럭트랑 같은 개념으로 주소 말고 통째로 복사해서 넘긴다. 그니까 그게 부담스러우면 포인터를 써야 될듯 )

    vector<int> test;
    vector<int> test2;
    test.push_back(32);
    test.push_back(30);
    test2 = test;
    test.push_back(29);
    for (int i = 0; i < test2.size(); i++) {
        cout << test2.at(i) << endl;
    }

list

doubly linked list

erase O(1), insert O(1), access O(N), space complexity O(N)

#include "stdafx.h"
#include <iostream>
#include <list>
#include <vector>
#include <unordered_map>
#include <map>
#include <set>
#include <unordered_set>
 
using namespace std;
 
int main() {
    list<int> sam;
    
    for (int i = 0; i < 10; i++) {
        sam.push_back(i);
    }
    
    list<int>::iterator it = sam.begin();
    
    advance(it, 3);
    
    advance(it, -1);
    
    sam.insert(it, 4444); // "it" 앞에다가 삽입해라.
    
    sam.erase(it); // "it"을 지워라!!
    
    for (it = sam.begin(); it != sam.end(); it++) {
        cout << *it << endl;
    }
 
 
    unordered_map<int, int> test;
    for (int i = 0; i < 10; i++) {
        test.insert(unordered_map<int, int>::value_type(i*2, i*3));
    }
    unordered_map<int, int>::iterator it2 = test.begin();
    advance(it2, 3);
    unordered_set<int>::iterator z;
    advance(z, 3);
    while(1){}
    return 0;
}