记录一些认为不错的数据结构程序算法

逆转链表：

#include<stdio.h>
#include<stdlib.h>
typedef struct nod
{
	int data;
	struct nod* next;
}nod;

typedef struct list
{
	nod* top;
	nod* last;
	int cnt;
}list;

list* create()
{
	list* p = (list*)malloc(sizeof(list));
	p->top = NULL;
	p->last = NULL;
	p->cnt = 0;
	return p;
}
nod* createnod(int data)
{
	nod* p = (nod*)malloc(sizeof(nod));
	p->data = data;
	p->next = NULL;
	return p;
}
int full(list* ps)
{
	return 0;
}
int empty(list* ps)
{
	return ps->cnt == 0;
}
void pushead(list* ps, int data)
{
	if (full(ps) == 0)
	{
		nod* p = createnod(data);
		if (ps->top == NULL)
		{
			ps->top = p;
			ps->last = p;
		}
		else
		{
			p->next = ps->top;
			ps->top = p;

		}
		ps->cnt++;
	}
}

void travel(list* ps)
{
	nod* p = ps->top;
	printf("目前元素有：");
	int i;
	for (i = 0; i<ps->cnt; i++)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	p = NULL;
}
void reversenod(nod* p)  //先将p指到倒数第二个节点位置，主要利用递归，可以将指针p一直向上移动
{
	if (p->next != NULL)
	{
		reversenod(p->next);//递归！
		p->next->next = p;
		p->next = NULL;  //主要为了在头结点的时候使用
	}
}
void reverse(list* ps)
{
	nod* p = ps->top;
	reversenod(p);
	ps->top = ps->last; //将链表的头结点，尾节点位置重新分配好
	ps->last = p;
}
void main()
{
	int i;
	list* ps = create(); //创建一个空链表
	for (i = 0; i<5; i++)
		pushead(ps, i); //在链表中放五个节点
	travel(ps); //遍历链表中所有元素 打印出来
	reverse(ps);//逆转链表 重点
	travel(ps);

}

本人在写reverse（）程序时的代码：

    多用了一个loc（）函数，确定每一个节点的位置；利用for（）将p指向倒数第二个节点，程序不简短。

nod* loc(list* ps,int loc)
{
	nod* p=ps->top;
	int i;
	if(loc==0)
		p=NULL;
	else
	{
		for(i=0;i<loc-1;i++)
		{
		p=p->next;
		}
	
	}
	return p;
}
reverse(list* ps)
{
	int i;
	nod* p=ps->last;
	for(i=0;i<ps->cnt;i++)
	{
	p->next=loc(ps,4-i);
	p=p->next;
	}
	ps->top=p;
	p=NULL;
}