c语言 编程 ，链表 改错

Question

void
SwapWithNext( Position P, List L )
{
Position BeforeP, AfterP;
BeforeP = P->Prev;
AfterP = P->Next;
P->Next = AfterP->Next;
BeforeP->Next = AfterP;
AfterP->Next = P;
P->Next->Prev = P;
P->Prev = AfterP;
AfterP->Prev = BeforeP;

我是按照上面给的 提示 写了下面的 链表交换的 程序
实行的时候 ，编译器出现错误 ，不知道怎么回事 ，请高手 指点

void swapNodes(DoubleNode * previousNode)
{
DoubleNode * p;
DoubleNode * afterp;

if (previousNode == NULL)
{
printf("Error in insertElement\n");
return;
}

previousNode = p->prev;
afterp = p->next;

p->next = afterp->next;
previousNode->next = afterp;
afterp->next = p;
p->next->prev = p;
p->prev = afterp;
afterp->prev = previousNode;
}

Answer 1

给你一个我写的完整实例 , 你自己分析吧 ,希望对你有帮助.
#include <stdio.h>
#include <string.h>
#define null 0
typedef struct node{
char *data;//结点的数据域，为一个字符串
struct node *next;//结点的指针域
}linkstrnode;//定义单链表结点结构
typedef linkstrnode *linkstring;

main(){//建立数据域为字符串类型，且结点无重复的单链表。对单链表做删除结点操作

linkstring head;
char *t;

printf("\nplease input the node of the linklist:");
printf("\nnodes data is strings,and end of #\n");
creatlinkstr(&head);//建立单链表
printf("\nthe source linklist is :\n");
printing(head);//输出单链表
printf("\nplease input search string:");
gets(t);//输入要删除的字符串
deletet(&head,t);//在单链表head中找到并删除值与t相同的结点
printf("\nthe final linklist is:\n");
printing(head);//输出做了删除操作后的单链表
}

creatlinkstr(linkstring head){
//建立单链表
char *t;
linkstrnode *p;
head=(linkstrnode *)malloc(sizeof(linkstrnode));
//建立一个只含头结点的空链表，头指针为head
head->next=null;
printf("\nplease input the node data(string),end of #");
gets(t);//输入一个字符串t
while (strcmp(t,"#")!=0){//当t的值不为“#”时，做以下操作
p=head;//在建好的单链表中，以p为扫描指针，从头开始查找有无数据域与t相同的结点
while ((p->next)&&(strcmp(t,p->next->data)))
p=p->next;
if (p->next)//如果存在数据域与t相同的结点，则输出存在信息
printf("\nstring %s existed",t);
else{//若不存在数据域与t相同结点，则做以下操作
p->next=(linkstrnode *)malloc(sizeof(linkstrnode));
//在单链表表尾申请一个新结点
p=p->next;//p指针指向新的表尾结点
strcpy(p->data,t);//将t的值复制到*p结点的数据域中
p->next=null;//将单链表的表尾结点的next指针置为空
}
printf("\nplease input the node data(string),end of #");
gets(t);//输入下一个字符串
}//end of while
}//end of creatlinkstr

printing(linkstring head){
//输出head单链表
linkstrnode *p;
p=head->next;
while(p){
puts(p->data);//输出结点的数据——字符串
p=p->next;
}
}//end of printing

deletet(linkstring head,char *t){
//若head单链表中有数据为t的结点，删除之
linkstrnode *p,*s;
p=head;
while ((p->next)&&(strcmp(p->next->data,t)))
//以p为扫描指针对head链表进行查找数据域值为*t结点，
//为了能方便删除操作，p指向待查结点的前趋
p=p->next;
if (p->next){//若查找到有，则做删除操作
s=p->next;
p->next=s->next;
free(s);
printf("\ndelete successful!");
}
else//若head链表中没有数据域的值为*t的结点，则输出删除失败的信息
printf("\ndelete failure!");
}

//-----------------ListNode.h-----------------------

#ifndef LISTNODE_H
#define LISTNODE_H

#include <iostream>
using namespace std;

template <class Type> class List;

template <class Type>
class ListNode
{
friend class List<Type>;
private:
Type data;
ListNode<Type>* link;
public:
ListNode ();
ListNode (const Type& item);

};

#endif

template <class Type>
ListNode<Type>::ListNode() : link(NULL)
{}

template <class Type>
ListNode<Type>::ListNode(const Type &item) : data(item), link(NULL)
{}

//---------------------List.h------------------------

#ifndef LIST_H
#define LIST_H

#include "ListNode.h"

template <class Type>
class List
{
private:
ListNode<Type> *first;
ListNode<Type> *last;
public:
List(const Type &value = NULL);
~List();
void MakeEmpty();
int Length() const;
ListNode<Type> *Find(Type value);
ListNode<Type> *Find(int index);
bool Insert(Type value, int index);
bool Remove(int index);
Type Get(int index);
};

#endif

// 构造函数
template <class Type>
List<Type>::List(const Type &value)
{
first = last = new ListNode<Type>(value);
}

// 析构函数
template <class Type>
List<Type>::~List()
{
MakeEmpty();
delete first;
}

// 链表清空
template <class Type>
void List<Type>::MakeEmpty()
{
ListNode<Type> *p;

while (first->link != NULL)
{
p = first->link;
first->link = p->link;

delete p;
}

last = first;
}

// 计算链表长度
template <class Type>
int List<Type>::Length() const
{
ListNode<Type> *p = first->link;
int count = 0;

while (p != NULL)
{
p = p->link;
count++;
}

return count;
}

// 按链表中所存储的信息查找
template <class Type>
ListNode<Type> * List<Type>::Find(Type value)
{
ListNode<Type> *p = first->link;

while (p != NULL && p->data != value)
{
p = p->link;
}

return p;
}

// 按下标查找
template <class Type>
ListNode<Type> * List<Type>::Find(int index)
{
if (index < -1)
return NULL;
if (index == -1)
return first;
ListNode<Type> *p = first->link;
int i = 0;

while (p != NULL && i < index)
{
p = p->link;
i++;
}

return p;
}

// 在指定
template <class Type>
bool List<Type>::Insert(Type value, int index)
{
ListNode<Type> *p = Find(index - 1);

if (p == NULL)
{
return false;
}
ListNode<Type> *newnode = new ListNode<Type>(value);
newnode->link = p->link;

if (p->link == NULL)
last = newnode;
p->link = newnode;

return true;
}

// 从链表中删除一个元素，删除index后边的节点
template <class Type>
bool List<Type>::Remove(int index)
{
ListNode<Type> *p = Find(index-1);
ListNode<Type> *q;

// 如果p为空，或者p的下一个节点为空，没有办法删除
if (p == NULL || p->link == NULL)
return false;
q = p;
p = p->link;
q->link = p->link;

delete p;
if (q->link == NULL)
last = q;

return true;
}

// 得到指定位置的节点data信息
template <class Type>
Type List<Type>::Get(int index)
{
ListNode<Type> *p = Find(index);

if (p == NULL || p == first)
return NULL;
else
return p->data;
}

头文件：LinkList.h

typedef struct LNode {
int data;
struct LNode *next;
}LNode, *pLinkList;

class LinkList {
private:
pLinkList m_pList;
int m_listLength;
public:
LinkList();
~LinkList();
bool InitList ();
bool DestroyList ();
bool ClearList();
bool IsEmpty ();
int GetLength ();
bool GetNode(int position, LNode** node);
int LocateElem(int elem);
bool SetNodeData(int position, int newData);
bool GetNodeData(int position, int &data);
bool InsertNode(int beforeWhich, int data);
bool DeleteNode(int position);
};

Cpp文件：LinkList.cpp

#include <iostream.h>
#include "LinkList.h"

LinkList::LinkList() {
m_pList = NULL;
m_listLength = 0;

InitList();
}

LinkList::~LinkList() {
if (!DestroyList()) {
DestroyList();
}
}

//初始化，分配一个头节点。
bool LinkList::InitList() {
if (!(m_pList = new LNode)) {
return false;
}
m_pList->next = NULL;

return true;
}

//销毁链表。
bool LinkList::DestroyList() {
if (!ClearList()) {
return false;
}

delete m_pList;

return true;
}

//判断链表是否为空。若为空，返回true，否则返回false。
bool LinkList::IsEmpty() {
if (m_pList->next == NULL) {
return true;
}
return false;
}

//返回链表的中当前节点数。
int LinkList::GetLength() {
return m_listLength;
}

//将链表清空，释放当前所有节点。
bool LinkList::ClearList() {
if (m_pList == NULL) {
return false;
}

LNode *pTemp = NULL;
while (m_pList->next != NULL) {
pTemp = m_pList->next;
m_pList->next = pTemp->next;
delete pTemp;
}
m_listLength = 0;

return true;
}

//将position指定的节点内的数据设置为newData。
//第一个有效节点的position为1。
bool LinkList::SetNodeData(int position, int newData) {
LNode *pTemp = NULL;

if (!(GetNode(position, &pTemp))) {
return false;
}

pTemp->data = newData;

return true;
}

//得到指定位置节点的数据。
//节点索引从1到listLength。
bool LinkList::GetNodeData(int position, int &data) {
LNode *pTemp = NULL;

if (!(GetNode(position, &pTemp))) {
return false;
}

data = pTemp->data;

return true;
}

//在链表中插入一个节点。
//插入的位置由beforeWhich指定，新节点插入在beforeWhich之前。
//beforeWhich的取值在1到ListLength+1之间。
bool LinkList::InsertNode(int beforeWhich, int data) {
LNode *pTemp = NULL;

if (beforeWhich < 1 || beforeWhich > (m_listLength + 1)) {
return false;
}

if (!(GetNode(beforeWhich - 1, &pTemp))) {
return false;
}

LNode *newNode = new LNode;
newNode->data = data;
newNode->next = pTemp->next;
pTemp->next = newNode;

m_listLength++;

return true;
}

//删除一个指定的节点。
//节点位置由position指定。
//positon的值从1到listLength。
//若链表为空或指定的节点不存在则返回false。
bool LinkList::DeleteNode(int position) {
if (position < 1 || position > m_listLength) {
return false;
}

LNode *pTemp = NULL;
if (!(GetNode(position - 1, &pTemp))) {
return false;
}

LNode *pDel = NULL;
pDel = pTemp->next;
pTemp->next = pDel->next;
delete pDel;

m_listLength--;

return true;
}

//得到指定位置节点的指针。
bool LinkList::GetNode(int position, LNode **node) {
LNode *pTemp = NULL;
int curPos = -1;

pTemp = m_pList;
while (pTemp != NULL) {
curPos++;
if (curPos == position)
break;
pTemp = pTemp->next;
}

if (curPos != position) {
return false;
}

*node = pTemp;

return true;
}

//定位与指定数据相等的数据节点。
//如果在当前链表中已经存在该数据则返回该数据节点的索引号。
//若不存在这样的节点则返回0。
//节点索引从0开始到listLength。
int LinkList::LocateElem(int elem) {
LNode *pTemp = NULL;
int curIndex = 1;

pTemp = m_pList->next;
while ((pTemp != NULL) && (pTemp->data != elem)) {
pTemp = pTemp->next;
curIndex++;
}

if (pTemp == NULL) {
return 0;
}

return curIndex;
}

/*
int main(){
LinkList l;

l.InsertNode(1, 10);
l.InsertNode(2, 20);
l.InsertNode(3, 30);
l.InsertNode(4, 40);
cout << l.GetLength() << endl;

int dataTemp = 0;
for (int i = 1; i <= l.GetLength(); i++) {
l.GetNodeData(i, dataTemp);
cout << dataTemp << endl;
}

if (l.SetNodeData(3, 50)) {
cout <<"DONE\n";
} else {
cout << "Failed\n";
}

for (i = 1; i <= l.GetLength(); i++) {
l.GetNodeData(i, dataTemp);
cout << dataTemp << endl;
}

if (l.DeleteNode(4)) {
cout <<"DONE\n";
} else {
cout << "Failed\n";
}

for (i = 1; i <= l.GetLength(); i++) {
l.GetNodeData(i, dataTemp);
cout << dataTemp << endl;
}

cout << l.LocateElem(50) << endl;
return 0;
}
*/

Answer 2

笔误吧，
第一条交换的 previousNode = p->prev; 改为 p = previousNode->next;
函数送入的previousNode 一定是被交换两个节点的父节点。就是下面说的链表中的1。
你的代码里中previousNode上来就赋为p->prev了，此时p还没有值（为0或随机值），后面的所有操作都是错的，访问了不可访问的地址，调试自然会报错。

/*链表 1 2 3 */
/*交换2、3 */
/*p = 2*/

Position BeforeP, AfterP;

/*befor = 1*/
BeforeP = P->Prev;
/*after = 3*/
AfterP = P->Next;
/*2的下一个 = 3的下一个*/
P->Next = AfterP->Next;
/*1的下一个 = 3*/
BeforeP->Next = AfterP;
/*3的下一个 = 2*/
AfterP->Next = P;
/*2的下一个的前一个 = 2*/
P->Next->Prev = P;
/*2的前一个 = 3*/
P->Prev = AfterP;
/*3的前一个 = 1*/
AfterP->Prev = BeforeP;