작성조건

1. 프로그램 메뉴 : 서비스 요청 등록(큐 삽입) / 대기번호 출력 / 서비스 처리(큐 삭제)

2. 서비스 요청 등록의 고객 입력 사항 : 이름, 전화번호, 서비스 요청 품목(냉장고, TV, 핸드폰)


소스코드

 

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
#include <stdio.h>
#include<stdlib.h>
#include <malloc.h>
#include<string.h>
#include <stdbool.h>
typedef char element;
typedef struct QNode {
    element name[10];
    element phonenumber[20];
    int service;
    struct QNode *rink;
} QNode;
 
typedef struct {
    QNode *front*rear;
} LQueueType;
 
LQueueType * createLinkedQueue()
{
    LQueueType *LQ;
    LQ = (LQueueType *)malloc(sizeof(LQueueType));
    LQ->front = NULL;
    LQ->rear = NULL;
    return LQ;
}
 
int isEmpty(LQueueType *LQ)
{
    if (LQ->front == NULL) {
        printf("\n Linked Queue is empty!\n");
        return 1;
    }
    else return 0;
}
 
void enQueue(LQueueType *LQ, QNode *item)
{
    if (LQ->front == NULL) {
        LQ->front = item;
        LQ->rear = item;
    }
    else {
        LQ->rear->rink = item;
        LQ->rear = item;
    }
}
 
void deQueue(LQueueType *LQ , QNode *obj)
{
    QNode *old = LQ->front;
 
    if (!isEmpty(LQ))
    {
        *obj = *old;
        LQ->front = LQ->front->rink;
        if (LQ->front == NULL)
            LQ->rear = NULL;
        free(old);
    }
}
 
void main(void)
{
    LQueueType *LQ1 = createLinkedQueue();
    QNode *newNode;
    int iCount = 0;
    int select = 0;
    bool flag = true;
    while (flag) {
        printf("항목을 선택해주세요. 1.서비스 요청 등록   2. 대기번호 출력   3. 서비스 처리   4. 종료\n");
        scanf("%d", &select);
        QNode old;
        switch (select)
        {
        case 1:
            newNode = (QNode *)malloc(sizeof(QNode));
            printf("이름 입력 : "); 
            char name[10];
            scanf("%s", name);
            strcpy(newNode->name, name);
            printf("전화번호 입력 : ");
            char num[20];
            scanf("%s", num);
            strcpy(newNode->phonenumber, num);
            printf("서비스 요청 품목(냉장고 : 1, TV : 2, 핸드폰 : 3 중 하나 입력) : ");
            scanf("%d", &newNode->service);
            enQueue(LQ1, newNode);
            printf("\n\n");
            iCount++;
            break;
        case 2:
            printf("대기번호 : %d\n", iCount);
            break;
        case 3:
            deQueue(LQ1, &old);
            switch (old.service)
            {
            case 1:
                printf("이름 : %s 전화번호 : %s 서비스 요청 품목 : 냉장고\n", old.name, old.phonenumber);
                break;
            case 2:
                printf("이름 : %s 전화번호 : %s 서비스 요청 품목 : TV\n", old.name, old.phonenumber);
                break;
            case 3:
                printf("이름 : %s 전화번호 : %s 서비스 요청 품목 : 핸드폰\n", old.name, old.phonenumber);
                break;
            }
            iCount--;
            break;
        default:
            flag = false;
            break;
        }
    }
}
cs

 


출력결과

 


(C언어) 후위표기 수식의 연산 프로그램


 

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
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
typedef int element;    //int를 element로 변환
 
//원소를 저장할 스택노드 구조체 구현
typedef struct stackNode {
    element data;
    struct stackNode *link;
}stackNode;
 
//스택 최상단 변수 선언
stackNode* top;
 
 
void push(element item)        //연결 리스트 스택의 삽입 연산
{
    stackNode* temp = (stackNode *)malloc(sizeof(stackNode));
    temp->data = item;
    temp->link = top;
    top = temp;
}
 
element pop()        //연결 리스트 스택의 삭제 후 반환 연산
{
    element item;
    stackNode* temp = top;
 
    if (top == NULL) {
        printf("\n\n Stack empty!\n");
        return 0;
    }
    else {
        item = temp->data;
        top = temp->link;
        free(temp);
        return item;
    }
}
 
element peek()        //연결 리스트 스택의 top 원소 검색 연산
{
    element item;
    if (top == NULL) {
        printf("\n\n Stack is empty!\n");
        return 0;
    }
    else {
        item = top->data;
        return item;
    }
}
 
void del()        //연결 리스트 스택의 삭제 연산
{
    stackNode* temp;
    if (top == NULL) {
        printf("\n\n Stack is empty! \n");
    }
    else {
        temp = top;
        top = top->link;
        free(temp);
    }
}
 
void printStack()        //연결리스트 스택의 출력 연산
{
    stackNode* p = top;
    printf("\n STACK [ ");
    while (p) {
        printf("%d", p->data);
        p = p->link;
    }
    printf("] ");
}
 
element evalPostfix(char *exp)    //후위 표기법을 계산하는 연산
{
    int opr1, opr2, value, i = 0;
    int length = strlen(exp);
    char symbol;
    top = NULL;
 
    for (i = 0; i < length; i++) {
        symbol = exp[i];
        if (symbol != '+' && symbol != '-' && symbol != '*' && symbol != '/') {
            value = symbol - '0';
            push(value);
        }
        else {
            opr2 = pop();
            opr1 = pop();
            switch (symbol) {
            case '+': push(opr1 + opr2); break;
            case '-': push(opr1 - opr2); break;
            case '*': push(opr1 * opr2); break;
            case '/': push(opr1 / opr2); break;
            }
        }
    }
    return pop();
}
 
void main(void)
{
    int result;
    char* express = "35*62/-";
    printf("후위표기식 =>%s",express);
 
    result = evalPostfix(express);
    printf("\n\n연산결과 => %d", result);
 
    getchar();
}
cs

 


출력결과

 


(c언어) 이중 연결 리스트의 원소 삭제 알고리즘


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
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
 
//리스트 구조체 선언
struct Dnode {
    struct Dnode *llink;
    char data[5];
    struct Dnode *rlink;
};
struct DoubleList {
    struct Dnode *dNode;
};
 
struct DoubleList DL = { NULL };
 
void deleteNode(DoubleList DL, Dnode *old) 
{
    old->llink->rlink = old->rlink;
    old->rlink->llink = old->llink;
    free(old);
}
 
 
 
void main() {
    struct Dnode *dn, *dn1, *dn2;
    dn = (Dnode*)malloc(sizeof(Dnode));
    dn1 = (Dnode*)malloc(sizeof(Dnode));
    dn2 = (Dnode*)malloc(sizeof(Dnode));
    strcpy(dn->data, "apple");
    strcpy(dn1->data, "banana");
    strcpy(dn2->data, "orange");
 
    dn->llink = NULL;
    dn->rlink = dn1;
 
    dn1->llink = dn;
    dn1->rlink = dn2;
 
    dn2->llink = dn1;
    dn2->rlink = NULL;
    DL.dNode = dn;
 
    printf("------Before------\n");
    struct Dnode *Temp = DL.dNode;
    int cnt = 0;
    while (Temp != NULL)
    {
        printf("%d : %s\n", cnt++, Temp->data);
        Temp = Temp->rlink;
    }
 
 
    deleteNode(DL, dn1);
 
 
    printf("------after------\n");
    Temp = DL.dNode;
    cnt = 0;
    while (Temp != NULL)
    {
        printf("%d : %s\n", cnt++, Temp->data);
        Temp = Temp->rlink;
    }
 
    return;
}
 
 
cs

 


출력결과

 


+ Recent posts