线性表-双向链表的简单知识

前面先贴出我之前才学双向链表写的总结，也许更贴近我才接触的感受，虽然也没过去多久。贴出的代码则是我重新写的和之前写的还是有点不一样(写的要稍微好一点点点)，前面这就作为代码思想的注释吧，而且我只列出当时重点怎么理解的部分。

不过还是先贴出结构体：

typedef struct Node {

         int data;

         structNode *prior;//前驱

         structNode *next;//后继

}Node, *pNode;

 

the past:

双向链表对比与单向链表，具有前驱和后继，双向链表还是蛮有趣的，因为他从前往后和从后往前都可以知道链表的值，我也看了很久。从头开始学习算法真心不容易，请允许我这个渣慢慢进步啊。

pNode Init() {

         pNodeL = (pNode )malloc(sizeof(Node));

         if(!L) {

                   printf("failed\n");

                   exit(-1);

         }

 

         L->next  = L->prior = NULL;//初始化头结点的前驱后继都为空

//好像得有返回量  我用void型就写出问题 唉。。。

         returnL ;

}

//头插法

//头插法在于头永远都在那里不会变 相对来说操作很死板

void PreInsert(pNode L,int item) {

         pNodep = L;

         pNodepNew = (pNode)malloc(sizeof(Node));

         pNew->data= item;

         pNew->prior= p;

         pNew->next= p->next;

         p->next= pNew;     

 

         return;

        

}

 

//尾插法

//我想了好久也是醉了

/*

尾插法在于每次都在最后一个节点后面插入，所以关键是怎么处理怎么设置出tail这个节点

         我原先的写法：

         voidTailInsert(pNode L, int item) {

                   pNodetail = L;

                   pNodepNew = (pNode)malloc(sizeof(Node));

                   pNew->data= item;

                   tail->next= pNew;

                   pNew->prior= tail;

                   pNew->next= NULL;

                   tail= pNew;

         }

         main函数里这样

         pNodeL;

         L= Init();

         printf("\n尾插法:\n");

         TailInsert(tail,8);

         TailInsert(tail,9);

         TailInsert(tail,1);

         TailInsert(tail,2);

         Traverse(L);//结果就一个数据

我的想法是每次在tail节点后插入一个新节点，然后在把最后这个新节点变成tail节点，这样不就行了么。

这段代码错误就在于pNode tail = L;这一句导致的结果就是每次执行插入函数，又特么的从开始的尾插入，

也就是永远只能插入一个数据（执行遍历就一个值）。

所以我就在想怎么让这个tail随着链表长度变化他一直在链表的最后位置。

想啊想，真特么的烦啊

本来我还想设个全局变量，把pNode L作为全局变量在放入函数里不就不会每次都变了，但那不就整个程序就变味了么唉。。

后来我就试着把pNode tail = L 去掉，然后在main函数里这样写

         pNodeL;

         L= Init();

         pNodetail = L;

         printf("\n尾插法:\n");

         TailInsert(tail,8);

         TailInsert(tail,9);

         TailInsert(tail,1);

         TailInsert(tail,2);

         Traverse(L);

 

  这样写pNode L;

         L= Init();

         pNodetail = L;就能让tail一直成为尾巴了，而原本的头一直没变

  然后测试还特么的一个数据

  想啊想

  最后想到（不是凭技术想出来的）我最近写链表时遇到的，就是传引用到函数里，就是TailInsert(pNode &tail, int item)酱紫

  我想了想，自我理解是因为tail直接传进去无法传回来，只能传引用才会变，只能酱紫

  理解了

  怎么说总算搞出来了

 2015/1/12/17:19

*/

void TailInsert(pNode &tail, int item){

 

         pNodepNew = (pNode)malloc(sizeof(Node));

         pNew->data= item;

         tail->next= pNew;

         pNew->prior= tail;

         pNew->next= NULL;

 

         tail= pNew;

}

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

typedef int datatype;

typedef struct Node {
	datatype data;
	struct Node *prior;//前驱
	struct Node *next;//后继
}Node, *pNode;
//===============================
void Init(pNode &L);//初始化
void PreInsert(pNode &L, datatype item);//前插法
void TailInsert(pNode &L, datatype item);//尾插法
void DeleteNode(pNode &L, datatype &item);//删除节点
void DelteList(pNode &L);//删除链表
void Traverse(pNode L);//遍历
//==================================================
//初始化

void Init(pNode  &L) {
	L = (pNode)malloc(sizeof(Node));
	if(!L)
		exit(-1);
	L->next = L->prior = NULL ;//前驱后继均为空
	return ;
}
//====================================================
//遍历
void Traverse(pNode L) {
	pNode p = L->next ;
	while(p) {
		printf("%d ",p->data );
		p = p->next ;
	}
	return ;
}
//======================================================
//====================================================
//只想看看前驱有没有实现
void TraversePrior(pNode L) {
	pNode p = L;
	if(!L->next) {
		return;
	}
	while(p->next ) {
		p = p->next ;//先遍历到最后
	}
	while(p != L) {//再从最后遍历到最前 真特么的矫情
		printf("[%d] ",p->data );
		p = p->prior ;
	}
	return ;
}
//======================================================
//前插法
/*	   pNew
	   /
	L------L->next

*/ 
void PreInsert(pNode &L, datatype item) {
	pNode pNew = (pNode )malloc(sizeof(Node));
	if(!pNew)
		exit(-1);
	pNew->data = item;
/*插入一个新节点 无非给pNew弄个前驱后继，或者说L的后继变了，
	L->next的前驱变了
	*/
	pNew->next = L->next;
	L->next = pNew;
	pNew->prior = L;

	return;
}
//===========================================================
//尾插法
void TailInsert(pNode &tail, datatype item) {
	pNode pNew = (pNode )malloc(sizeof(Node ));
	if(!pNew )
		exit(-1);
	pNew->data = item;

	
	tail->next = pNew;
	pNew->prior = tail;
	pNew->next = NULL ;
	
	tail = pNew;

	return;	
}
//==========================================================
//从头开始删
void DeleteNode(pNode &L, datatype &item) {
	pNode temp =L->next ;
	item = temp->data;//删除的节点的值
	temp->next->prior = temp->prior ;//节点删除了，那么她的后继需要一个前驱

	temp->prior->next  = temp->next ;//她的前驱需要一个后继


	free(temp);//释放
	temp = NULL ;
	return;

}
//===========================================================
//删除链表
void DeleteList(pNode &L) {
	if(NULL == L) {
		return;
	}
	
	pNode p = L->next;
	while(p) {
		pNode q = p;
	//	printf("[%d] ",p->data);
		p = p->next;
		free(q);
		q = NULL;
	}
	/*
	if(p)
		printf("haha");
	else 
		printf("hehe");
	
	if(L->next )
		printf("111111");
	else 
		printf("222222");
这中间部分就是说明p被释放了，但是L->next还是存在的，所以下面那句就是必需
的了。至于为什么L->next还是真我也不是很理解
	
	*/
	L->next = NULL;
	//free(L);
	//L = NULL;算了还是保留头结点吧 看你理解的意思了
	
	return;
}


//=========================================================
int main() {
	pNode p;
	Init(p);
	Traverse(p);
//	PreInsert(p,1);
//	PreInsert(p,2);
//	PreInsert(p,3);
//	PreInsert(p,4);
//	Traverse(p);
	pNode tail = p;
	TailInsert(tail,1);
	TailInsert(tail,2);
	TailInsert(tail,3);
	TailInsert(tail,4);//tail永远是尾巴 唉 。。。
	Traverse(p);
	printf("\n");
	printf("遍历前驱：\n");
	TraversePrior(p);
	printf("\n");
	int item;
	printf("删除节点：\n");
	DeleteNode(p,item);
	printf("删除的是%d \n",item);
	Traverse(p);
	printf("\n");
	printf("清空链表：\n");
	DeleteList(p);

	Traverse(p);
	printf("\n");

	free(p);
	return 0;
}