전북대학교 알고리즘 분할정복

검색결과에서 웹페이지의 순위를 매기기 위하여 구글이 사용하는 요소들이 100여가지가 존재한다고 합니다.

구글 페이지 랭킹에 긍정적인
영향을 미치는 조건들

구글에서는 웹마스터 가이드라인을 제시하고 있습니다.

• 디자인 및 콘텐츠 가이드 라인
• 디렉토리와 텍스트 링크 구조가 명확한 사이트
• 사용자에게 사이트맵 제공
• 중요한 이름, 콘텐츠 또는 링크를 표시할때 이미지 대신 텍스트 사용.
• 제목 요소와 ALT 속성이 정확
• URL의 Query에서 매개변수의 길이는 짧게, 개수는 적게 유지
• 한페이지의 링크는 100개 미만으로 제한
• 기술 가이드라인
• DHTML 혹은 플래시 같은 고급기능으로 홈페이지 전체를 구성하지 말것
• 웹서버의 If-Modified-Since HTTP 헤더 지원여부
• 웹서버에서 robots.txt 파일을 사용
• 대부분의 브라우저에서의 올바른 사이트 표시
• 사이트의 성능 모니터링과 로드시간 최적화
• 품질 가이드라인
• 클로킹 콘텐츠 즉 사용자를 속이거나 실제로 존재하지 않는 콘텐츠 제공하지 않음
• 검색엔진 순위를 높이기 위한 편법 사용 금지
• 사이트의 순위나 PageRank를 인위적으로 높이기 위해 개발된 링크 편법을 사용금지
• 숨겨진 텍스트나 링크를 사용하지 않습니다.
• 클로킹 또는 부적절한 리디렉션을 사용하지 않습니다.
• 자동화된 검색어를 Google에 보내지 않습니다.
• 페이지의 내용과 상관없는 검색어 및 키워드를 삽입하지 않습니다.
• 대부분이 중복 콘텐츠로 채워진 다수의 페이지, 하위 도메인 또는 도메인으로 사이트를 구성하지 않습니다.
• 피싱이나 바이러스, 트로이 목마 또는 기타 악성 소프트웨어를 설치하는 등의 악의적 행위가 이루어지는 페이지를 만들지 않습니다.
• 검색엔진 전용 '도어웨이' 페이지 또는 독창적인 콘텐츠가 거의 없거나 전혀 없는 제휴 프로그램 등 기타 '틀에 박힌' 방식을 피합니다.
• 사이트가 제휴 프로그램에 참여하고 있다면 해당 사이트만의 고유한 가치를 창출할 수 있어야 합니다. 사용자들이 사이트를 먼저 방문하고 싶게 만드는 고유하고 관련성 높은 콘텐츠를 제공하는 것이 그 지름길입니다.

키워드부분

• title Body 태그에 있는 키워드 : 타이틀태그에 있는 키워드 - 타이틀태그 시작부근에 있는 10 - 60 글자, 특수문자 제외. 플로리다업데이트는 OOP의 일환으로 이 규칙에 대한 위반에도 벌점을 주었다고 합니다. 현재 키워드 부분에서 가장 중요한 랭크포인트입니다.
• H시리즈 태그 내의 키워드 : HTML 에는 특정 문구를 강조하기 위해 H1에서 H6까지의 태그가 존재합니다.
• URL 에 있는 키워드 : URL에 존재하는 키워드로 연관 검색어에서 중요한 척도이었지만 너무 많이 알려저서 현재는 중요랭크포인트에서 하위권에 존재합니다.
• 도메인명에 있는 키워드 : 도메인명에 존재 하는 키워드로 bar(-) 또는 Underbar(_)를 통해서 구분합니다.
• img 의alt (와)과title 에 포함되는 키워드(2.6)
• bold, strong 태그로 사용되는 키워드(2.4)
• meta 태그의deion 그리고 사용되는 키워드(2.1)
• meta 태그의keywords 그리고 사용되는 키워드(1.3)

페이지 특성부분

• 인바운드 링크(Inbound Link) : 자신의 페이지로 들어오는 링크를 말합니다. 자신의 페이지링크를 띄운 해당 페이지의 랭크에 따라 자신의 페이지 랭크 점수가 올라가게 됩니다. 예를들어 자신의 페이지를 페이지랭크 3으로 올려야 겠다고 생각하시면, 페이지랭크 1짜리의 각각의 다른페이지에서 555개의 링크를 받거나, 페이지랭크 2짜리의 각각의 다른 페이지에서 101개의 링크를 받게되면 자신의 페이지를 페이지랭크 3으로 만들수 있습니다. 가장 간단하게 페이지랭크 3을 만들려면 페이지랭크 5짜리 페이지에서 링크를 하나만 받으면 됩니다. 그 리고 페이지랭크 5를 만들려면 페이지랭크 7짜리 페이지에서 1개의 링크를 받던지 아님 6짜리 페이지에서 3개 내지는 4개의 링크를 받으면 됩니다. 페이지랭크 10짜리 페이지에서 링크를 받는다면 한번에 자신의 페이지랭크가 8로 올라갑니다.
• 아웃바운드 링크(Outbound Link) : 자신의 홈페이지에서 타 홈페이지로 나가는 링크를 말합니다. 예를 들어 링크가 존재하는 5랭크의 페이지에서 링크의 숫자가 50개라면 15점 정도밖에 안되지만, 링크의 숫자가 10개면 77점이 됩니다. 즉 페이지의 랭크가 높다고 무조건 좋은것이 아니라 얼마나 랭크가 높으면서도 링크가 적은 페이지에서 링크를 받느냐가 중요한 것입니다. 물론 3랭크의 10개의 링크만 존재하는 페이지에서 받는것보단 5랭크의 90개 링크들 중 하나가 더 높기 때문에 1순위는 페이지 랭크입니다. 자신의 홈페이지에 적용을 한다면 외부로 나가는 링크가 얼마나 좋은 품질의 홈페이지인가에 대해 페이지랭킹에 영향을 주게 됩니다.
• 시간의 변화에 대한 링크의 안정성 : 수시로 변하는 링크가 아닌 고정적 혹은 장기적인 링크를 받는게 좋습니다. Naver나 Daum의 경우 구글 페이지 랭킹은 7랭크이고 각각 메인화면에는 항상 각종 블로그의 링크들이 떠있습니다. 하지만 이 링크들은 수시로 변하기 때문에 해당 블로그들의 페이지 랭크에 영향을 주지 않는다는게 좋은 예입니다.
• 문서의 나이 : 해당 페이지의 나이가 영향을 미칩니다. 랭킹전략으로 해당 페이지를 미리 만들어놓고 차차 수정해 나가는 것이 올바른 전략입니다.
• 인덱싱 가능한 텍스트의 양 : 페이지에 너무 많은 키워드를 담고 있다면, 아웃바운드 링크와 비슷하게 해당 키워드에 대한 배점이 낮아지는 형식이기 때문에 관련된 인기 키워드들은 적은 수로 활용하는 것이 좋은 방법입니다.
• 알고리즘으로 측정하는 문서 컨텐츠의 품질
• 조직적/ 계층적인 문서?플로우(SiteMap)
• 페이지의 갱신 빈도
• URL 에 포함되는 slash의 수
• 스펠과 문법의 정확함
• 올바른 HTML 문서

구글 페이지에 부정적인 영향을 미치는 요소들

• 로봇이 빈번히 서버에 액세스 할 수 없다(3.8) 홈페이지의 대문이나 내용이 이미지이거나 Flash 혹은 그래픽으로 이루어진 경우는 이미지나 Flash 혹은 그래픽적으로 이루어진 페이지는 크롤링에서 식별 할 수 없기 때문에 아주 좋지 않은 홈페이지입니다.
• 안좋은 홈페이지로의 아웃바운드 링크 : 구글을 검색하다보면 구글홈페이지에서 해당 페이지는 악성코드를 배포하기 때문에 들어갈 수 없습니다 라는 페이지를 표시해주는걸 보셨을 것입니다. 이러한 안좋은 홈페이지들로의 아웃바운드 링크를 걸게 된다면 페이지랭크에서 불이익을 받게 됩니다.
• 욕설이나 비속어등의 단어
• 많은 페이지에 중복된 타이틀이나 Meta 태그가 존재할 경우
• 숨겨진 텍스트 : 플로리다업데이트 이후에 구글에서 검색엔진을 계속적으로 업데이트 하면서 숨겨진 텍스트를 통한 광고에 대해 벌칙을 적용하고 있는것 같습니다.
• 이 이외에도 다른 검색 포탈과 비슷하게 페이지의 트레픽, 페이지 선정률과 클릭스 페이지에 머무는 시간, 북마크 유무등이 랭크업에 도움을 줍니다.

출처

http://www.impact.pe.kr/files4wiki/seo.html
http://lisence.kr/meta/test/370?PHPSESSID=9f728a772eb2031e579c335c48711ba0

후배가 학교에서 C++을 이용하여 성적처리 프로그램 작성 과제를 받았다는군요

그런데 교수님이 중요한 class는 안가르쳐 주시고 예제위주로만 수업을 진행하여

후배는 class 의 개념도 모른채.. vector 과 sort 사용법만 대충알고 구조체를 이용해서 프로그램을 짜더군요

책보기도 질리고 오랜만에 키보드질좀 해볼까 하고 손을 대어 봤네요.

백터에서 구조체를 넣을때 정렬의 기준점을 정하는 방법이 여러가지가 있더군요.

class 나 struct나 거기서 거기일테지만 C에 익숙한 저는 저게 편하더군요.

#include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <stdlib.h>

using namespace std;

typedef struct _student_info
{
    string  name;
    double  mid_term;
    double  final_term;
    double  homework;
    double  final_score;
} st_info;

int menu( void );   // 메뉴 항목
void add_student( st_info *st );    // 학생 추가
void print_vector( vector &st );   // 점수 출력
bool compareToname( const st_info& lst, const st_info& rst );   // 이름으로 정렬
bool compareTofinal( const st_info& lst, const st_info& rst );  // 총점으로 정렬

int main( int argc, char *argv[] )
{
    int signal = 1;
    st_info         st;             // 백터에 추가하기 위한 임시 구조체
    vector v_st_info;      // 백터 선언
    while(signal)                   // 시그널을 주어서 0이면 반복 종료
    {
        switch( menu() )
        {
        case 1:                 // 학생추가
            add_student( &st );
            v_st_info.push_back( st );
            break;
        case 2:                 // 학생 리스트 출력
            print_vector( v_st_info );
            break;
        case 3:                 // 이름으로 정렬
            sort( v_st_info.begin(), v_st_info.end(), compareToname );
            break;
        case 4:                 // 점수로 정렬
            sort( v_st_info.begin(), v_st_info.end(), compareTofinal );
            break;
        case 5:                 // 종료모드
            signal = 0;
            break;
        default :               // 입력이 잘못됨. 숫자제외문자 처리요망
            cout << "You input Number is bad" << endl;
            cin.ignore();       // 작동안되는듯
            break;
        }
        // 임시 구조체 변수 초기화
        st.name.clear();
        st.mid_term     = 0.0;
        st.final_term   = 0.0;
        st.homework     = 0.0;
        st.final_score  = 0.0;
    }
    return 0;
}


int menu( void )
{   // 메뉴 출력 및 입력
    int menu;
    cout<< "1. add Student" << endl
        << "2. print" << endl
        << "3. des_sort" << endl
        << "4. asc_sort" << endl;
    cout<< "Input Number : ";
    cin >> menu;
    return menu;
}

void add_student( st_info *st ) // 임시구조체 변수 입력 받기
{                               // 참조 타입이 안먹혀서 포인터타입으로 받음
    cout << "Input name  : "; cin >> st->name;
    cout << "Input Middle test score : "; cin >> st->mid_term;
    cout << "Input Final Test Score : "; cin >> st->final_term;
    cout << "Input homework : "; cin >> st->homework;
    st->final_score = 0.2 * st->mid_term + 0.4 * st->final_term + 0.4 * st->homework;
}

void print_vector( vector &st )    // 학생 리스트 출력 이름과 총점만
{
    vector::size_type i;
    for( i=0 ; i

 

전북대학교 분할정복 알고리즘

#include <stdio.h>
#include <stdlib.h>
typedef struct  _node
{
    int             key;
    struct _node    *next;
} node;
#define success 1
#define fail    0
node    *init_node( void );     //head와 tail node의 초기화
node    *delete_all( node *head );      // head와 tail을 제외한 모든 node 삭제
node    *find_key( node *head, int s_key ); // 주어진 key값으로 node탐색
int     insert_node( node *head, int i_key );   // head와 첫번째 node사이 삽입
int     delete_node( node *node_n );    // 주어진 node의 다음 node 삭제
int     insert_key( node *head, int f_key, int i_key ); // 주어진 key값의 node 새로운 node 삽입
int     delete_key( node *head, int d_key );    // 주어진 key값의 노드삭제
void    print_node( node *head );   // node 출력

//  구현해야할 함수
//  oscending_node()   오름차순정렬
//  descending_node()   내림차순 정렬
int main( int argc, char **argv )
{
    int     result  =   0;
    node    *temp   =   NULL;
    node    *head   =   init_node();
    fputs( "Insert Node 1 to 10\n", stdout );
    insert_node( head, 10 );
    insert_node( head, 9 );
    insert_node( head, 8 );
    insert_node( head, 7 );
    insert_node( head, 6 );
    insert_node( head, 5 );
    insert_node( head, 4 );
    insert_node( head, 3 );
    insert_node( head, 2 );
    insert_node( head, 1 );
    print_node( head );
    fputs( "Finding key 5\n", stdout );
    temp    =   find_key( head, 5 );
    printf( "Finding 5 is %ssuccessful\n", temp == NULL ? "un" : "" );
    fputs( "Insert key 11 after 3\n", stdout );
    insert_key( head, 3, 11 );
    print_node( head );
    fputs( "Delete key 10\n", stdout );
    delete_key( head, 10 );
    print_node( head );
    fputs( "Finding key 3 and Delete next node\n", stdout );
    temp    =    find_key( head, 3 );
    delete_node( temp );
    print_node( head );
    fputs( "Delete key 7\n", stdout );
    delete_key( head, 7 );
    print_node( head );
    fputs( "Delete all node\n", stdout );
    delete_all( head );
    print_node( head );
    return 0;
}
node    *init_node( void )
{
    node    *head   =   (node *)malloc( sizeof(node) ); // head node initialization
    node    *tail   =   (node *)malloc( sizeof(node) ); // tail node initialization
    if( head == NULL ) // Head Node에 대해 할당에 실패했을때
    {
        fputs( "Failed to allocate for Head node\n", stdout );
        return  NULL;
    }
    if( tail == NULL ) // Tail Node에 대해 할당에 실패했을때
    {
        fputs( "Failed to allocate for tail node\n", stdout );
        free( head );  // Tail Node에 대해 할당에 실패했을 땐, Head Node를 해제
        return NULL;
    }
    head->next  =   tail;
    tail->next  =   NULL;
    return  head;
}

node    *delete_all( node *head )
{
    node    *navi_node  =   head->next; // 순회노드 선언 및 head 다음으로 설정
    node    *free_node  =   NULL;          // 해제노드 선언
    while( navi_node->next != NULL ) // 순회노드가 tail에 이를때까지
    {
        free_node   =   navi_node;
        navi_node   =   navi_node->next;
        free( free_node );
    }
    head->next  =   navi_node; // navi_node 가 성공적으로 루프를 종료했다면 tail
    return head;
}
node    *find_key( node *head, int s_key )
{
    node    *navi_node =   head->next; // head 다음노드로 설정
    while( navi_node->key != s_key && navi_node->next != NULL ) // key값을 찾거나 꼬리에 이를때까지
        //
    {
        navi_node   =   navi_node->next;
    }
    if( navi_node->key == s_key ) // key값을 찾았을경우
    {
        return navi_node;
    }
    else if( navi_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Node is tail\n", stdout );
        return NULL;
    }
}
int     insert_node( node *head, int i_key)
{
    node    *i_node =   NULL;  // 삽입노드 선언
    i_node          =   (node *)malloc( sizeof(node) ); // 삽입노드 할당
    if( i_node == NULL )
    {
        fputs( "Failed to allocate for Insert Node\n", stdout );
        return fail;
    }
    i_node->key     =   i_key;
    i_node->next    =   head->next;
    head->next      =   i_node;
    return success;
}
int     delete_node( node *node_d)
{
    node        *delete_node    =   node_d->next; // 삭제노드 선언 및 node_next다음노드로 설정
    if( delete_node->next == NULL )
    {
        fputs( "Next node is tail.\n", stdout );
        return fail;
    }
    node_d->next    =   delete_node->next;
    free( delete_node );
    return success;
}
int     insert_key( node *head, int f_key, int i_key )
{
    node    *i_node     =   NULL;
    node    *s_node     =   head->next; // 탐색노드
    while( s_node->next != NULL && s_node->key != f_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
    }
    if( s_node->key == f_key ) // key값일경우
    {
        i_node          =   (node *)malloc( sizeof(node) );
        if( i_node == NULL ) // 할당에 실패했을때
        {
            fputs( "Failed to allocate for Insert node\n", stdout );
            return fail;
        }
        i_node->next    =   s_node->next;
        i_node->key     =   i_key;
        s_node->next    =   i_node;
        return success;
    }
    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}
int     delete_key( node *head, int d_key )
{
    node    *s_node =   head->next; // 탐색노드
    node    *p_node =   head; // 탐색노드를 따라갈 이전노드
    while( s_node->next != NULL && s_node->key != d_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
        p_node  =   p_node->next;
    }
    if( s_node->key == d_key ) // key값일경우
    {
        p_node->next    =   s_node->next;
        free( s_node );
        return success;
    }
    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}
void    print_node( node *head )
{
    node    *c_node =   head->next; // 탐색노드
    int     index_node  =   0; // 노드 개수
    printf("--------------------------------------------------\n");
    while( c_node->next  != NULL )
    {
        index_node++;
        fprintf(stdout, "%2dth Node key value : %2d\n", index_node, c_node->key );
        c_node  =   c_node->next;
    }
    printf("--------------------------------------------------\n");
}
}

#include    <stdio.h>
#include    <stdlib.h>
#include    <string.h>
#include    <unistd.h>
#include    <arpa/inet.h>
#include    <sys/types.h>
#include    <sys/socket.h>
#include    <netdb.h>

void    error_handling( char *message );
void    response( char *recv );
void    pong ( char *ping );

#define MAX 8192

int     sockfd;


int     main( int argc, char *argv[] )
{
    const   char    address[64]    =   "irc.hanirc.org";

    char    nickname[64]    =   "Luna_bot";
    char    channel[64]     =   "#프겔";

    int     port            =   6664;

    struct  sockaddr_in sock;
    struct  hostent     *host_st;

    char    rcv_data[MAX]  =   {0x00, };
    char    send[1024]      =   {0x00, };

    char    *ping;

    host_st     =   gethostbyname( address );
    if( host_st == NULL)
    {
        error_handling( "gethostbyname() error" );
    }

    sockfd      =   socket( AF_INET, SOCK_STREAM, 0 );
    if( sockfd == -1 )
    {
        error_handling( "socket() error" );
    }

    memset( &sock, 0x0, sizeof(sock) );
    sock.sin_family     =   AF_INET;
    sock.sin_port       =   htons( port );
    sock.sin_addr       =   *((struct in_addr*)host_st->h_addr);

    if( connect( sockfd, (struct sockaddr *)&sock, sizeof(sock) ) == -1 )
    {
        error_handling( "connect() error" );
    }

    strncpy( send, "NICK Luna_bot \n", sizeof(send) - 1 );
    printf( "Request : %s", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    strncpy( send, "USER iam5duck \"naver.com\" \"irc.hanric.org\" : Luna\n", sizeof(send) -1 );
    printf( "Request : %s\n", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "NICK Luna_bot \n", sizeof(send) - 1 );
    printf( "Request : %s", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    /*    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );
    */
    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "USERHOST LaLuna\n", sizeof(send) - 1 );
    printf( "Request : %s", send);
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof(send) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "JOIN #프갤\n", sizeof(send) - 1 );
    printf( "Request : %s", send );
    write( sockfd, send, strlen(send) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    read( sockfd, rcv_data, sizeof(rcv_data) );
    response( rcv_data );
    memset( rcv_data, 0x0, sizeof( rcv_data ) );

    strncpy( send, "PRIVMSG #프갤 :HI I'am LaLuna Bot\n", sizeof(send) - 1 );
    printf( "Request : %s", send );
    write( sockfd, send, strlen(send) );
    memset( send, 0x0, sizeof( send ) );

    while( 1 )
    {
        read( sockfd, rcv_data, sizeof(rcv_data) );
        response( rcv_data );

        if( strstr( rcv_data, "!out" ) )
        {
            memset(send, 0x0, sizeof(send) );
            strncpy( send, "PRIVMSG #프갤 :Luna_bot 갑니다 ㅂ2ㅂ2\n", sizeof(send) - 1 );
            break;
        }

        if( strstr( rcv_data, "Luna_bot" ) )
        {
            strncpy( send, "PRIVMSG #프갤 :I am so hot, 난 너무 예뻐요\n ", sizeof(send) -1 );
            write( sockfd, send, strlen( send ) );
            memset( send, 0x0, sizeof( send ) );
        }
        memset( rcv_data, 0x0, sizeof( rcv_data ) );
    }

    close( sockfd );
    return 0;
}

void    error_handling( char *message )
{
    fputs( message, stderr );
    fputc( '\n', stderr );
    exit( 1 );
}

void    response( char *recv )
{
    char    temp[MAX];
    char    *parsing;
    char    *ping;

    printf( "-----------------------------------------------\n");
    strncpy( temp, recv, sizeof(temp) - 1);

    parsing     =   strtok( temp, "\n");

    while( parsing != NULL )
    {
        if( parsing )   printf( "Response : %s\n", parsing );
        if( (strstr( parsing, "PING " )) != NULL )
        {
            pong( parsing );
        }
        parsing =   strtok( NULL, "\n" );
    }
    printf( "-----------------------------------------------\n");
}

void    pong( char *ping )
{
    char    temp[MAX]  =   {0x00, };
    char    *parsing;

    strncpy( temp, ping, strlen( ping ) + 1 );
    parsing     =   strtok( temp, "\n" );
    memcpy( parsing, "PONG", 4 );

    printf( "PINGPONG : %s\n", parsing );
    write( sockfd, parsing, strlen( parsing ) + 1 );
}

int insert_key( node *head, int f_key, int i_key )

삽입노드 선언

탐색노드 선언 및 head다음노드로 설정

key값을 찾거나 꼬리에 도달할때까지 반복

탐색노드를 다음노드로 이동

if( key값을 찾으면 )

삽입노드 할당 및 key값 설정 ( 할당에 실패하면 함수 종료 )

삽입노드 다음을 탐색노드 다음으로 설정

탐색노드 다음을 삽입노드로 설정

success 반환

else if( 꼬리라면 )

에러메세지 출력

fail 반환

1. 성공시
• success반환
2. 실패시
• fail 반환
3. 인자값
• head : head 주소값
• i_key : 삽입할 노드의 key 값
  

int     insert_key( node *head, int f_key, int i_key )
{
    node    *i_node     =   NULL;
    node    *s_node     =   head->next; // 탐색노드

    while( s_node->next != NULL && s_node->key != f_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
    }

    if( s_node->key == f_key ) // key값일경우
    {
        i_node          =   (node *)malloc( sizeof(node) );
        if( i_node == NULL ) // 할당에 실패했을때
        {
            fputs( "Failed to allocate for Insert node\n", stdout );
            return fail;
        }
        i_node->next    =   s_node->next;
        i_node->key     =   i_key;
        s_node->next    =   i_node;
        return success;
    }
    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}

int  delete_key( node *head, int d_key )

탐색노드 선언 및 head 다음노드로 설정

탐색노드를 따라갈 이전노드 선언

탐색노드가 key값을 찾거나 꼬리에 도달할때까지 반복

이전노드를 탐색노드로 설정

탐색노드는 다음노드로 이동

if( key값을 찾았으면 )

이전노드 다음노드를 탐색노드 다음노드로 설정

탐색노드 해제

success 반환

else if( 꼬리라면 )

에러메세지 출력

fail 반환

1. 성공시
• success반환
2. 실패시
• fail 반환
3. 인자값
• head : head 주소값
• int d_key : 삭제할 노드의 key 값

int     delete_key( node *head, int d_key )
{
    node    *s_node =   head->next; // 탐색노드
    node    *p_node =   head; // 탐색노드를 따라갈 이전노드

    while( s_node->next != NULL && s_node->key != d_key ) // key값을 찾거나 꼬리에 도달할때까지
    {
        s_node  =   s_node->next;
        p_node  =   p_node->next;
    }

    if( s_node->key == d_key ) // key값일경우
    {
        p_node->next    =   s_node->next;
        free( s_node );
        return success;
    }

    else if( s_node->next == NULL ) // 꼬리일경우
    {
        fputs( "Search node is tail.\n", stdout );
        return fail;
    }
}

typedef struct  _node
{
    int             key;       // key값을 저장
    struct _node    *next;       // 다음 node의 주소
} node;

#define success 1
#define fail   0

node    *init_node( void );     //head와 tail node의 초기화
node    *delete_all( node *head );      // head와 tail을 제외한 모든 node 삭제
node    *find_key( node *head, int s_key ); // 주어진 key값으로 node탐색
int     insert_node( node *head, int i_key );   // head와 첫번째 node사이 삽입
int     delete_node( node *node_n );    // 주어진 node의 다음 node 삭제
int     insert_key( node *head, int f_key, int i_key ); // 주어진 key값의 node 새로운 node 삽입
int     delete_key( node *head, int d_key );    // 주어진 key값의 노드삭제
void    print_node( node *head );   // node 출력
//  구현해야할 함수
//  oscending_node()   오름차순정렬
//  descending_node()   내림차순 정렬