singular linked list

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


typedef struct	s_node
{
	int		data;
	struct s_node* next;
}		t_node;

int list_size(t_node* begin)
{
	t_node* head;
	int cnt;

	head = begin;
	cnt = 0;
	while (head) // head != NULL
	{
		head = head->next;
		cnt++;
	}
	return cnt;
}

t_node* create_elem(int data)
{
	t_node* node;
	node = (t_node*)malloc(sizeof(t_node));
	if (node == 0)
		return 0;
	node->data = data;
	node->next = 0;
	return node;
}
int list_add1(t_node** begin, int num)
{
	t_node* temp;
	t_node* curr;
	int i;

	if (begin == 0 || (temp = create_elem(num)) == 0)
		return -1;
	if (*begin == 0)
	{
		*begin = temp;
		return (0);
	}
	i = 1;
	curr = *begin;
	while (curr->next)
	{
		curr = curr->next;
		i++;
	}
	curr->next = temp;
	return (i);

}
/*
t_node* list_get(t_node* begin_list, int n)
{
	int i;
	t_node* curr;

	if (n < 0)
		return 0;
	if (n >= list_size(begin_list))
		return 0;
	i = 0;
	curr = begin_list;
	while (i != n)
	{
		curr = curr->next;
		i++;
	}
	return curr;
}*/
t_node* list_get(t_node* begin_list, int n)
{
	int i;
	t_node* curr;

	i = 0;
	curr = begin_list;
	while (curr && i < n)
	{
		curr = curr->next;
		i++;
	}
	if (i != n)
		return (0);
	return (curr);
}

int list_find(t_node* begin_list, int data)
{
	t_node* curr;
	int i;

	if (begin_list == 0) // important!!! 
		return -1;
	i = 0;
	curr = begin_list;
	while (curr)
	{
		if (curr->data == data)
			return (i);
		curr = curr->next;
		i++;
	}
	return (-1);
}

int list_remove(t_node** begin_list, int n)
{
	t_node* prev;
	t_node* curr;
	int i;

	if (begin_list == 0 || *begin_list == 0  || n < 0)
		return (0);
	if (n == 0)
	{
		curr = *begin_list;
		*begin_list = curr->next;
		free(curr);
		return (1);
	}
	prev = *begin_list;
	curr = (*begin_list)->next;
	i = 1;
	while (curr && i < n)
	{
		prev = curr; // 순서거꾸로 했다가 에러남 ㅋㅋㅋ
		curr = curr->next;
		i++;
	}
	if (i != n || curr == 0)
		return (-1);
	prev->next = curr->next;
	free(curr);
	return (1);
}

int list_add(t_node** begin_list, int data, int n)
{
	t_node* curr;
	t_node* new_node;
	int i;

	if (begin_list == 0 || (new_node = create_elem(data)) == 0)
		return (-1);
	if (*begin_list == 0 || n <= 0)
	{
		new_node->next = *begin_list;
		*begin_list = new_node;
		return (0);
	}
	i = 0;
	curr = *begin_list;
	while (curr->next && i < n - 1)
	{
		curr = curr->next;
		i++;
	}
	new_node->next = curr->next;
	curr->next = new_node;
	return (++i);
}
int main(void)
{

	t_node* begin_list = 0;
	printf("size = %d\n", list_size(begin_list));
	list_add1(&begin_list, 0);
	printf("size = %d\n", list_size(begin_list));
	list_add1(&begin_list, 1);
	printf("size = %d\n", list_size(begin_list));
	list_add1(&begin_list, 2);
	printf("size = %d\n", list_size(begin_list));
	list_add1(&begin_list, 3);
	printf("size = %d\n", list_size(begin_list));
	t_node* curr = begin_list;
	for (; curr; curr = curr->next)
	{
		printf("%d\n", curr->data);
	}

	for (int i = -2; i < 5; i++)
	{
		printf("%p\n", list_get(begin_list, i));
	}

	for (int i = -2; i < 6; i++)
	{
		printf("find = %d\n", list_find(begin_list, i));
	}
	
	printf("remove = %d\n", list_remove(&begin_list, 3));
	curr = begin_list;
	for (; curr; curr = curr->next)
	{
		printf("%d\n", curr->data);
	}

	printf("add -> %d\n", list_add(&begin_list, 10, 5));
	curr = begin_list;
	for (; curr; curr = curr->next)
	{
		printf("%d\n", curr->data);
	}
	/**/

	return (0);
}

exercise 00

• allowed functions : malloc, free

• 아래와 같은 list.h를 사용 합니다.

  typedef struct s_node { int data; struct s_node *next; } t_node;

create_elem

• t_node형 새로운 요소를 생성하는 함수를 작성하세요.

  t_node *create_elem(int data);

list_add1

• t_node형 새로운 요소를 목록의 맨 뒤에 추가하는 함수를 작성하세요.

• 성공 시 인덱스 번호를 반환 합니다.(0부터 시작)

• 실패 시 음수를 반환 합니다.

  int list_add1(t_node **begin_list, int data);

list_size

• 목록에 있는 요소의 개수를 반환하는 함수를 작성하세요.

  int list_size(t_node *begin_list);

list_get

• 목록에서 n번 인덱스의 요소를 반환하는 함수를 작성하세요.

• 목록에 있는 요소의 수가 더 적을 땐, 널포인터를 반환 합니다.

  t_node *list_get(t_node *begin_list, int n);

list_find

• 목록에서 data의 값이 같은 요소의 인덱스를 반환하는 함수를 작성하세요.

• 없을 경우엔 음수를 반환 합니다.

  int list_find(t_node *begin_list, int data);

list_remove

• 목록에서 n번 인덱스의 요소를 삭제하는 함수를 작성하세요.

• 삭제에 성공 했을 때는 1, 실패 했을 때는 0을 반환 합니다.

  int list_remove(t_node **begin_list, int n);

list_add

• 목록의 n번 인덱스에 data를 갖는 새로운 요소를 생성하는 함수를 작성하세요.

• n이 목록의 요소의 수보다 클 경우엔 마지막 위치에 생성하세요.

• 생성된 요소의 인덱스를 반환 합니다.

  int list_add(t_node **begin_list, int data, int n);

github.com/365kim/algorithm_study

365kim/algorithm_study