Kugi's Blog

#include <stdio.h>
#include <math.h>

// 테스트함수01, y = x^3 - 5x^2 + 2x + 1
double function01(double x)
{
	return (x*x*x - 5*x*x + 2*x + 1);
}

// 함수 func에 대해 구간 a에서 b까지 n개의 사다리꼴로 나누어 면적을 구한다.
// n이 커질수록 정확도가 증가한다.
double integral_trapezoidal(double (*func)(double), double a, double b, int n)
{
	int i;
	double result, top_edge, bot_edge;
	double height = (b-a) / n;
	double height_half = height / 2;

	top_edge = func(a);
	bot_edge = func(a+height);
	result = (top_edge+bot_edge) * height_half;

	for ( i=2; i<=n; i++ )
	{
		top_edge = bot_edge;
		bot_edge = func( a + i*height );
		result += (top_edge+bot_edge) * height_half;
	}

	return result;
}

int main()
{
	double a, b;
	int n;

	printf("입력[a, b, n]: ");
	scanf("%lf %lf %d", &a, &b, &n);

	printf("구간 [%.2lf, %.2lf] n=%d\n\ 적분결과: %.6lf\n",
		   a, b, n, integral_trapezoidal(function01, a, b, n));

	return 0;
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

#define LIST_SIZE_MAX	1000
#define RAND_MAX		1000

typedef struct LinkedListNode
{
	int data;
	struct LinkedListNode* prev;
	struct LinkedListNode* next;
} ListNode;

typedef struct LinkedListHeader
{
	int size;
	ListNode* head;
	ListNode* tail;
} ListHeader;

int initListHeader(ListHeader* header)
{
	if ( header == NULL )
	{
		return -1;
	}

	header->head = NULL;
	header->tail = NULL;
	header->size = 0;

	return 0;
}

int insertNode(ListHeader* header, int data, int _index)
{
	ListNode* curNode = NULL;
	ListNode* newNode = NULL;
	int i;

	if ( header == NULL )
	{
		printf("\n ** NULL pointer error : header in insertNode()\n");
		return -1;
	}

	if ( _index > header->size || _index < 0 )
	{
		printf("\n ** Wrong node number : nodeNumber in insertNode(): %d\n", _index);
		return -1;
	}

	newNode = (ListNode*)malloc(sizeof(ListNode));
	newNode->data = data;
	if ( newNode == NULL )
	{
		printf("\n ** NULL pointer error : newNode in insertNode()\n");
		return -1;
	}

	if ( header->head == NULL )
	{
		header->head = newNode;
		newNode->prev = NULL;
		newNode->next = NULL;
		header->tail = header->head;
	}
	else
	{
		curNode = header->head;
		for ( i=1; i<_index; i++ )
		{
			if ( curNode == NULL )
			{
				printf("\n ** NULL pointer error : curNode in insertNode(), i=%d\n", i);
				return -1;
			}
			curNode = curNode->next;
		}

		if ( curNode->next == NULL )
		{
			newNode->next = NULL;
			newNode->prev = curNode;
			header->tail = newNode;
		}
		else
		{
			newNode->next = curNode->next;
			newNode->prev = curNode;
		}
		curNode->next = newNode;
	}
	
	header->size++;
}

int pushBack(ListHeader* header, int data)
{
	ListNode* node = (ListNode*)malloc(sizeof(ListNode));

	if ( header == NULL )
	{
		printf("\n ** NULL pointer error : header in pushBack()\n");
		return -1;
	}

	if ( node == NULL )
	{
		printf("\n ** NULL pointer error : node in pushBack()\n");
		return -1;
	}

	(*node).data = data;
	(*node).next = NULL;

	if ( header->tail == NULL )
	{
		(*node).prev = NULL;
		header->head = node;
		header->tail = header->head;
	}
	else
	{
		(*node).prev = header->tail;
		header->tail->next = node;
		header->tail = header->tail->next;
	}
	header->size++;

	return header->size;
}

int popBack(ListHeader* header)
{
	if ( header == NULL )
	{
		printf("\n ** NULL pointer error : header in popBack()\n");
		return -1;
	}

	if ( header->tail != NULL && header->size > 1 )
	{
		ListNode* tempnode = header->tail;
		header->tail->prev->next = NULL;
		header->tail = header->tail->prev;
		free(tempnode);
		header->size--;
	}
	else if ( header->head != NULL && header->size == 1 )
	{
		free(header->head);
		header->head = NULL;
		header->tail = NULL;
		header->size--;
	}

	return header->size;
}

int clearList(ListHeader* header)
{
	if ( header == NULL )
	{
		printf("\n ** NULL pointer error : header in clearList()\n");
		return -1;
	}

	while ( header->size > 0 && header->head != NULL )
	{
		if ( popBack(header) == -1 )
		{
			return -1;	
		}
	}

	return header->size;
}

void insertNodeRand(ListHeader* header, int index)
{
	insertNode(header, rand()%RAND_MAX+1, index);
}

void pushBackRand(ListHeader* header)
{
	pushBack(header, rand()%RAND_MAX+1);
}

void printLinkedList(ListHeader* header)
{
	ListNode* node;

	if ( header == NULL )
	{
		printf("\n ** NULL pointer error : header in printLinkedList()\n");
		return;
	}

	node = header->head;
	while ( node != NULL )
	{
		printf("%d ", node->data);
		node = node->next;
	}
	printf("\n");
}

int main()
{
	int i;
	ListHeader header;

	srand(time(NULL));	// rand()를 사용하기 위한 초기화

	initListHeader(&header);

	// examples...
	for ( i=0; i<10; i++ )
	{
		pushBackRand(&header);
		printLinkedList(&header);
	}

	for ( i=0; i<10; i++ )
	{
		popBack(&header);
		printLinkedList(&header);
	}

	for ( i=0; i<10; i++ )
	{
		insertNodeRand(&header, i);
		printLinkedList(&header);
	}

	clearList(&header);
	printLinkedList(&header);

	return 0;
}