简单的双链表前插

[donle1000]

帮别人调的，可惜太高估自己了，DEBUG了半天，楞是没弄出来，好象知道哪里错了但又改不出来

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


typedef struct LNode //三个量 
{ 
	int data; 
	struct LNode *next; 
	struct LNode *prior; 
}LNode,*LinkedList; 

LinkedList LinkedListInit() //链表初始化 
{ 
	LinkedList L; 
	L=(LinkedList)malloc(sizeof(LNode)); 
	L->next=NULL; 
	L->prior=NULL; 
	return L; 
} 

LinkedList LinkedListCreat( ) 
{ 
	LinkedList L,p,s; //p只是一个介质 
	int x=0; 
	L=LinkedListInit(); 
	p=L->next; 
	
	printf("输入要创建的链表，以-1为结束\n"); 
	fflush(stdin); //清空缓冲区 
	scanf("%d",&x); 
	while(x!=-1) 
	{ 
		s=(LinkedList)malloc(sizeof(LNode)); 
		s->data=x; 
		
		s->prior=p->prior; //双链表的插入 
		p->prior->next=s; 
		s->next=p; 
		p->prior=s;
		
		p=p->next; 
		scanf("%d",&x); 
		free(s);
	} 
	p=NULL; 
	return(L); 
} 

void main() 
{ 
	LinkedList L; 
	
	L=LinkedListCreat(); 
}

[猫已经找不回了]

typedef struct LNode //三个量 
{ 
    int data; 
    struct LNode *next; 
    struct LNode *prior; 
}LNode,*LinkedList; 

LinkedList LinkedListInit() //链表初始化 
{ 
    LinkedList L; 
    L=(LinkedList)malloc(sizeof(LNode)); 
    L->next=NULL; 
    L->prior=NULL; 
    return L; 
} 

LinkedList LinkedListCreat( ) 
{ 
    LinkedList L,p,s; //p只是一个介质 
    int x=0; 
    L=LinkedListInit(); 
    p=L;                    //让p承接最后一个真正的节点,不需要介质
    
    printf("输入要创建的链表，以-1为结束\n"); 
    fflush(stdin); //清空缓冲区 
    scanf("%d",&x); 
    while(x!=-1) 
    { 
        s=(LinkedList)malloc(sizeof(LNode)); 
        s->data=x; 
        

        s->prior=p; //双链表的插入 
        p->next=s;     
        p=p->next; 
        scanf("%d",&x); 
        free(s);
    } 
    p=NULL; 
    return(L); 
} 

void main() 
{ 
    LinkedList L; 
    
    L=LinkedListCreat(); 
}

[猫已经找不回了]

帮你改了下,这是我这几天唯一认真看了的关于链表的代码..因为楼主写链表的思路跟我很接近,看着舒服..
说下你的问题,你喜欢用一个没有分配内存的介质p先占据尾节点的next,但是这样导致p->prior无法指向.
而你的LinkedListCreat里插入新节点s都是通过操作p,这样导致了双链表的prior无法接上,从而输入第一个数据后就出错了.

所以建议别用未分配内存的介质接在尾节点后面,让p直接指向尾节点就够了.帮你改了下,帖在3楼.

[donle1000]

[Quote=引用 3 楼 hairetz 的回复:]
C/C++ code
typedef struct LNode //三个量
{
int data;
struct LNode *next;
struct LNode *prior;
}LNode,*LinkedList;

LinkedList LinkedListInit() //链表初始化
{
LinkedList L;
L=(LinkedList)malloc(sizeof(LNode));
L->next=NULL;
L->prior=NULL;
return L;
}

LinkedList LinkedListCreat( )
{
LinkedList L,p,s; //p只是一个介质
int …
[/Quote]

看来万事靠书本是不行的。。。这个插入法。。。不了解

[donle1000]

[Quote=引用 4 楼 hairetz 的回复:]
帮你改了下,这是我这几天唯一认真看了的关于链表的代码..因为楼主写链表的思路跟我很接近,看着舒服..
说下你的问题,你喜欢用一个没有分配内存的介质p先占据尾节点的next,但是这样导致p->prior无法指向.
而你的LinkedListCreat里插入新节点s都是通过操作p,这样导致了双链表的prior无法接上,从而输入第一个数据后就出错了.

所以建议别用未分配内存的介质接在尾节点后面,让p直接指向尾节点就够了.帮你改了下,帖在3楼.
[/Quote]

那个P其实是我在调试的时候加的，贴过来的时候忘记修改了，主要区别还是在于插入算法上。让P指向尾节点，
s->prior=p->prior; P的前驱节点仍然无法判断

[HelloDan]

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


typedef struct LNode //三个量 
{ 
    int data; 
    struct LNode *next; 
    struct LNode *prior; 
}LNode,*LinkedList; 

LinkedList LinkedListInit() //链表初始化 
{ 
    LinkedList L; 
    L=(LinkedList)malloc(sizeof(LNode)); 
    L->next=NULL; 
	L->data=0;    // advise to add this line
    L->prior=NULL; 
    return L; 
} 

LinkedList LinkedListCreat( ) 
{ 
    LinkedList head,p,s; //p只是一个介质 
    int x=0; 
    head=LinkedListInit(); 
    //p=L->next;   // that's to say p==NULL. it's not proper to do so
	p=head;
    
    printf("输入要创建的链表，以-1为结束\n"); 
    fflush(stdin); //清空缓冲区 
    //scanf("%d",&x); 
    while(x!=-1) 
    { 
		scanf("%d",&x);
        s=(LinkedList)malloc(sizeof(LNode)); 
        s->data=x;
        s->next=NULL;		
        
        s->prior=p; //双链表的插入  		
        p->next=s; 
		
        p=s;       
         
        //free(s);
    } 
    p=NULL; 
    return(head); 
} 


int main() 
{ 
    LinkedList L,temp; 
    
    L=LinkedListCreat(); 
	while(L->next!=NULL)
	{
	  printf("%d\n",L->data);
	  temp=L->next;
	  free(L);//  remember to go over the list to free the memory
	  L=temp;
	}
	
	
	return 0;
}

[pengzhixi]

LinkedList LinkedListCreat( ) 
{ 
    LinkedList L,p,s; //p只是一个介质 
    int x=0; 
    L=LinkedListInit(); 
    p=L;                    //让p指向链表最后一个节点
    
    printf("输入要创建的链表，以-1为结束\n"); 
    fflush(stdin); //清空缓冲区 
    scanf("%d",&x); 
    while(x!=-1) 
    { 
        s=(LinkedList)malloc(sizeof(LNode)); 
        s->data=x; 
        

        s->prior=p; //让新节点的前驱指针指向原来链表的最后一个节点 
        p->next=s;  //让最后一个节点的后继指针指向新节点s   
        p=p->next; //让p指向新加的节点。
        scanf("%d",&x); 
        free(s);
    } 
    p=NULL; 
    return(L); 
} 

这个插入法实际上是在链表的最后一个节点插入。

[猫已经找不回了]

汗,楼主你把LinkedListCreat里面那个 free(s);删去,刚才才发现还有这个东西,晕,怎么可能在create的时候就删除.

[猫已经找不回了]

刚发现你要前插的,好做,把create里的prior跟next换一下就好了,帮你改了一下,带前向遍历输出的.

typedef struct LNode //三个量 
{ 
    int data; 
    struct LNode *next; 
    struct LNode *prior; 
}LNode,*LinkedList; 

LinkedList LinkedListInit() //链表初始化 
{ 
    LinkedList L; 
    L=(LinkedList)malloc(sizeof(LNode)); 
	L->data=NULL;
    L->next=NULL; 
    L->prior=NULL; 
    return L; 
} 

LinkedList LinkedListCreat( ) 
{ 
    LinkedList L,p,s; //p只是一个介质 
    int x=0; 
    L=LinkedListInit(); 
    p=L;                    //让p承接最后一个真正的节点,不需要介质
    
    printf("输入要创建的链表，以-1为结束\n"); 
    fflush(stdin); //清空缓冲区 
    scanf("%d",&x); 
    while(x!=-1) 
    { 
        s=(LinkedList)malloc(sizeof(LNode)); 
        s->data=x; 
        

        s->next=p; //双链表的插入
		s->prior=NULL;
        p->prior=s;     
        p=p->prior; 
        scanf("%d",&x); 
    } 
    p=NULL; 
    return(L); 
} 

view_List_prior(LinkedList L )
{
	while(L!=NULL)
	{
		printf("   %d ",L->data);
		L=L->prior;
	}
}

void main() 
{ 
    LinkedList L; 
    
    L=LinkedListCreat(); 
	view_List_prior(L->prior);
}

[pengzhixi]

p=L->next;//L->next为NULL。
LinkedListCreat( )//你这个函数是不是将所有的新节点都插到第一个节点的前面呢?

[Athos_K]

对C的语法不很了解，如不嫌弃，可以用我的实现
#ifndef DNODE
#define DNODE
#include<iostream>
#include<cstdlib>
using namespace std;
template<class T>
class DNode
{
DNode<T> *left;
DNode<T> *right;
public:
T data;
DNode(void){right=this;left=this;}
DNode(const T& item);
void InsertRight(DNode<T> *p);
void InsertLeft(DNode<T> *p);
DNode<T> *DeleteNode();
DNode<T> *NextNodeRight()const{return right;}
DNode<T> *NextNodeLeft()const{return left;}
};
template<class T>
DNode<T>::DNode(const T& item)
{
data=item;
right=this;
left=this;
}
template<class T>
void DNode<T>::InsertRight(DNode<T> *p)
{
p->right=right;
right->left=p;
p->left=this;
right=p;
}
template<class T>
void DNode<T>::InsertLeft(DNode<T> *p)
{
p->left=left;
left->right=p;
p->right=this;
left=p;
}
template<class T>
DNode<T> *DNode<T>::DeleteNode()
{
right->left=left;
left->right=right;
return this;
}
#endif

说明：
1.构建链表的过程就是用InsertRight或者InsertLeft不断地往头结点插入的过程。
2.头结点不能是指针类型！！