单向链表及双向链表

链表

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

typedef int data_t;
typedef struct linknode{
	data_t data;
	struct linknode *next;
}link_t;

link_t *creat_link()
{
	link_t *head;
	head = malloc(sizeof(link_t));
	head->next = NULL;

	return head;
}

int ins_head_link(link_t *head,const data_t *data)
{
	//1.创建空间，保存数据
	//2.保存 后一个元素地址
	//3.头结点里保存新的元素的地址
	
	link_t *newnode;
	newnode = malloc(sizeof(link_t));
	newnode->data = *data;
	newnode->next = head->next;
	head->next = newnode;

	return 0;
}
int ins_index_link(link_t *head,int index,const data_t *data)
{
	//1.定位到要插入位置的前一个结点
	//2.执行插入
#if 0      //if 0，预编译的时候把这一段代码不进行编译，相当于注释掉了，如果是if 1的话则进行编译。
	link_t *p;
	int count;
	p = head;
	count = 0;
	while(NULL != p->next){
		count ++;
		p = p->next;
	}

	if(index < 0 || index > count)
		return -1;
#endif

	if(index < 0)
		return -2;

	while(index --){
		head = head->next;
		if(NULL == head)
			return -1;
	}

	ins_head_link(head,data);

	return 0;
}
int del_head_link(link_t *head)
{
	link_t *temp;
	if(NULL == head->next)
		return -1;

	temp = head->next;
	head->next = temp->next;
	free(temp);

	return 0;
}

int del_index_link(link_t *head,int index)
{
	//1.定位 
	//2.删除
	
	if(NULL == head->next)
		return -1;

	while(index --){
		head = head->next;
		if(NULL == head->next)
			return -1;
	}
	del_head_link(head);
	
	return 0;
}

int change_index_link(link_t *head,int index,const data_t *newdata)
{
	//1.定位 
	//2.改
	
	if(NULL == head->next)
		return -1;

	while(index --){
		head = head->next;
		if(NULL == head->next)
			return -1;
	}
	
	head->next->data = *newdata;

	return 0;
}
/*返回找到的元素的前一个结点的地址*/
link_t *locate_link(link_t *head,const data_t *data)
{
	while(NULL != head->next){
		if(*data == head->next->data)
			return head;
		head = head->next;
	}

	return NULL;
}

int is_empty_link(link_t *head)
{
	return NULL == head->next;//如果相等则返回1，否则返回0
}

int clean_link(link_t *head)
{
#if 0
	while(!is_empty_link(head)){
		del_head_link(head);
	}
#else
	
	while(0 == del_head_link(head));

#endif
	return ;
}

int del_locate_link(link_t *head,const data_t *data)
{
	head = locate_link(head,data);
	
	if(NULL != head){
		del_head_link(head);
		return 0;
	}

	return -1;
}


int dis_link(link_t *head)
{
	clean_link(head);
	free(head);
	return 0;
}


void print_link(link_t *head)
{
	link_t *p;
	p = head;
	while(NULL != p->next){
		p = p->next;
		printf("%d ",p->data);
	}
	printf("\n");
	return ;
}




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

	link_t *p;
	link_t *node;
	int i;

	p = creat_link();
	del_index_link(p,1);
	for(i = 20;i >= 10;i --){
		ins_head_link(p,&i);
	}

	print_link(p);

	i = 250;
	ins_index_link(p,10,&i);

	print_link(p);
	del_index_link(p,13);
	print_link(p);
	
	i = 251;
	change_index_link(p,10,&i);
	print_link(p);

	i =13;
	node = locate_link(p,&i);
	printf("find:%d\n",node->next->data);
	del_head_link(node);
	print_link(p);

	clean_link(p);
	print_link(p);

	return 0;
}

双向链表

#include <stdio.h>
#include <stdlib.h>              //双向链表

typedef int data_t;
typedef struct dblink{
	data_t data;
	struct dblink *front;
	struct dblink *next;
}dblink_t;

dblink_t *creat_dblink()
{
	dblink_t *head;
	dblink_t *tail;

	head = malloc(sizeof(dblink_t));
	tail = malloc(sizeof(dblink_t));
	
	head->next = tail;
	head->front = NULL;

	tail->next = NULL;
	tail->front = head;

	return head;
}


int ins_head_dblink(dblink_t *head,const data_t *data) 
{
	dblink_t *newnode;
	newnode = malloc(sizeof(dblink_t));

	newnode->data = *data;

	newnode->next = head->next;               //连接关系有四个，用newnode和head表示
	newnode->front = head;

	head->next->front = newnode; // newnode->next->front = newnode;
	head->next = newnode;        // newnode->front->next = newnode;

	return 0;
}

int del_head_dblink(dblink_t *head)
{
	dblink_t *temp;

	if(NULL == head->next->next)
		return -1;

	temp = head->next;

	temp->next->front = head;//head->next->next->front = head;      //连接关系有两个，用head和temp表示
	head->next = temp->next; //head->next = head->next->next;

	free(temp);
	return 0;
}

void print_dblink(dblink_t *head)
{
	dblink_t *tail;
	while(NULL != head->next->next){
		head = head->next;
		printf("%d ",head->data);
	}
	printf("\n");

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

	return ;
}



int main(int argc, const char *argv[])
{
	dblink_t *head;
	int i;

	head = creat_dblink();
	for(i = 10;i >= 0;i --){
		ins_head_dblink(head,&i);
	}

	print_dblink(head);

	return 0;
}

双向循环链表

#include <stdio.h>
#include <stdlib.h>               //双向循环链表，和双向链表的差别在于定义不同，创建不同，打印不同

typedef int data_t;
typedef struct dblink{
	data_t data;
	struct dblink *front;
	struct dblink *next;
}dblink_t;

dblink_t *creat_dblink()
{
	dblink_t *head;
	dblink_t *tail;

	head = malloc(sizeof(dblink_t));
	
	head->next = head;
	head->front = head;

	return head;
}


int ins_head_dblink(dblink_t *head,const data_t *data)
{
	dblink_t *newnode;
	newnode = malloc(sizeof(dblink_t));

	newnode->data = *data;

	newnode->next = head->next;
	newnode->front = head;

	head->next->front = newnode; // newnode->next->front = newnode;
	head->next = newnode;        // newnode->front->next = newnode;

	return 0;
}

int del_head_dblink(dblink_t *head)
{
	dblink_t *temp;
	
	if(head == head->next)
		return -1;

	temp = head->next;

	temp->next->front = head;//head->next->next->front = head;
	head->next = temp->next; //head->next = head->next->next;

	free(temp);
	return 0;
}

void print_dblink(dblink_t *head)
{
	dblink_t *p = head;
	dblink_t *tail;
	while(p != head->next){
		head = head->next;
		printf("%d ",head->data);
	}
	printf("\n");

	tail = head->next;
	while(p != tail->front){
		tail = tail->front;
		printf("%d ",tail->data);
	}
	printf("\n");

	return ;
}

int main(int argc, const char *argv[])
{
	dblink_t *head;
	int i;

	head = creat_dblink();
	for(i = 10;i >= 0;i --){
		ins_head_dblink(head,&i);
	}
	print_dblink(head);
	return 0;
}

约瑟夫环

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

typedef int data_t;
typedef struct linknode{
	data_t data;
	struct linknode *next;
}link_t;


link_t *creat_one()
{
	link_t *p;
	p = malloc(sizeof(link_t));
	p->next = p;

	p->data = 1;

	return p;
}

int ins_head_link(link_t *p,int num)
{
	link_t *newnode;
	newnode = malloc(sizeof(link_t));
	newnode->data = num;
	newnode->next = p->next;

	p->next = newnode;

	return 0;
}
link_t *init_jos()
{
	int i;
	link_t *p;
	//1.创建一个单结点环 
	p = creat_one();
	
	//2.插入剩余的结点
	for(i = 10;i >= 2;i --){
		ins_head_link(p,i);
	}

	return p;
}

int del_head_link(link_t *head)
{
	if(head == head->next)
		return -1;
	link_t *temp;
	temp = head->next;
	head->next = temp->next;

	printf("%d\n",temp->data);
	free(temp);

	return 0;
}

link_t *jos_once(link_t *p)
{
	int i = 3 - 2;
	while(i --){
		p = p->next;
	}
	del_head_link(p);

	return p->next;
}

link_t *jos(link_t *p)
{
	//重复执行删除到剩下两个为止
	

	while(p != p->next->next){
		p = jos_once(p);
	}
	
	return p;
}

void print_clink(link_t *p)
{
	link_t *temp = p;

	do{
		printf("%d ",p->data);
		p = p->next;
	}while(p != temp);
	
	printf("\n");

	return ;
}

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

	link_t *p;
	//1.创建一个环
	p = init_jos();

	print_clink(p);

	//2.执行删除
	p = jos(p);
	//3.打印
	
	print_clink(p);


	return 0;
}