在制作一个通过节点字段从 X 点移动到 Y 点的程序的过程中。我是 C 的新手，我的代码中出现错误问题。我正在寻求您的帮助来修复这些（很可能是愚蠢的错误），所以我希望它能够正常运行。任何建议将不胜感激！
这是节点字段 http://i1350.photobucket.com/albums/p771/Clarkyy4/Untitled_zps9bbda929.png
解决 项目的确切问题：找到网络中任意两个节点之间的最短网络路径。*在上述网络中输入一个源节点。*输入网络中的目标节点。* 找到从源到目的地的最短路径并显示出来。ie 进入源节点：E 进入源节点：H 最短路径：E - F - G - H (3 hops) （最短路径可能不止一条，至少找到一条） 你必须使用我们讨论过的ADT之一在课堂上（我建议使用 queuesADT 或 linkListADT）。
这是链接列表ADT.h
/* This header file contains the functions to maintain
and process a linked list.
Written by:
Date:
*/
//#include "P5-01.h" /* Singly-Linked List ADT Type Definitions */
// List ADT Type Defintions
typedef struct node
{
void* dataPtr;
struct node* link;
} NODE;
typedef struct
{
int count;
NODE* pos;
NODE* head;
NODE* rear;
int (*compare) (void* argu1, void* argu2);
} LIST;
//#include "P5-02.h" /* List ADT Prototype Declarations */
// Prototype Declarations
LIST* createList (int (*compare)
(void* argu1, void* argu2));
LIST* destroyList (LIST* list);
int addNode (LIST* pList, void* dataInPtr);
bool removeNode (LIST* pList,
void* keyPtr,
void** dataOutPtr);
bool searchList (LIST* pList,
void* pArgu,
void** pDataOut);
bool retrieveNode (LIST* pList,
void* pArgu,
void** dataOutPtr);
bool traverse (LIST* pList,
int fromWhere,
void** dataOutPtr);
int listCount (LIST* pList);
bool emptyList (LIST* pList);
bool fullList (LIST* pList);
static bool _insert1 (LIST* pList,
NODE* pPre,
void* dataInPtr);
static void _delete (LIST* pList,
NODE* pPre,
NODE* pLoc,
void** dataOutPtr);
static bool _search (LIST* pList,
NODE** pPre,
NODE** pLoc,
void* pArgu);
// End of List ADT Definitions
//#include "P5-03.h" /* Create linked list */
/* =============== createList ==============
Allocates dynamic memory for a list head
node and returns its address to caller
Pre compare is address of compare function
used to compare two nodes.
Post head has allocated or error returned
Return head node pointer or null if overflow
*/
LIST* createList
(int (*compare) (void* argu1, void* argu2))
{
// Local Definitions
LIST* list;
// Statements
list = (LIST*) malloc (sizeof (LIST));
if (list)
{
list->head = NULL;
list->pos = NULL;
list->rear = NULL;
list->count = 0;
list->compare = compare;
} // if
return list;
} // createList
//#include "P5-04.h" /* Add Node */
/* ================== addNode =================
Inserts data into list.
Pre pList is pointer to valid list
dataInPtr pointer to insertion data
Post data inserted or error
Return -1 if overflow
0 if successful
1 if dupe key
*/
int addNode (LIST* pList, void* dataInPtr)
{
// Local Definitions
bool found;
bool success;
NODE* pPre;
NODE* pLoc;
// Statements
found = _search (pList, &pPre, &pLoc, dataInPtr);
if (found)
// Duplicate keys not allowed
return (+1);
success = _insert1 (pList, pPre, dataInPtr);
if (!success)
// Overflow
return (-1);
return (0);
} // addNode
//#include "P5-05.h" /* Insert Node */
/* =================== _insert1 ==================
Inserts data pointer into a new node.
Pre pList pointer to a valid list
pPre pointer to data's predecessor
dataInPtr data pointer to be inserted
Post data have been inserted in sequence
Return boolean, true if successful,
false if memory overflow
*/
static bool _insert1 (LIST* pList, NODE* pPre,
void* dataInPtr)
{
// Local Definitions
NODE* pNew;
// Statements
if (!(pNew = (NODE*) malloc(sizeof(NODE))))
return false;
pNew->dataPtr = dataInPtr;
pNew->link = NULL;
if (pPre == NULL)
{
// Adding before first node or to empty list.
pNew->link = pList->head;
pList->head = pNew;
if (pList->count == 0)
// Adding to empty list. Set rear
pList->rear = pNew;
} // if pPre
else
{
// Adding in middle or at end
pNew->link = pPre->link;
pPre->link = pNew;
// Now check for add at end of list
if (pNew->link == NULL)
pList->rear = pNew;
} // if else
(pList->count)++;
return true;
} // _insert1
//#include "P5-06.h" /* Remove Node */
/* ================= removeNode ================
Removes data from list.
Pre pList pointer to a valid list
keyPtr pointer to key to be deleted
dataOutPtr pointer to data pointer
Post Node deleted or error returned.
Return false not found; true deleted
*/
bool removeNode (LIST* pList, void* keyPtr,
void** dataOutPtr)
{
// Local Definitions
bool found;
NODE* pPre;
NODE* pLoc;
// Statements
found = _search (pList, &pPre, &pLoc, keyPtr);
if (found)
_delete (pList, pPre, pLoc, dataOutPtr);
return found;
} // removeNode
//#include "P5-07.h" /* Delete Node */
/* ================= _delete ================
Deletes data from a list and returns
pointer to data to calling module.
Pre pList pointer to valid list.
pPre pointer to predecessor node
pLoc pointer to target node
dataOutPtr pointer to data pointer
Post Data have been deleted and returned
Data memory has been freed
*/
void _delete (LIST* pList, NODE* pPre,
NODE* pLoc, void** dataOutPtr)
{
// Statements
*dataOutPtr = pLoc->dataPtr;
if (pPre == NULL)
// Deleting first node
pList->head = pLoc->link;
else
// Deleting any other node
pPre->link = pLoc->link;
// Test for deleting last node
if (pLoc->link == NULL)
pList->rear = pPre;
(pList->count)--;
free (pLoc);
return;
} // _delete
//#include "P5-08.h" /* Search Interface */
/* ================== searchList =================
Interface to search function.
Pre pList pointer to initialized list.
pArgu pointer to key being sought
Post pDataOut contains pointer to found data
-or- NULL if not found
Return boolean true successful; false not found
*/
bool searchList (LIST* pList, void* pArgu,
void** pDataOut)
{
// Local Definitions
bool found;
NODE* pPre;
NODE* pLoc;
// Statements
found = _search (pList, &pPre, &pLoc, pArgu);
if (found)
*pDataOut = pLoc->dataPtr;
else
*pDataOut = NULL;
return found;
} // searchList
//#include "P5-09.h" /* Search List */
/* ================== _search =================
Searches list and passes back address of node
containing target and its logical predecessor.
Pre pList pointer to initialized list
pPre pointer variable to predecessor
pLoc pointer variable to receive node
pArgu pointer to key being sought
Post pLoc points to first equal/greater key
-or- null if target > key of last node
pPre points to largest node < key
-or- null if target < key of first node
Return boolean true found; false not found
*/
bool _search (LIST* pList, NODE** pPre,
NODE** pLoc, void* pArgu)
{
// Macro Definition
#define COMPARE \
( ((* pList->compare) (pArgu, (*pLoc)->dataPtr)) )
#define COMPARE_LAST \
((* pList->compare) (pArgu, pList->rear->dataPtr))
// Local Definitions
int result;
// Statements
*pPre = NULL;
*pLoc = pList->head;
if (pList->count == 0)
return false;
// Test for argument > last node in list
if ( COMPARE_LAST > 0)
{
*pPre = pList->rear;
*pLoc = NULL;
return false;
} // if
while ( (result = COMPARE) > 0 )
{
// Have not found search argument location
*pPre = *pLoc;
*pLoc = (*pLoc)->link;
} // while
if (result == 0)
// argument found--success
return true;
else
return false;
} // _search
//#include "P5-10.h" /* Retrieve Node */
/* ================== retrieveNode ================
This algorithm retrieves data in the list without
changing the list contents.
Pre pList pointer to initialized list.
pArgu pointer to key to be retrieved
Post Data (pointer) passed back to caller
Return boolean true success; false underflow
*/
static bool retrieveNode (LIST* pList,
void* pArgu,
void** dataOutPtr)
{
// Local Definitions
bool found;
NODE* pPre;
NODE* pLoc;
// Statements
found = _search (pList, &pPre, &pLoc, pArgu);
if (found)
{
*dataOutPtr = pLoc->dataPtr;
return true;
} // if
*dataOutPtr = NULL;
return false;
} // retrieveNode
//#include "P5-11.h" /* Empty List */
/* ================= emptyList ================
Returns boolean indicating whether or not the
list is empty
Pre pList is a pointer to a valid list
Return boolean true empty; false list has data
*/
bool emptyList (LIST* pList)
{
// Statements
return (pList->count == 0);
} // emptyList
//#include "P5-12.h" /* Full List */
/* ================== fullList =================
Returns boolean indicating no room for more data.
This list is full if memory cannot be allocated for
another node.
Pre pList pointer to valid list
Return boolean true if full
false if room for node
*/
bool fullList (LIST* pList)
{
// Local Definitions
NODE* temp;
// Statements
if ((temp = (NODE*)malloc(sizeof(*(pList->head)))))
{
free (temp);
return false;
} // if
// Dynamic memory full
return true;
} // fullList
//#include "P5-13.h" /* List Count */
/* ================== listCount ==================
Returns number of nodes in list.
Pre pList is a pointer to a valid list
Return count for number of nodes in list
*/
int listCount(LIST* pList)
{
// Statements
return pList->count;
} // listCount
//#include "P5-14.h" /* Traverse List */
/* ================== traverse =================
Traverses a list. Each call either starts at the
beginning of list or returns the location of the
next element in the list.
Pre pList pointer to a valid list
fromWhere 0 to start at first element
dataPtrOut address of pointer to data
Post if more data, address of next node
Return true node located; false if end of list
*/
bool traverse (LIST* pList,
int fromWhere,
void** dataPtrOut)
{
// Statements
if (pList->count == 0)
return false;
if (fromWhere == 0)
{
//Start from first node
pList->pos = pList->head;
*dataPtrOut = pList->pos->dataPtr;
return true;
} // if fromwhere
else
{
// Start from current position
if (pList->pos->link == NULL)
return false;
else
{
pList->pos = pList->pos->link;
*dataPtrOut = pList->pos->dataPtr;
return true;
} // if else
} // if fromwhere else
} // traverse
//#include "P5-15.h" /* Destroy List */
/* ================== destroyList =================
Deletes all data in list and recycles memory
Pre List is a pointer to a valid list.
Post All data and head structure deleted
Return null head pointer
*/
LIST* destroyList (LIST* pList)
{
// Local Definitions
NODE* deletePtr;
// Statements
if (pList)
{
while (pList->count > 0)
{
// First delete data
free (pList->head->dataPtr);
// Now delete node
deletePtr = pList->head;
pList->head = pList->head->link;
pList->count--;
free (deletePtr);
} // while
free (pList);
} // if
return NULL;
} // destroyList
主要代码
#include "stdafx.h"
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include "linkListADT.h"
typedef struct
{
void* dataPtr;
struct node* link;
} NODE;
typedef struct
{
int count;
NODE* pos;
NODE* head;
NODE* rear;
} DATA;
int _tmain(int argc, _TCHAR* argv[])
{
// empty list
node *head = NULL;
// create a temporary
node *temp;
temp = (node*)malloc(sizeof(node)); // allocate
// place info to first node
temp->data->head = 'A';
temp->data->pos = 1;
temp->data->rear = NULL;
// get address of head
temp->next=head;
head = temp;
}
{
char cnode = 'A','B','C','D','E','F','G','H','I','J';
int next;
int cnode;
printf(cnode);
switch(cnode);
{
case 'A';
next = rand()%3;
switch(next);
{
case 0: cnode = 'E'; break;
case 1: cnode = 'F'; break;
case 2: cnode = 'B'; break;
}
case 'B';
next = rand()%3;
switch(next);
{
case 0: cnode = 'A'; break;
case 1: cnode = 'C'; break;
case 2: cnode = 'D'; break;
}
case 'C';
next = rand()%3;
switch(next);
{
case 0: cnode = 'B'; break;
case 1: cnode = 'F'; break;
case 2: cnode = 'G'; break;
}
case 'D';
next = rand()%3;
switch(next)
{
case 0: cnode = 'B'; break;
case 1: cnode = 'G'; break;
case 2: cnode = 'H'; break;
}
case 'E';
next = rand()%3;
switch(next)
{
case 0: cnode = 'B'; break;
case 1: cnode = 'G'; break;
case 2: cnode = 'H'; break;
}
case 'F';
next = rand()%6;
switch(next)
{
case 0: cnode = 'C'; break;
case 1: cnode = 'G'; break;
case 2: cnode = 'E'; break;
case 3: cnode = 'A'; break;
case 4: cnode = 'J'; break;
case 5: cnode = 'K'; break;
}
case 'G';
next = rand()%4;
switch(next)
{
case 0: cnode = 'D'; break;
case 1: cnode = 'F'; break;
case 2: cnode = 'H'; break;
case 3: cnode = 'C': break;
}
case 'H';
next = rand()%4;
switch(next)
{
case 0: cnode = 'D'; break;
case 1: cnode = 'G'; break;
case 2: cnode = 'L'; break;
case 3: cnode = 'K': break;
}
case 'I';
next = rand()%2;
switch(next)
{
case 0: cnode = 'E'; break;
case 1: cnode = 'J'; break;
}
case 'J';
next = rand()%3;
switch(next)
{
case 0: cnode = 'F'; break;
case 1: cnode = 'I'; break;
case 2: cnode = 'K'; break;
}
case 'K';
next = rand()%4;
switch(next)
{
case 0: cnode = 'H'; break;
case 1: cnode = 'L'; break;
case 2: cnode = 'F'; break;
case 3: cnode = 'J'; break;
}
case 'L';
next = rand()%2;
switch(next)
{
case 0: cnode = 'H'; break;
case 1: cnode = 'K'; break;
}
}
}
}
return 0;
}