정렬 (sort) : 2개 이상의 자료를 오름차순이나 내림차순으로 재배열하는 것

키 (key) : 자료를 정렬하는데 사용하는 기준

선택 정렬 (Selection Sort)


전체 원소들 중에서 기준 위치에 맞는 원소를 선택하여 자리를 교환하는 방식

 

  • 전체 원소 중에서 가장 작은 원소를 찾아서 선택하여 첫 번째 원소와 자리를 교환
  • 그 다음 두 번째로 작은 원소를 찾아 선택하여 두 번째 원소와 자리를 교환
  • 그 다음에는 세 번째로 작은 원소를 찾아서 세 번째 원소와 자리를 교환
  • 이 과정을 반복하면서 정렬을 완성
void selectionSort(int a[ ],int n) {
    int i, j, min, temp;
    for (i=0; i<n-1; i++) {
        min = i;
        for (j=i+1; j<n; j++) {
            if (a[j]<a[min]) min = j;
        }
        temp = a[i];
        a[i] = a[min];
        a[min] = temp;
    }
}

메모리 사용공간 : n

시간 복잡도 : O(n^2)

 

삽입 정렬 (Insert Sort)


정렬되어있는 부분집합에 정렬할 새로운 원소의 위치를 찾아 삽입하는 방법

 

  • 부분집합 S : 정렬된 앞부분의 원소들 
  • 부분집합 U : 아직 정렬되지 않은 나머지 원소들
  • U의 원소를 하나씩 꺼내서 S의 마지막 원소부터 비교하면서 위치를 찾아 삽입
  • 이 과정을 반복하면서 정렬을 완성

메모리 사용공간 : n

시간 복잡도 : 최선의 경우 O(n) 최악의 경우 O(n^2)

 

퀵 정렬 (quick sort)


  • 부분 집합으로 분할하기 위해서 L과 R을 사용
  • 왼쪽 끝에서 오른쪽으로 움직이면서 크기를 비교하여 피봇 보다 크거나 같 은 원소를 찾아 L로 표시
  • 오른쪽 끝에서 왼쪽으로 움직이면서 피봇보다 작은 원소를 찾아 R로 표시
  • L이 가리키는 원소와 R이 가리키는 원소를 서로 교환
  • L와 R이 만나게 되면 피봇과 L의 원소를 서로 교환하고, 교환한 위치를 피봇 의 위치로 확정
  • 피봇의 확정된 위치를 기준으로 만들어진 왼쪽 부분 집합과 오른쪽 부분 집합 에 대해서 퀵 정렬을 순환적으로 반복 수행하는데 부분 집합의 크기가 1 이하 가 되면 퀵 정렬을 종료
quickSort(a[], begin, end)
    if (begin < end) then {
        p ← partition(a, begin, end);
        quickSort(a[], begin, p-1);
        quickSort(a[], p+1, end);
    }
end quickSort() 
partiton(a[], begin, end)
    pivot ← (begin + end)/2;
    L ← begin;
    R ← end;
    while(L<R) do {
        while(a[L]<a[pivot] and L<R) do L++;
        while(a[R]≥a[pivot] and L<R) do R--;
        if(L<R) then { // L의 원소와 R의 원소 교환
            temp ← a[L];
            a[L] ← a[R];
            a[R] ← temp;
            if(L=pivot) then pivot ← R
        }
    }
    temp ← a[pivot]; // L의 원소와 피봇 원소 교환
    a[pivot] ← a[L];
    a[L] ← temp;
    return L;
end partition()

메모리 사용공간 : n

시간 복잡도 : O(n log2n)

 

버블 정렬 (bubble sort)


인접한 두 개의 원소를 비교하여 자리를 교환하는 방식

메모리 사용공간 : n

시간 복잡도 : O(n^2)

셀 정렬 (shell sort)


일정한 간격으로 부분집합을 구성하고 삽입 정렬을 수행하는 작업을 반복하면서 전체 원소들을 정렬하는 방법

 

히프 정렬 (heap sort)


  • 정렬할 원소들을 입력하여 최대 히프 구성
  • 히프에 대해서 삭제 연산을 수행하여 얻은 원소를 마지막 자리에 배치
  • 나머지 원소에 대해서 다시 최대 히프로 재구성 원소의 개수만큼 반복 수행

'University > Data Structure' 카테고리의 다른 글

그래프 (Graph)  (0) 2019.06.16
트리 (Tree)  (0) 2019.06.15
자료구조 (Data Structure)  (0) 2019.06.15

그래프 종류


무방향 그래프 (undirected graph) : 두 정점을 연결하는 간선의 방향이 없는 그래프

방향 그래프 (directed graph) : 간선이 방향을 가지고 있는 그래프

완전 그래프 (complete graph) : 각 정점에서 다른 모든 정점을 연결하여 가능한 최대 간선의 수를 가진 그래프

부분 그래프 (sub graph) : 원래의 그래프에서 일부의 정점이나 간선을 제외하여 만든 그래프

가중 그래프 (weight graph), 네트워크 (network) : 정점을 연결하는 간선에 가중치(weight)를 할당한 그래프

 

그래프 용어


인접 (adjacent) : 두 정점이 연결되어 있음, A와 B는 인접

부속 (incident) : 연결된 정점을 잇는 간선은 부속, 간선 (A, B)는 정점 A와 B에 부속 

차수 (degree) : 정점에 부속되어있는 간선의 수

경로 (path) : 그래프에서 간선을 따라 갈 수 있는 길을 순서대로 나열한 것

  경로 길이 (path length) : 경로를 구성하는 간선의 수

  단순 경로 (simple path) : 모두 다른 정점으로 구선된 경로

  사이클 (cycle) : 단순경로 중에서 경로의 시작 정점과 마지막 정점이 같은 경로

DAG (directed acyclic graph) : 방향 그래프이면서 사이클이 없는 그래프

연결 그래프 (connected graph) : 서로 다른 모든 쌍의 정점들 사이에 경로가 있는 그래프

단절 그래프 (disconnected graph) : 연결되지 않은 정점이 있는 그래프

 

인접 행렬 (adjacent matrix) : 행렬에 대한 2차원 배열을 사용하는 순차 자료구조 방법

인접 리스트 (adjacent list) : 각 정점에 대한 인접 정점들을 연결하여 만든 단순 연결 리스트

 

그래프 탐색


깊이 우선 탐색 (depth first search : DFS)

DFS(v)
    for (i←0; i<n; i←i+1) do {
        visited[i]←false;
    }
    stack←createStack();
    visited[v]←true;
    while (not isEmpty(stack)) do {
        if (visited[v의 인접정점 w]=false) then {
            push(stack, v);
            visited[w]←true;
            w 방문;
            v←w;
        }
        else v←pop(stack);
    }
end DFS()

너비 우선 탐색 (breadth first search : BFS)

BFS(v)
    for (i←0; i<n; i←i+1) do {
        visited[i]←false;
    }
    Q←createQueue();
    visited[v]←true;
    while (not isEmpty(Q)) do {
        while (visited[v의 인접정점 w]=false) do {
            visited[w]←true;
            w 처리;
            enQueue(Q, w);
        }
        v←deQueue(Q);
    }
end BFS()

 

신장 트리

(spanning tree)


n개의 정점으로 이루어진 무방향 그래프 G에서 n개의 모든 정점과 n-1개의 간선으로 만들어진 트리

 

깊이 우선 신장 트리 (depth first spanning tree)

  깊이 우선 탐색을 이용하여 생성된 신장 트리

너비 우선 신장 트리 (breadth first spanning tree)

  너비 우선 탐색을 이용하여 생성된 신장 트리

최소 비용 신장 트리 (minimum cost spanning tree)

  무방향 가중치 그래프에서 신장 트리를 구성하는 간선들의 가중치 합이 최소인 신장 트리

 

Kruskal 알고리즘 1

  가중치가 높은 간선을 제거하면서 최소 비용 신장 트리를 만드는 방법

Kruskal 알고리즘 2

  가중치가 낮은 간선을 삽입하면서 최소 비용 신장 트리를 만드는 방법

Prim's 알고리즘

  간선을 정렬하지 않고 하나의 정점에서 시작하여 트리를 확장해 나가는 방법

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

'University > Data Structure' 카테고리의 다른 글

정렬 (Sorting)  (0) 2019.06.16
트리 (Tree)  (0) 2019.06.15
자료구조 (Data Structure)  (0) 2019.06.15

선형 데이터 구조 (Linear Data Structure) 

  • items are organized one after another

  • list, stack, queue

비선형 데이터 구조 (Nonlinear Data Structure) 

  • item have multiple immediate successor
  • tree, graph

트리 (Tree)


비선형 자료구조

계층형 자료구조

확장되는 나무 모양의 구조

노드 (Node) : 트리를 구성하는 원소

간선 (Edge) : 노드를 연결하는 선

서브 트리 (Sub Tree) : 자식노드들이 독립하여 구성한 트리

 

노드간의 관계 용어


자식 (Child) : the node directly below node n in the tree

부모 (Parent) : the node directly above node n in the tree

형제 (Siblings) : nodes with a common parent

루트 (Root) : the only node in the tree with no parent, the name of tree

단말 (Leaf) : a node with no child

조상 (Ancestor) : a node on the path from the root to node n

자손 (Descendant) : a node on the path from node n to a leaf

 

높이 (Height)

  노드의 높이 : 루트에서 노드에 이르는 간선의 수

  트리의 높이 : 트리에 있는 노드의 높이 중에서 가장 큰 값

차수 (Degree)

  노드의 차수 : 노드에 연결된 자식 노드의 수

  트리의 차수 : 트리에 있는 노드의 차수 중에서 가장 큰 값

 

이진트리 (Binary Tree)


트리의 노드 구조를 일정하게 정의하여 트리의 구현과 연산이 쉽도록 정의한 트리

특성 1 : n개의 노드를 가진 이진 트리는 항상 (n-1)개의 간선을 가진다.

특성 2 : 높이 h 이진 트리는 최소 h+1개 최대 2^(h+1) - 1개의 노드를 가진다.

포화 이진 트리 : 모든 레벨에 노드가 포화상태로 차 있는 이진 트리

완전 이진 트리 : 1번 부터 n번까지 빈 자리가 없는 이진 트리

편향 이진 트리 : 한쪽 방향의 자식 노드만을 가진 이진 트리

 

이진트리의 순회 


typedef struct treeNode {
  char data;
  struct treeNode *left;
  struct treeNode *right;
}treeNode;

전위 순회

void preorder(treeNode* root)
{
  if(root)
  {
    printf("%c", root->data);
    preorder(root->left);
    preorder(root->right);
  }
}

중위 순회

void inorder(treeNode* root)
{
  if(root)
  {
    inorder(root->left);
    printf("%c", root->data);
    inorder(root->right);
  }
}

후위 순회

void postorder(treeNode* root)
{
  if(root)
  {
    postorder(root->left);
    postorder(root->right);
    printf("%c", root->data);
  }
}

 

이진 탐색 트리


이진 트리에 탐색을 위한 조건을 추가하여 정의한 자료구조

탐색 연산

searchBST(bsT, x)
  p ← bsT;
  if (p=null) then
    return null;
  if (x = p.key) then
    return p;
  if (x < p.key) then
    return searchBST(p.left, x);
  else 
    return searchBST(p.right, x);
end searchBST() 

삽입 연산

insertBST(bsT, x)
  p ← bsT;
  while (p≠null) do {
    if (x = p.key) return;
    q ← p;
    if (x < p.key) p ← p.left;
    else           p ← p.right;
  }
  new ← getNode();
  new.key ← x;
  new.left ← null;
  new.right ← null;
  if (bsT = null)      bsT←new;
  else if (x < q.key)  q.left ← new;
  else                 q.right ← new;
  return;
end insertBST()

삭제 연산

deleteBST(bsT, x)
  p ← 삭제할 노드;
  parent ← 삭제할 노드의 부모 노드;
  if (p = null) then return;
  if (p.left = null and p.right = null) then { // (1) 차수가 0인 노드(단말노드) 삭제
    if (parent.left = p) then parent.left ← null;
    else parent.right ← null;
  }
  else if (p.left = null or p.right = null) then { // (2) 차수가 1인 노드의 삭제
    if (p.left ≠ null) then { // 왼쪽자식노드를 가진 경우
      if (parent.left = p) then parent.left ← p.left;
      else parent.right ← p.left;
    }
    else { // 오른쪽자식노드를 가진 경우
      if (parent.left = p) then parent.left ← p.right;
      else parent.right ← p.right;
    }
  }
  else if (p.left ≠ null and p.right ≠ null) then { // (3) 차수가 2인 노드의 삭제
    q ← maxNode(p.left);
    p.key ← q.key;
    deleteBST(p.left, p.key);
  }
end deleteBST() 

 

히프


완전 이진 트리에 있는 노드 중에서 키 값이 가장 큰 노드나 키 값이 가장 작은 노드를 찾기 위해서 만든 자료형

삽입 연산

insertHeap(heap, item)
  if (n = heapSize) then heapFull();
  n ← n+1; // 1
  for (i ← n; ;) do {
    if (i = 1) then exit;
    if (item ≤ heap[ i/2 ]) then exit; // 2
    heap[i] ← heap[ i/2 ]; // 3
    i ← i/2 // 4
  }
  heap[i] ← item; // 5
end insertHeap()

삭제 연산

deleteHeap(heap)
  if (n = 0) then return error;
  item ← heap[1]; // 1 루트노드의 원소를 item에 저장
  temp ← heap[n]; // 2 마지막노드의 원소를 temp에 보관
  n ← n-1; // 3 히프의 노드개수 1감소
  i ← 1; // 4 i: temp원소가 저장될 노드번호 저장변수
  j ← 2; // j : i의 좌측자식노드 번호
  while (j ≤ n) do {
    if (j < n) then
    if (heap[j] < heap[j+1]) then j ← j+1; // 키값이 큰 자식노드 찾기
    if (temp ≥ heap[j]) then exit; // 5 자식노드가 작으면, 자리 확정
    heap[i] ← heap[j]; // 6 자식노드가 크면, 자리 교환
    i ← j;
    j ← j*2;
  }
  heap[i] ← temp; // 7
  return item; // 8
end deleteHeap()

'University > Data Structure' 카테고리의 다른 글

정렬 (Sorting)  (0) 2019.06.16
그래프 (Graph)  (0) 2019.06.16
자료구조 (Data Structure)  (0) 2019.06.15

데이터를 잘 정리정돈 해야 원하는 데이터를 쉽고 빠르게 찾을 수 있어 처리속도가 빨라집니다.

'University > Data Structure' 카테고리의 다른 글

정렬 (Sorting)  (0) 2019.06.16
그래프 (Graph)  (0) 2019.06.16
트리 (Tree)  (0) 2019.06.15

+ Recent posts