addFront는 List에 값을 넣는데 사용이 된다.

이제, List에 값을 추가했으니 빼고 추출하는걸 표현하고자 한다.


List에서 데이터를 빼기 위해선 list에 있는 node을 받을 수 있게 해야된다.


void_Linked_List delFront 구현.


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
/**
*/
int delFtont(struct _void_node** lp, void* dats){
 
    int n = 0;
    struct _void_node *tmplp=NULL;
 
    if(*lp==NULL){
        printf("Error lp is NULL");
        return 1;
    }
 
    tmplp = *lp;
 
    for(n=0;n<tmplp->v_size;n++){
        *(char*)dats = *(char*)tmplp->dats;
    }
 
    *lp=(*lp)->next;
 
    free(tmplp->dats);
    free(tmplp);
 
    return 0;
}
 
cs


'연습' 카테고리의 다른 글

PAQ8o10t  (0) 2015.06.10
void_Linked_List 전체 소스  (0) 2015.06.08
void_Linked_List -연습 addFront 구현-  (0) 2015.06.05
void_linked_list -연습-  (0) 2015.06.03
Linked_List -Playing with C-  (0) 2015.06.02
Posted by JunkMam
,
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
/**
*/
int addFront(struct _void_node** lp, void* dats, char v_size){
 
    int n = 0;
    struct _void_node* tmplp = NULL;
    printf("lp Test : %d\n"*lp);
 
    tmplp = (struct _void_node*)malloc(sizeof(struct _void_node));
 
    if(tmplp == NULL){
        return 1;
    }
 
    tmplp->v_size = v_size;
 
    tmplp->dats = NULL;
 
    tmplp->dats = malloc(sizeof(v_size));
 
    if(tmplp->dats == NULL){
        return 1;
    }
 
    for(n = 0; n < v_size; n++){
        *(char*)(tmplp->dats+n) = *(char*)(dats+n);
    }
 
    tmplp->next = *lp;
    *lp = tmplp;
 
    printf("%d\n",*lp);
 
    return 0;
}
 
cs

방법은 다음과 같다.

tmplp을 만들어서 해당 tmplp가 NULL로 초기화하여, malloc에서 문제가 있는지 확인 한다.

만약, NULL일 경우에는 닶이 없게 되므로 오류처리하게 만든다.(return 1을 반환한다.)


이상없이 생성되면, dats을 NULL로 변환한 후에 malloc을 시킨다.(어짜피 tmplp는 새로 형성되는 형태이기 때문에 문제가 없다고 생각한다.)


처리가 끝나면, void형을 char형으로 형변환하여 입력하게 한다.

이것은 1byte씩 넣기 때문에 문제가 없다.

좀 더 빨리 처리하기 원하면, v_size에 따라서 1byte, 2byte, 4byte, 8byte로 형변환하여 처리하는 방법이 있다.


tmplp의 다음은 lp와 동일하기 때문에,

tmplp -> next = *lp;을 이용하여 링크를 걸어준다.

Front에 연결하기 때문에 *lp가 결국 tmplp가 되므로

tmplp->next = *lp;

*lp = tmplp;

이렇게 된다. 이상 없는지 확인 한 후에 return 0으로 처리 완료되도록 한다.


이렇게 하면, Linked_List로 추가 되는 형태가 된다.

Posted by JunkMam
,

void_linked_list -연습-

연습 2015. 6. 3. 22:46
linked_list을 void형으로 처리하는 방법.

void로 데이터를 저장하고, 해당 데이터의 크기를 v_size을 이용 할 수 있다.

next를 이용해서 다음 값을 받아질 수 있게한다.


void_list 구조


1
2
3
4
5
struct _void_node{
    char v_size;
    void* dats;
    struct _void_node* next;
}
cs



void_List.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/**
*/
struct _void_node{
    char v_size;
    void* dats;
    struct _void_node* next;
};
 
/**
*/
int mk_list(struct _void_node**);
int addFront(struct _void_node**void*char);
int delFtont(struct _void_node**void*);
 
 
cs

void_List.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
/**
*/
#include "voidList.h"
 
/**
*/
int mk_list(struct _void_node** lp){
 
    printf("Test  %d\n",*lp);
 
    struct _void_node* tmplp = (struct _void_node*)NULL;
 
    if(*lp!=NULL){
        printf("Error lp is Not NULL.");
        return 1;
    }
 
    tmplp = (struct _void_node*)malloc(sizeof(struct _void_node));
 
    *lp = tmplp;
}
 
/**
*/
int addFront(struct _void_node** lp, void* dats, char v_size){
}
 
/**
*/
int delFtont(struct _void_node** lp, void* dats){
}
 
cs


현재, List을 연결하여 처리하는 것에 대해서 이상 유무를 처리하고 있다.

Posted by JunkMam
,

 Playing with C라는 책에 있는 Linked_List를 이용한 Stack 구현 방법을 간단하게 표현하기 위해서 작성 중이다.


 Linked_List을 이용하여 Stack을 구현하면, 장점은 배열의 크기를 초과하여도 문제 없는 장점이 있다.


 void_Linked_List에서 계속 오류가 나기 때문에 문제점이 무엇인지 확인 하기 위해서 지금 이 소스를 보고 분석 중이다.

 왜 문제가 생기는지 알 수 있다면, 그걸 보고 고쳐서 사용할 수 있다고 생각한다.


List.h 

1
2
3
4
5
6
7
8
9
10
11
12
13
#include <stdio.h>
#include <stdlib.h>
 
struct _node{
    int data;
    struct _node* next;
};
 
struct _node* mkList();
int addFront(struct _node**,int data);
int delFront(struct _node**);
 
 
cs


List.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
#include "list.h"
 
/**
*/
struct _node* mkList(){
    struct _node* lp = (struct _node*)NULL;
    return lp;
}
 
/**
*/
int addFront(struct _node** lp, int data){
 
    struct _node* n = NULL;
 
    n = (struct _node*)malloc(sizeof(struct _node));
 
    if(n==NULL){
        printf("Error");
        return 1;
    }
 
    n->data = data;
    n->next = *lp;
    *lp = n;
 
    return 0;
}
 
/**
*/
int delFront(struct _node** lp){
 
    struct _node* head = NULL;
    int data = NULL;
 
    if(*lp==NULL){
        printf("Error is Emplty List");
        return 1;
    }
 
    head = *lp;
 
    *lp = head->next;
    data = head->data;
 
    free(head);
 
    return data;
}
 
 
 
cs


main.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
#include "list.h"
 
int main()
{
    int data = 0;
    int n = 0, i = 0;
    struct _node** stacks=NULL;
 
    stacks = (struct _node**)malloc(sizeof(struct _node*));
 
    printf("몇개의 정수를 입력하고 싶으십니까?");
    scanf("%d", &n);
 
    if(n<=0){
        printf("Error Numbers");
        return 1;
    }
 
    *stacks = mkList();
 
    printf("%d개의 정수를 입력해주세요.",n);
    for(i=0;i<n;++i){
        scanf("%d", &data);
        addFront(stacks,data);
    }
 
    printf("당신이 입력한 정수를 역순으로 출력합니다.\n");
    while(!*stacks==NULL){
        data = delFront(stacks);
        printf(" %d",data);
    }
 
    return 0;
}
 
cs


Posted by JunkMam
,

 연립일차방정식이란,

 미지수 여러개에 대한 일차방정식은 방정식의 값과 계수가 실수 일때,

 일차(미지수간의 관계가 단일한 경우)인 방정식을 말한다.


 예을 들어서


 ax+by=F


 라고 할 수 있다.


 연립 방정식은 이러한 일차방정식이 연립(동일하게 존재하는)되어진 2개 이상의 방정식을 뜻한다.


 예을 들어서


 ax+by=F

 cx+dy=f


 이렇다면, ax+by=F와 cx+dy=f가 모두다 성립되는 방정식을 연립 방정식이라고 한다.


 연립일차 방정식이 성립되는 해를 연립일차방정식의 해집합이라고 한다.

 동일한 해집합을 가지는 두 해집합의 연립일차방정식을 동치라고한다.


 이 해집합을 그래프로 그리면, 기하학으로 표현이 가능하다.


 1. 기하학에서 교차되는 것은 연립일차방정식에선 유일한 해를 갖는다.

 2. 기하학에서 평행하는 것은 연립일차방정식에선 해를 갖지 않는다.

 3. 기하학에서 일치하는 것은 연립일차방정식에선 해가 무수히 많다.


 이 3개의 경우가 있으며, 사용이 용이한 것은 유일한 해를 가질때이다.(해를 갖지 않으면, 계산했을때, 쓸모가 없으며 무수히 많은 해를 가지게 되면, 난잡해진다.)


 유일한 해를 가지게 되는 것을 계산하는 것은 연립일차방정식을 푼다는 것이고, 연립일차방정식을 푸는 공식을 행렬식이라고한다.


 이 방법으로 다양한 방법 중에 반드시 값을 찾아내는 방법은 Gauss 소거법이 있다.

'연습' 카테고리의 다른 글

void_Linked_List -연습 addFront 구현-  (0) 2015.06.05
void_linked_list -연습-  (0) 2015.06.03
Linked_List -Playing with C-  (0) 2015.06.02
find 프로그램 만들기.  (0) 2015.05.11
void_stack 제작하기 -동적 할당-  (0) 2015.05.09
Posted by JunkMam
,

fine 프로그램이란,

Linux에서 존재하는 find로 파일을 찾을때 사용한다.

현재 소스는 파일명을 찾는 소스가 아닌, 전체를 훍어서 전체 경로를 출력하는 소스이다.


만드는 방법으로, 재귀 함수를 이용한 백 트레킹이다.


나눠서 컴파일을 하는 분리 컴파일을 이용하였다.


파일명: dir.h

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <stdio.h>
#include <stdlib.h>
 
//디렉토리를 사용하기 위한 헤더파일
#include <dirent.h>
//파일 정보를 받기 위한 파일.
#include <sys/stat.h>
 
//타이머설정.
#include <windows.h>
 
//잠시 일시 정지등을 하기 위한 파일.
#include <conio.h>
 
#ifndef __DIR_FIND_H__
#define __DIR_FIND_H__
int searchdir(const char*);
#endif // __DIR_FIND_H__
 
cs


파일명: dir.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
 
#include "_dir.h"
 
/*
searchdir
parament : const char* str
수정하지 않는 str는 디렉토리 절대 경로로 이 경로 다음에 검색을 시작한다.
*/
int searchdir(const char* str){
 
    DIR *dir=NULL;//디렉토리 연결 변수
    struct dirent *dirs=NULL;//해당 디렉토리 파일명 변수
    struct stat *status=NULL;//해당 디렉토리 파일 변수
 
    char* tmpstr=NULL;//디렉토리 연결 변수.
 
    dir=opendir(str);//디렉토리 열어서 사용.
    dirs=readdir(dir);//.(현재 디렉토리 처리)
    dirs=readdir(dir);//..(이전 디렉토리 처리)
 
    //재귀 함수를 이용하여 디렉토리를 사용한다.
    while(dirs=readdir(dir)){
 
        //파일 경로를 저장하기 위한 변수 할당.
        tmpstr=(char*)malloc(strlen(str)+dirs->d_namlen+3);
 
        //현재 디렉토리의 파일을 알아보기 위한 상태값을 받는 변수 할당.
        status=(struct stat*)malloc(sizeof(struct stat));
 
        if(tmpstr==NULL){
            printf("Errors");
            exit(-1);
        }
 
        if(status==NULL){
            printf("Errors Status");
            exit(-1);
        }
 
        strcpy(tmpstr,str);
        strcat(tmpstr,dirs->d_name);
 
        stat(tmpstr,status);
 
        if(S_ISDIR(status->st_mode)){
            strcat(tmpstr,"/");
            printf("%s\n",tmpstr);
            Sleep(50);
            searchdir(tmpstr);
        }else{
            printf("%s\n",tmpstr);
            Sleep(50);
        }
        free(status);
        free(tmpstr);
    }
 
    closedir(dir);
 
    return 0;
}
 
cs


파일명: main.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
 
/**
find 프로그램
해당 설정 경로에서 깊이 우선 순위로 파일을 찾아서 출력하는 목표.
*/
 
#include "dir/_dir.h"
 
int main(int argc, char* argv[])
{
    if(argc >1){
        printf("Find Start %s\n",argv[1]);
        printf("Press any key to start\n");
        getch();
        searchdir(argv[1]);
    }else{
        printf("Find Start C:/\n");
        printf("Press any key to start\n");
        getch();
        searchdir("C:/");
    }
 
    return 0;
}
 
cs


find D:/을 넣을 경우

D: 드라이버에 폴더를 뒤지게 되어 있다.

Posted by JunkMam
,

 stack을 배운지 오래이다.

 여기서 생각한건 'int stack, char stack등 각 자료형을 따로 만드는건 귀찮지 않는가?' 라고 생각했었다.

 그래서 생각한건 void는 자료형을 저장하지 않는다는걸 이용하여 void_stack형을 제작할려고 한다.


 일단, void형의 stack과 자료형이 정의된 stack의 차이는 void형 자료형은 다른 자료형과 다르게, '자료형이 정의 되어있지 않는' 형태이다.

 자료형이 정의 되어 있지 않기 때문에, 자료형의 크기를 정의해줘야하며, 자료형의 크기는 최소 단위인 Byte단위로 처리된다고 생각해야된다.

 그래서 그냥 자료형의 stack 구조체는

1
2
3
4
5
struct stack{
 int size;
 int top;
 int *dats;
};
cs

이런 구조가 된다.

하지만, void형의 구조는 다음과 같이 자료형의 크기를 정의 해줘야된다.

1
2
3
4
5
6
struct _void_stack{
 int i_size;
 char v_size;
 int top;
 void *dats;
};
cs


이 구조를 나는 void_stack이라고 정의 하겠다.

나머지 void_stack에 쓰이는 함수들을 정의는 다음과 같이 할 것이다.

1
2
3
4
int mk_stack(struct _void_stack**,const int,const int);
int push_stack(struct _void_stack*,const void*);
int pop_stack(struct _void_stack*,void*);
int delete_stack(struct _void_stack**);
cs

다른 것과 차이는 mk_stack은 void_stack을 받아서 처리하도록 하고, 실패할시 1을 성공할시 0으로하여 문제점을 제거하는 방향으로 잡았다.

함수의 구현 소스

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
int mk_stack(struct _void_stack** stack,const int i_size,const int v_size){
 
    if(stack==NULL) return 1;//Input Stack is Not Values.
    if(*stack!=NULL) return 1;//Not NULL.
 
    *stack=(struct _void_stack*)malloc(sizeof(struct _void_stack));
 
    if(*stack==NULL) return 1;//Not Create Stack.
 
    (*stack)->i_size=i_size;
    (*stack)->v_size=v_size;
    (*stack)->top=-1;
    (*stack)->dats=NULL;
 
    (*stack)->dats=(void*)malloc(i_size*v_size);
    *(char*)(*stack)->dats=10;
 
    if((*stack)->dats==NULL)return 1;
 
    return 0;
 
}
 
int push_stack(struct _void_stack* stack,const void* dats){
 
    int n = 0;
 
    if(stack==NULL) return 1;//Stack is NULL.
    if(stack->top==stack->i_size) return 1;//Stack is FULL.
 
    stack->top++;
 
    for(n=0;n<stack->v_size;n++){
        *((char*)stack->dats+(stack->v_size*stack->top)+n)=*((char*)dats+n);
    }
 
    return 0;
 
}
 
int pop_stack(struct _void_stack* stack,void* buff){
 
    int n = 0;
 
    if(stack==NULL) return 1;//Stack is NULL.
    if(stack->top==-1return 1;//Stack is Empty.
 
    for(n=0;n<stack->v_size;n++){
        //(char)buff[n]=(char)stack->dats[(stack->v_size*stack->top)+n];
        *((char*)buff+n)=*((char*)stack->dats+(stack->v_size*stack->top)+n);
    }
 
    stack->top--;
 
    return 0;
}
 
int delete_stack(struct _void_stack** stack){
 
    if(stack==NULL) return 1;
    if(*stack==NULL) return 1;
 
    free((*stack)->dats);
    free(*stack);
 
    *stack=NULL;
 
    return 0;
}
 
cs

설명으로 mk_stack의 설명을 하자면,

stack을 받는 변수에 NULL을 넣을 경우 오류나도록 하였고,

stack이 존재할 경우에 오류나도록 하였다.

이 이유는,

1. 값을 넣었을때, 문제를 일으키는 경우를 확인하는 것이다.

2. stack을 올바르게 넣었다고 하더라도 stack이 존재한 상태는 메모리를 손실을 일으킬 수 있기 때문에, 그걸 막기 위하여 NULL인지 확인 하는것이다.

이 2가지는 항상 확인해야되는 것이기 때문에, mk_stack이나, 다른 함수들이 오류나는걸 막는걸 주로 한다.

stack에서 dats을 동적할당하여 만들어 내고, 크기는 i_size[인덱스 크기]와 v_size[변수 자료형 크기]의 합이야한다.


전체 소스

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
#include <stdio.h>
 
#include <stdlib.h>
 
struct _void_stack{
    int i_size;//index size
    int v_size;//value size
    int top;//top
    void* dats;//data
};
 
int mk_stack(struct _void_stack**,const int,const int);
int push_stack(struct _void_stack*,const void*);
int pop_stack(struct _void_stack*,void*);
int delete_stack(struct _void_stack**);
 
 
int mk_stack(struct _void_stack** stack,const int i_size,const int v_size){
 
    if(stack==NULL) return 1;//Input Stack is Not Values.
    if(*stack!=NULL) return 1;//Not NULL.
 
    *stack=(struct _void_stack*)malloc(sizeof(struct _void_stack));
 
    if(*stack==NULL) return 1;//Not Create Stack.
 
    (*stack)->i_size=i_size;
    (*stack)->v_size=v_size;
    (*stack)->top=-1;
    (*stack)->dats=NULL;
 
    (*stack)->dats=(void*)malloc(i_size*v_size);
 
    if((*stack)->dats==NULL)return 1;
 
    return 0;
 
}
 
int push_stack(struct _void_stack* stack,const void* dats){
 
    int n = 0;
 
    if(stack==NULL) return 1;//Stack is NULL.
    if(stack->top==stack->i_size) return 1;//Stack is FULL.
 
    stack->top++;
 
    for(n=0;n<stack->v_size;n++){
        *((char*)stack->dats+(stack->v_size*stack->top)+n)=*((char*)dats+n);
    }
 
    return 0;
 
}
 
int pop_stack(struct _void_stack* stack,void* buff){
 
    int n = 0;
 
    if(stack==NULL) return 1;//Stack is NULL.
    if(stack->top==-1return 1;//Stack is Empty.
 
    for(n=0;n<stack->v_size;n++){
        //(char)buff[n]=(char)stack->dats[(stack->v_size*stack->top)+n];
        *((char*)buff+n)=*((char*)stack->dats+(stack->v_size*stack->top)+n);
    }
 
    stack->top--;
 
    return 0;
}
 
int delete_stack(struct _void_stack** stack){
 
    if(stack==NULL) return 1;
    if(*stack==NULL) return 1;
 
    free((*stack)->dats);
    free(*stack);
 
    *stack=NULL;
 
    return 0;
}
 
 
cs

이렇게 제작하면, void_stack이 완성되게 된다.


Posted by JunkMam
,