반응형

Linkedlist를 이용하여 List에 데이터를 넣었다가 빼고, 리스트에 존재하는지 등에 대한 Function들을 작성해보았습니다.

(비교, ArrayList 사용하기 : http://jwprogramming.tistory.com/228 )


(1) linkedlistmain.c

#include <stdio.h>

#include <stdlib.h>

#include "linkedlist.h"


int main(int argc, char* argv[]) {

int i = 0;

int arrayCount = 0;

LinkedList * pList = NULL;

ListNode * pNode = NULL;

ListNode node;

pList = createLinkedList();

if (pList != NULL) {

node.data = 1;

addLLElement(pList, 0, node);

node.data = 3;

addLLElement(pList, 1, node);

node.data = 5;

addLLElement(pList, 2, node);

displayLinkedList(pList);

removeLLElement(pList, 0);

displayLinkedList(pList);

deleteLinkedList(pList);

}

return 0;

}


(2) linkedlist.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "linkedlist.h"


LinkedList* createLinkedList() {

LinkedList *pReturn = NULL;

int i = 0;

pReturn = (LinkedList *)malloc(sizeof(LinkedList));

if (pReturn != NULL) {

memset(pReturn, 0, sizeof(LinkedList));

}

else {

printf("오류, 메모리할당 createLinkedList() \n");

return NULL;

}

return pReturn;

}

int addLLElement(LinkedList* pList, int position, ListNode element) {

int ret = FALSE;

int i = 0;

ListNode* pPreNode = NULL;

ListNode* pNewNode = NULL;

if (pList != NULL) {

if (position >= 0 && position <= pList->currentElementCount) {

pNewNode = (ListNode*)malloc(sizeof(ListNode));

if (pNewNode != NULL) {

*pNewNode = element;

pNewNode->pLink = NULL;

pPreNode = &(pList->headerNode);

for (i = 0; i < position; i++) {

pPreNode = pPreNode->pLink;

}

pNewNode->pLink = pPreNode->pLink;

pPreNode->pLink = pNewNode;

pList->currentElementCount++;

ret = TRUE;

}

else {

printf("오류, 메모리할당 addLLElement() \n");

return ret;

}

}

else {

printf("오류, 위치 인덱스-[%d], addLLElement() \n", position);

}

}

return ret;

}

int removeLLElement(LinkedList* pList, int position) {

int ret = FALSE;

int i = 0;

int arrayCount = 0;

ListNode* pNode = NULL;

ListNode* pDelNode = NULL;

if (pList != NULL) {

arrayCount = getLinkedListLength(pList);

if (position >= 0 && position < arrayCount) {

pNode = &(pList->headerNode);

for (i = 0; i < position; i++) {

pNode = pNode->pLink;

}

pDelNode = pNode->pLink;

pNode->pLink = pDelNode->pLink;

free(pDelNode);

pList->currentElementCount--;

ret = TRUE;

}

else {

printf("오류, 위치 인덱스-[%d] removeLLElement() \n", position);

}

}

return ret;

}

ListNode* getLLElement(LinkedList* pList, int position) {

ListNode* pReturn = NULL;

int i = 0;

ListNode* pNode = NULL;

if (pList != NULL) {

if (position >= 0 && position < pList->currentElementCount) {

pNode = &(pList->headerNode);

for (i = 0; i <= position; i++) {

pNode = pNode->pLink;

}

pReturn = pNode;

}

}

return pReturn;

}

void deleteLinkedList(LinkedList* pList) {

int i = 0;

if (pList != NULL) {

clearLinkedList(pList);

free(pList);

}

}

void clearLinkedList(LinkedList* pList) {

if (pList != NULL) {

if (pList->currentElementCount > 0) {

removeLLElement(pList, 0);

}

}

}

int getLinkedListLength(LinkedList* pList) {

int ret = 0;

if (pList != NULL) {

ret = pList->currentElementCount;

}

return ret;

}

int isEmpty(LinkedList* pList) {

int ret = FALSE;

if (pList != NULL) {

if (pList->currentElementCount == 0) {

ret = TRUE;

}

}

return ret;

}


void displayLinkedList(LinkedList* pList) {

int i = 0;

if (pList != NULL) {

printf("현재 원소 개수 : %d\n", pList->currentElementCount);

for (i = 0; i < pList->currentElementCount; i++) {

printf("[%d], %d\n", i, getLLElement(pList, i)->data);

}

}

else {

printf("원소가 없습니다.\n");

}

}


(3) linkedlist.h

#ifndef _LINKEDLIST_

#define _LINKEDLIST_


typedef struct ListNodeType

{

int data;

struct ListNodeType* pLink;

} ListNode;


typedef struct LinkedListType

{

int currentElementCount;

ListNode headerNode;

} LinkedList;


void displayLinkedList(LinkedList* pList);

LinkedList* createLinkedList();

int addLLElement(LinkedList* pList, int position, ListNode element);

int removeLLElement(LinkedList* pList, int position);

ListNode* getLLElement(LinkedList* pList, int position);

void deleteLinkedList(LinkedList* pList);

void clearLinkedList(LinkedList* pList);

int getLinkedListLength(LinkedList* pList);

int isEmpty(LinkedList* pList);

void displayLinkedList(LinkedList* pList);


#endif



#ifndef _COMMON_LIST_DEF_

#define _COMMON_LIST_DEF_


#define TRUE 1

#define FALSE 0


#endif

반응형

'Programming > C' 카테고리의 다른 글

(5) DoubleLinkedList 사용하기  (0) 2016.10.30
(4) Linkedlist 를 이용하여 Reverse, Concat 응용  (0) 2016.10.30
(2) ArrayStack 사용하기  (0) 2016.10.30
(1) ArrayList 사용하기  (0) 2016.10.30
C언어란?  (0) 2016.04.18

WRITTEN BY
SiriusJ

,
반응형

ArrayStack을 이용하여 Stack에 데이터를 넣었다가 빼고, 스택에 존재하는지, 현재 스택 상태 출력 등에 대한 Function들을 작성해보았습니다.


(1) arraystackmain.c

#include <stdio.h>

#include <stdlib.h>

#include "arraystack.h"


int main(int argc, char* argv[]) {

char value = 0;

ArrayStack *pStack = NULL;

ArrayStackNode *pNode = NULL;

pStack = createArrayStack(6);


if (pStack != NULL) {

ArrayStackNode node1 = { 'A' };

ArrayStackNode node2 = { 'B' };

ArrayStackNode node3 = { 'C' };

ArrayStackNode node4 = { 'D' };

pushAS(pStack, node1);

pushAS(pStack, node2);

pushAS(pStack, node3);

pushAS(pStack, node4);

displayArrayStack(pStack);

pNode = popAS(pStack);

if (pNode != NULL) {

printf("Pop 값-[%c]\n", pNode->data);

free(pNode);

}

else {

printf("공백(Empty) 스택\n");

}

displayArrayStack(pStack);

pNode = peekAS(pStack);

if (pNode != NULL) {

printf("Peek 값 - [%c]\n", pNode->data);

}

else {

printf("공백(Empty) 스택\n");

}

displayArrayStack(pStack);

}

return 0;

}


(2) arraystack.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "arraystack.h"


ArrayStack* createArrayStack(int size) {

ArrayStack *pReturn = NULL;

int i = 0;


if (size > 0) {

pReturn = (ArrayStack *)malloc(sizeof(ArrayStack));

if (pReturn != NULL) {

memset(pReturn, 0, sizeof(ArrayStack));

pReturn->maxElementCount = size;

pReturn->currentElementCount = 0;

}

else {

printf("오류, 메모리 할당, createArrayStack()\n");

return NULL;

}

}

else {

printf("오류, 스택의 크기는 0이상이어야 합니다.\n");

return NULL;

}


pReturn->pElement = (ArrayStackNode *)malloc(sizeof(ArrayStackNode)*size);


return pReturn;

}


int pushAS(ArrayStack* pStack, ArrayStackNode element) {

int i = 0;

int ret = FALSE;

if (pStack != NULL) {

if (isArrayStackFull(pStack) == FALSE) {

pStack->pElement[pStack->currentElementCount] = element;

pStack->currentElementCount++;

ret = TRUE;

}

else {

printf("오류, 스택이 가득 찼습니다, pushAS()\n");

}

}

return ret;

}


ArrayStackNode* popAS(ArrayStack* pStack) {

ArrayStackNode* pReturn = NULL;

if (pStack != NULL) {

if (isArrayStackEmpty(pStack) == FALSE) {

pReturn = (ArrayStackNode *)malloc(sizeof(ArrayStackNode));

if (pReturn != NULL) {

*pReturn = pStack->pElement[pStack->currentElementCount - 1];

pStack->currentElementCount--;

}

else {

printf("오류, 메모리할당, popAS()\n");

}

}

}

return pReturn;

}


ArrayStackNode* peekAS(ArrayStack* pStack) {

ArrayStackNode* pReturn = NULL;

if (pStack != NULL) {

if (isArrayStackEmpty(pStack) == FALSE) {

pReturn = &(pStack->pElement[pStack->currentElementCount - 1]);

}

}

return pReturn;

}


void deleteArrayStack(ArrayStack* pStack) {

if (pStack != NULL) {

if (pStack->pElement != NULL) {

free(pStack->pElement);

}

free(pStack);

}

}


int isArrayStackFull(ArrayStack* pStack) {

int ret = FALSE;


if (pStack != NULL) {

if (pStack->currentElementCount == pStack->maxElementCount) {

ret = TRUE;

}

}

return ret;

}


int isArrayStackEmpty(ArrayStack* pStack) {

int ret = FALSE;


if (pStack != NULL) {

if (pStack->currentElementCount == 0) {

ret = TRUE;

}

}


return ret;

}


void displayArrayStack(ArrayStack *pStack) {

int i = 0;

if (pStack != NULL) {

int size = pStack->maxElementCount;

int top = pStack->currentElementCount;

printf("스택 크기: %d, 현재 노드 개수: %d\n", pStack->maxElementCount, pStack->currentElementCount);

for (i = size - 1; i >= top; i--) {

printf("[%d]-[Empty]\n", i);

}

for (i = top - 1; i >= 0; i--) {

printf("[%d]-[%c]\n", i, pStack->pElement[i].data);

}

}

}


(3) arraystack.h

#ifndef _ARRAY_STACK_

#define _ARRAY_STACK_


typedef struct ArrayStackNodeType {

char data;

} ArrayStackNode;


typedef struct ArrayStackType {

int maxElementCount;

int currentElementCount;

ArrayStackNode *pElement;

} ArrayStack;


ArrayStack* createArrayStack(int size);

int pushAS(ArrayStack* pStack, ArrayStackNode element);

ArrayStackNode* popAS(ArrayStack* pStack);

ArrayStackNode* peekAS(ArrayStack* pStack);

void deleteArrayStack(ArrayStack* pStack);

int isArrayStackFull(ArrayStack* pStack);

int isArrayStackEmpty(ArrayStack* pStack);

void displayArrayStack(ArrayStack *pStack);


#endif


#ifndef _COMMON_STACK_DEF_

#define _COMMON_STACK_DEF_


#define TRUE 1

#define FALSE 0


#endif

반응형

'Programming > C' 카테고리의 다른 글

(5) DoubleLinkedList 사용하기  (0) 2016.10.30
(4) Linkedlist 를 이용하여 Reverse, Concat 응용  (0) 2016.10.30
(3) Linkedlist 사용하기  (0) 2016.10.30
(1) ArrayList 사용하기  (0) 2016.10.30
C언어란?  (0) 2016.04.18

WRITTEN BY
SiriusJ

,
반응형

ArrayList를 이용하여 List에 데이터를 넣었다가 빼고, 리스트에 존재하는지 등에 대한 Function들을 작성해보았습니다.


(1) arraylistmain.c

#include <stdio.h>

#include <stdlib.h>

#include "arraylist.h"


int main(int argc, char *argv[]) {

int i = 0, arrayCount = 0;


ArrayList *pList = NULL;

ArrayListNode *pValue = NULL;


pList = createArrayList(6);


if (pList != NULL) {

ArrayListNode node;

node.data = 1;

addALElement(pList, 0, node);

node.data = 3;

addALElement(pList, 1, node);

node.data = 5;

addALElement(pList, 2, node);


displayArrayList(pList);


removeALElement(pList, 0);


displayArrayList(pList);


arrayCount = getArrayListLength(pList);


for (i = 0; i < arrayCount; i++) {

pValue = getALElement(pList, i);

printf("ArrayList[%d]-%d\n", i, pValue->data);

}

deleteArrayList(pList);

}

return 0;

}



(2)arraylist.c

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "arraylist.h"


ArrayList* createArrayList(int maxElementCount) {

ArrayList *pReturn = NULL;

int i = 0;


if (maxElementCount > 0) {

pReturn = (ArrayList *)malloc(sizeof(ArrayList));


if (pReturn != NULL) {

pReturn->maxElementCount = maxElementCount;

pReturn->currentElementCount = 0;

pReturn->pElement = NULL;

}


else {

printf("오류, 메모리할당 createArrayList() \n");

return NULL;

}

}


else {

printf("오류, 최대 원소 개수는 0이상이어야 합니다.\n");

return NULL;

}


pReturn->pElement = (ArrayListNode *)malloc(sizeof(ArrayListNode)*maxElementCount);


if (pReturn->pElement == NULL) {

printf("오류, 2번째 메모리 할당 crateArrayList() \n");

free(pReturn); return NULL;

}

memset(pReturn->pElement, 0, sizeof(ArrayListNode)*maxElementCount);


return pReturn;

}


int addALElement(ArrayList* pList, int position, ArrayListNode element) {

int ret = FALSE;

int i = 0;


if (pList != NULL) {

if (isArrayListFull(pList) != TRUE) {

if (position >= 0 && position <= pList->currentElementCount) {

for (i = pList->currentElementCount - 1; i >= position; i--) {

pList->pElement[i + 1] = pList->pElement[i];

}


pList->pElement[position] = element;


pList->currentElementCount++;


ret = TRUE;

}

else {

printf("오류, 위치 인덱스-[%d] 범위초과, addALElement()\n", position);

}

}


else {

printf("오류, 리스트 용량초과-[%d]/[%d]\n", position, pList->maxElementCount);

}

}


return ret;

}


int removeALElement(ArrayList* pList, int position) {

int ret = FALSE;

int i = 0;


if (pList != NULL) {

if (position >= 0 && position < pList->currentElementCount) {

for (i = position; i < pList->currentElementCount - 1; i++) {

pList->pElement[i] = pList->pElement[i + 1];

}


pList->currentElementCount--;

ret = TRUE;

}

else {

printf("오류, 위치 인덱스-[%d] 범위 초과, removeALElement()\n", position);

}

}


return ret;

}


ArrayListNode* getALElement(ArrayList* pList, int position) {

ArrayListNode* pReturn = NULL;

if (pList != NULL) {

if (position >= 0 && position < getArrayListLength(pList)) {

pReturn = &(pList->pElement[position]);

}

else {

printf("오류, 위치 인덱스-[%d] 범위 초과, getTALElement() \n", position);

}

}


return pReturn;

}


void displayArrayList(ArrayList* pList) {

int i = 0;

if (pList != NULL) {

printf("최대 원소 개수 : %d\n", pList->maxElementCount);

printf("현재 원소 개수 : %d\n", pList->currentElementCount);


for (i = 0; i < pList->currentElementCount; i++) {

printf("[%d], %d\n", i, getALElement(pList, i)->data);

}


i = pList->currentElementCount;

for (; i < pList->maxElementCount; i++) {

printf("[%d], Empty\n", i);

}

}

else {

printf("ArrayList is NULL");

}

}


int isArrayListFull(ArrayList* pList) {

int ret = FALSE;


if (pList != NULL) {

if (pList->currentElementCount == pList->maxElementCount) {

ret = TRUE;

}

}

return ret;

}


int getArrayListLength(ArrayList* pList) {

int ret = 0;

if (pList != NULL) {

ret = pList->currentElementCount;

}

return ret;

}


void deleteArrayList(ArrayList* pList) {

int i = 0;

if (pList != NULL) {

free(pList->pElement);

free(pList);

}

}


(3)arraylist.h    (Header File)

#ifndef _ARRAYLIST_

#define _ARRAYLIST_


typedef struct ArrayListNodeType

{

int data;

} ArrayListNode;


typedef struct ArrayListType

{

int maxElementCount;

int currentElementCount;

ArrayListNode *pElement;

} ArrayList;


ArrayList* createArrayList(int maxElementCount);

int addALElement(ArrayList* pList, int position, ArrayListNode element);

int removeALElement(ArrayList* pList, int position);

ArrayListNode* getALElement(ArrayList* pList, int position);

void displayArrayList(ArrayList* pList);

int isArrayListFull(ArrayList* pList);

int getArrayListLength(ArrayList* pList);

void deleteArrayList(ArrayList* pList);


#endif


#ifndef _COMMON_LIST_DEF_

#define _COMMON_LIST_DEF_


#define TRUE 1

#define FALSE 0


#endif


반응형

'Programming > C' 카테고리의 다른 글

(5) DoubleLinkedList 사용하기  (0) 2016.10.30
(4) Linkedlist 를 이용하여 Reverse, Concat 응용  (0) 2016.10.30
(3) Linkedlist 사용하기  (0) 2016.10.30
(2) ArrayStack 사용하기  (0) 2016.10.30
C언어란?  (0) 2016.04.18

WRITTEN BY
SiriusJ

,
반응형

파이썬 Merge Sort로 오름차순으로 정렬하는 방식입니다.


시간복잡도 : O(nlogn)


(CASE 1)

def mergeSort(A):

    left = []

    right = []

    

    if len(A) > 1:

        mid = len(A) / 2


        for l in range(0, mid, 1):

            left.append(A[l])

        for r in range(mid, len(A), 1):

            right.append(A[r])


        mergeSort(left)

        mergeSort(right)

        

        i=j=k=0

        

        while i < len(left) and j < len(right):

            if left[i] < right[j]:

                A[k]=left[i]

                i += 1

            else:

                A[k]=right[j]

                j += 1

            k += 1


        while i < len(left):

            A[k]=left[i]

            i += 1

            k += 1


        while j < len(right):

            A[k]=right[j]

            j += 1

            k += 1


if __name__ == '__main__':

    A= [1, 8, 6, 10, 4, 5, 3, 22]

    mergeSort(A)

    print A



(CASE 2)

def merge_sort(A, first, last):

    mid = 0

    if first < last:

        mid = (first + last) / 2

        merge_sort(A, first, mid)

        merge_sort(A, mid+1, last)

        merge(A, first, last)


def merge(A, first, last):

    temp = []

    mid = (first + last) / 2

    i = first

    j = mid + 1

    k = 0


    while i <= mid and j <= last:

        if A[i] <= A[j]:

            temp.append(A[i])

            i += 1

        else:

            temp.append(A[j])

            j += 1


    if i > mid:

        for t in range(j, last+1):

            temp.append(A[t])


    else:

        for t in range(i, mid+1):

            temp.append(A[t])

    

    for t in range(first, last+1, 1):

        A[t] = temp[k]

        k += 1

    

if __name__ == '__main__':

    A= [1, 8, 6, 10, 4, 5, 3, 22]

    merge_sort(A, 0, len(A)-1)


    print A

반응형

WRITTEN BY
SiriusJ

,
반응형

파이썬 Heap Sort로 내림차순으로 정렬하는 방식입니다.


시간복잡도 : O(nlogn)


def heapify(A, n, k):

    while 2*k+1 < n:

        L = 2*k+1

        R = 2*k+2


        if A[k] > A[L]:

            m = L

        else:

            m = k

        if R < n and A[m] > A[R]:

            m = R

        if k != m:

            A[k], A[m] = A[m], A[k]

            k = m

        else:

            break


def make_heap(A):

    for k in range(len(A)/2, -1, -1):

        heapify(A, len(A), k)


def heapSort(A):

    make_heap(A)

    n = len(A)

    for k in range(len(A)-1):

        A[0], A[n-1] = A[n-1], A[0]

        n = n-1

        heapify(A, n, 0)


if __name__ == '__main__':

    A = [3, 10, 7, 9, 8, 5, 12, 21, 4, 15]

    heapSort(A)

    print A


반응형

WRITTEN BY
SiriusJ

,
반응형

파이썬 Heap Sort로 오름차순으로 정렬하는 방식입니다.

시간복잡도 : O(nlogn)


def heapify(A, n, k):

    while 2*k+1 < n:

        L = 2*k+1

        R = 2*k+2


        if A[k] < A[L]:

            m = L

        else:

            m = k

        if R < n and A[m] < A[R]:

            m = R

            

        if k != m:

            A[k], A[m] = A[m], A[k]

            k = m

        else:

            break


def make_heap(A):

    for k in range(len(A)/2, -1, -1):

        heapify(A, len(A), k)


def heapSort(A):

    make_heap(A)

    n = len(A)

    

    for k in range(n-1):

        A[0], A[n-1] = A[n-1], A[0]

        n -= 1

        heapify(A, n, 0)


if __name__ == '__main__':

    A = [3, 10, 7, 9, 8, 5, 12, 21, 4, 15]

    heapSort(A)

    print A

반응형

WRITTEN BY
SiriusJ

,
반응형

파이썬 Selection Sort로 오름차순으로 정렬하는 방식입니다.


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


def selectionSort(A):

    for i in range(len(A)):

        minValue = i

        for j in range(i+1, len(A)):

            if A[j] < A[minValue]:

                minValue = j


        A[minValue], A[i] = A[i], A[minValue]


if __name__ == '__main__':

    A = [4, 1, 5, 8, 6, 2, 3, 7, 10]

    selectionSort(A)

    print A



반응형

WRITTEN BY
SiriusJ

,
반응형

파이썬 Insertion Sort로 오름차순으로 정렬하는 방식입니다.


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


def insertionSort(A):

    for i in range(1, len(A)):

        temp = A[i]

        j = i

        while j > 0 and A[j-1] > temp:

            A[j] = A[j-1]

            j -= 1

        A[j] = temp


if __name__ == '__main__':

    A = [4, 1, 5, 8, 6, 2, 3, 7, 10]

    insertionSort(A)

    print A


반응형

'Programming > Python' 카테고리의 다른 글

Sorting(5) Heap Sort(힙 정렬 - min Heap)  (0) 2016.10.27
Sorting(4) Selection Sort(선택 정렬)  (0) 2016.10.27
Sorting(2) Quick Sort(퀵 정렬)  (0) 2016.10.27
Sorting(1) Bubble Sort(버블 정렬)  (0) 2016.10.27
Python2 설치  (0) 2016.05.14

WRITTEN BY
SiriusJ

,