강의자료5
Upcoming SlideShare
Loading in...5
×
 

강의자료5

on

  • 864 views

 

Statistics

Views

Total Views
864
Views on SlideShare
864
Embed Views
0

Actions

Likes
0
Downloads
10
Comments
0

0 Embeds 0

No embeds

Accessibility

Categories

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment

강의자료5 강의자료5 Presentation Transcript

  • 3 장 ADTs Stack and Queue (Queue)
  • What is a Queue?
    • Logical (or ADT) level: A queue is an ordered group of homogeneous items (elements), in which new elements are added at one end (the rear) , and elements are removed from the other end (the front ).
    • 순서가 있는 동형의 원소들의 모임 ; 원소 삽입은 한쪽 끝에서 일어나고 삭제는 다른쪽 끝에서 일어남
    • A queue is a FIFO “first in, first out” structure.
  • Queue ADT Operations
    • MakeEmpty -- Sets queue to an empty state.
    • IsEmpty -- Determines whether the queue is currently empty.
    • IsFull -- Determines whether the queue is currently full.
    • Enqueue (ItemType newItem) -- Adds newItem to the rear of the queue.
    • Dequeue (ItemType& item) -- Removes the item at the front of the queue and returns it in item.
  • ADT Queue Operations
    • Transformers
      • MakeEmpty
      • Enqueue
      • Dequeue
    • Observers
      • IsEmpty
      • IsFull
    change state observe state
  • DYNAMIC ARRAY IMPLEMENTATION( circular queue) QueType ~QueType Enqueue Dequeue . . . class QueType Private Data: front 1 rear 4 maxQue 5 items ‘ C’ ‘X’ ‘J’ items [0] [1] [2] [3] [4] RESERVED
  • 큐 구현 - (1)
    • 큐의 구현 : 1 차원 배열 items[] 이용
      • 큐의 첫번째 원소 (front) 원소를 items[0] 로 표현한 큐
    A B C … B C D … B C … [0] [1] [2] [0] [1] [0] [1] [2] rear rear rear 원소를 하나 삭제한 뒤의 상태 원소를 하나 삽입한 뒤의 상태 - 삭제 : queue[0] 에 있는 앞 원소를 제거  삭제할 때마다 나머지 원소들을 왼쪽으로 이동해야 함  큐가 n 개의 원소를 가질 때 , 삭제 시 Θ (n) 시간이 걸림 - 삽입 : 배열 크기 조절 시간을 제외하면 Θ (1) 시간이 걸림
  • 큐 구현 - (2)
    • 큐의 구현
      • (2) 큐의 첫번째 원소를 items[front] 로 표현한 큐
      • - 변수 front 를 사용하여 큐의 첫번째 위치를 항상 유지
      • - 원소의 삭제를 Θ (1) 시간에 수행하기 위한 방법
      • - 큐의 원소 : items[front], …, items[rear]
    A B C … B C D … B C … rear rear rear 첫번째 원소를 삭제한 뒤의 상태 원소를 하나 삽입한 뒤의 상태 front front front
  • 큐 구현 - (2)
    • 큐의 구현
    • (2) 큐의 첫번째 원소를 items[front] 로 표현한 큐 ( 계속 )
      • - 배열 queue 의 크기가 capacity 일 경우 ,
    • rear 가 capacity-1 과 같고 , front > 0 일 때 문제 발생
    • - 배열의 크기를 확장하지 않고 어떻게 원소를 삽입할까 ?
        • 큐의 모든 원소를 왼쪽 끝으로 이동시켜 오른 쪽 끝에 공간을 만드는 방법
        • – 배열 이동에 많은 시간 소요 : 큐의 원소 수에 비례
        • 원형 큐를 사용하는 방법
        • – 큐가 배열의 끝에서 되돌아오게 하여 최악의 경우 삽입 , 삭제 시간을 O(1) 으로 한다 .
    … A B C D E A B C D E ... rear rear front front (a) 이동 전 (b) 이동 후
  • 큐 구현 - (3)
    • 원형 큐 (Circular queue)
      • 변수 front 는 큐에서 첫 원소의 위치를 가리킴
      • 변수 rear 는 큐에서 마지막 원소의 위치 다음을 ( 시계방향으로 ) 가리킴
    A B C A B C D B C D rear rear rear front front front (a) 현재상태 (b) 삽입 (c) 삭제
  • Circular Queue items[0] items[1] items[2] items[maxQue-1] 논리적으로 배열의 시작과 끝이 이어져 있는 것으로 간주 items items[0] items[1] items[maxQue-1]
  • 경계조건 (boundary conditions) items[maxQue-1] front rear front rear Enqueue(a1) Enqueue(a2) front rear Enqueue(a3) front rear Dnqueue(x) front rear Queue is empty 인 상태 : rear == front a1 a1 a2 a1 a2 a3 a2 a3
  • 경계조건 (boundary conditions) front rear rear front Enqueue( … ) … Dequeue( … ) … rear front Enqueue( … ) ⇒ Queue is full Queue 가 empty 일 경우와 full 일 경우 모두 front = rear 가 되어 구분이 가능하지 않다 . 따라서 , Queue 가 full 인 상태 : (rear +1) % maxQue == front a2 a3
    • //--------------------------------------------------------
    • // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE
    • #include "ItemType.h" // for ItemType
    • template<class ItemType>
    • class QueType
    • {
    • public:
    • QueType( );
    • QueType( int max ); // PARAMETERIZED CONSTRUCTOR
    • ~QueType( ) ; // DESTRUCTOR
    • . . .
    • bool IsFull( ) const;
    • void Enqueue( ItemType item );
    • void Dequeue( ItemType& item );
    • private:
    • int front;
    • int rear;
    • int maxQue;
    • ItemType* items; // DYNAMIC ARRAY IMPLEMENTATION
    • };
    • //--------------------------------------------------------
    • // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d
    • //--------------------------------------------------------
    • template<class ItemType>
    • QueType <ItemType> ::QueType( int max ) // PARAMETERIZED
    • {
    • maxQue = max + 1;
    • front = 0;
    • rear = 0;
    • items = new ItemType[maxQue]; // dynamically allocates
    • }
    • template<class ItemType>
    • QueType <ItemType> ::QueType() // default class constructor
    • maxQue = 501;
    • front = 0; rear = 0;
    • items = new ItemType[maxQue]; // dynamically allocates
    • }
    • template<class ItemType>
    • bool QueType <ItemType> ::IsEmpty( )
    • {
    • return ( rear == front )
    • }
    • //--------------------------------------------------------
    • // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d
    • //--------------------------------------------------------
    • template<class ItemType>
    • QueType <ItemType> ::~QueType ( ) // 소멸자
    • {
    • delete [ ] items; // deallocates array
    • }
    • .
    • .
    • .
    • template<class ItemType>
    • bool QueType <ItemType> ::IsFull( )
    • {
    • return ( (rear + 1) % maxQue == front ) // WRAP AROUND
    • }
    • //--------------------------------------------------------
    • // CLASS TEMPLATE DEFINITION FOR CIRCULAR QUEUE cont’d
    • //--------------------------------------------------------
    • template<class ItemType>
    • void QueType <ItemType> ::Enqueue(ItemType newitem )
    • {
    • if( IsFull() )
    • {
    • cout << “Queue is full n”; // 예외처리
    • return;
    • }
    • items[rear] = newitem;
    • rear = (rear + 1) % maxQue; // WRAP AROUND
    • }
    • template<class ItemType>
    • void QueType <ItemType> ::Dequeue(ItemType &item )
    • {
    • if( IsEmpty() )
    • {
    • cout << “Queue is empty n”; // 예외처리
    • return;
    • }
    • item = items[front];
    • front = (front + 1) % maxQue; // WRAP AROUND
    • }
  • SAYS ALL PUBLIC MEMBERS OF QueType CAN BE INVOKED FOR OBJECTS OF TYPE CountedQuType
    • // DERIVED CLASS CountedQueType FROM BASE CLASS QueType
    • template<class ItemType>
    • class CountedQueType : public QueType<ItemType>
    • {
    • public:
    • CountedQueType( );
    • void Enqueue( ItemType newItem );
    • void Dequeue( ItemType& item );
    • int LengthIs( ) const;
    • // Returns number of items on the counted queue.
    • private:
    • int length;
    • };
  • class CountedQueType<char>
    • // Member function definitions for class CountedQue
    • template<class ItemType>
    • CountedQueType <ItemType> ::CountedQueType( ) : QueType<ItemType>( )
    • {
    • length = 0 ;
    • }
    • template<class ItemType>
    • int CountedQueType <ItemType> ::LengthIs( ) const
    • {
    • return length ;
    • }
    • template<class ItemType>
    • void CountedQueType <ItemType> ::Enqueue( ItemType newItem )
    • // Adds newItem to the rear of the queue.
    • // Increments length.
    • {
    • length++;
    • QueType<ItemType>::Enqueue( newItem );
    • }
    • template<class ItemType>
    • void CountedQueType <ItemType> ::Dequeue(ItemType& item )
    • // Removes item from the rear of the queue.
    • // Decrements length.
    • {
    • length--;
    • QueType<ItemType>::Dequeue( item );
    • }