C语言链表中的指针怎么样前后移动

Question

一般用while(p!=NULL){p=p->next}来遍历链表，但这样是一条链走到底。
比方说我想让指在遍历完后，往回走一结点或两个结要怎么做，要怎么做。我昨天试出往前移动一个或两个方法，但用此方法往前移就不行了；
所以有个疑问，但向链表是不是只能往一个方向移动；因为每个结点的Pv->next=p都指向新P，这是向后链合，但新P能不能有什么方向往前往回走呢；请高手指点下，这里要怎么写；
或都说前面的while(p!=NULL){p=p->next}这个是从头往尾遍历，那我就用此链表，来个从尾到头来遍历要怎么写？

Answer 1

来吧~~单链表应生生反着遍历

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

#define elemType int /* 单链表元素数据类型 */
#define LNODE_SIZE sizeof (struct lNode) /* 单链表结点空间大小 */

#define status int /* 状态型变量 */
#define OVERFLOW -1 /* 内存溢出状态码 */
#define ERROR 0 /* 错误状态码 */
#define OK 1 /* 正确状态码 */

/* 单链表数据结构 */
typedef struct lNode {
elemType data;
struct lNode *next;
} lNode, *linkList;

/* 初始化 */
/* 操作结果：构造一个空的单链表L */
void initList (linkList *L) {
*L = (linkList) malloc (LNODE_SIZE); /* 产生头结点，并使L指向此头结点 */
if(!*L) /* 内存分配失败 */
exit (OVERFLOW);
(*L)->next = NULL; /* 指针域为空 */
}

/* 销毁 */
/* 初始条件：单链表L已存在。操作结果：销毁单链表L */
void destroyList (linkList L) {
linkList p,q;

p = L->next; /* p指向第一个结点 */
while (p) { /* 没到表尾 */
q = p->next;
     free (p);
     p = q;
}
free (L);
}

/* 判断单链表是否为空 */
/* 初始条件：单链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
int listIsEmpty (linkList L) {
return L->next == NULL;
}

/* 获取单链表长度 */
/* 初始条件：单链表L已存在。操作结果：返回L中数据元素个数 */
int listLength (linkList L) {
int i = 0;
linkList p = L->next; /* p指向第一个结点 */

while (p) { /* 没到表尾 */
     i++;
     p=p->next;
}

return i;
}

/* 获取单链表指定元素值 */
/* 操作结果：L为带头结点的单链表的头指针。当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */
status getElem (linkList L, int i, elemType *e) {
int j = 1; /* j为计数器 */
linkList p = L->next; /* p指向第一个结点 */

while (p && j<i) { /* 顺指针向后查找，直到p指向第i个元素或p为空 */
p = p->next;
j++;
}

if (!p || j>i) /* 第i个元素不存在 */
return ERROR;

*e = p->data; /* 取第i个元素 */

return OK;
}

/* 单链表指定位置插入新元素 */
/* 操作结果：在带头结点的单链表L中第i个位置之前插入元素e */
status listInsertNode (linkList L, int i, elemType e) {
int j=0;
linkList p=L,s;

while (p && j<i-1) { /* 寻找第i-1个结点 */
p = p->next;
     j++;
}

if (!p || j>i-1) /* 插入位置不合理：i小于1或者大于表长 */
return ERROR;

/* 生成新结点，并插入L中 */
s = (linkList) malloc (LNODE_SIZE);
if(!s) /* 内存分配失败 */
exit (OVERFLOW);
s->data = e;
s->next = p->next;
p->next = s;

return OK;
}

/* 删除单链表指定位置元素 */
/* 操作结果：在带头结点的单链线性表L中，删除第i个元素，并由e返回其值 */
status listDeleteNode (linkList L, int i, elemType *e) {
int j = 0;
linkList p = L, q;

while (p->next && j<i-1) { /* 寻找第i个结点，并令p指向其前驱结点 */
     p = p->next;
j++;
}

if (!p->next || j>i-1) /* 删除位置不合理：i小于1或者大于表长 */
return ERROR;

/* 删除并释放结点 */
q = p->next;
p->next = q->next;
*e = q->data;
free (q);

return OK;
}

/* 打印链表内容 */
/* 初始条件：单链表L已存在。操作结果：当链表不为空时，打印链表内容并返回OK，否则返回ERROR */
status printList (linkList L) {
linkList p = L->next; /* p指向第一个结点 */

if (listIsEmpty (L)) {
puts ("The link list is empty! ");
return ERROR;
}

while (p) {
printf ("%d\t", p->data);
p = p->next;
}
putchar ('\n');
return OK;
}

int main (void) {
linkList L;
elemType e;
elemType a=1, b=2, c=3, d=4;
int index, j;

/* 初始化链表 */
initList (&L);
/* 插入若干元素 */
listInsertNode (L, 1, a);
listInsertNode (L, 1, b);
listInsertNode (L, 1, c);
listInsertNode (L, 1, d);

printList (L);

for (j=listLength (L); j>0; j--) { /* 反向遍历打印 */
getElem (L, j, &e);
printf ("%d\t", e);
}
putchar ('\n');


destroyList (L); 

getch (); /* 屏幕暂留 */ 
return 0 ;
}

=======以下是原回答==============================================

写个双向链表呗。每个结点搞两个指针域，分别存前驱、后继两个结点。这样就可以很方便的从后往前遍历了。

以下简单写个双向循环链表（双向链表一般都循环），包括初始化、销毁、插入结点、删除结点、正向打印、反向打印

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

#define elemType int /* 单链表元素数据类型 */
#define LNODE_SIZE sizeof (struct lNode) /* 单链表结点空间大小 */

#define status int /* 状态型变量 */
#define OVERFLOW -1 /* 内存溢出状态码 */
#define ERROR 0 /* 错误状态码 */
#define OK 1 /* 正确状态码 */

/* 循环双链表数据结构 */
typedef struct lNode {
elemType data;
struct lNode *prior, *next;
} duLNode, *duLinkList;

/* 初始化 */
/* 操作结果：构造一个空的循环双链表L */
void initList (duLinkList *L) {
*L = (duLinkList) malloc (LNODE_SIZE); /* 产生头结点，并使L指向此头结点 */
if(!*L) /* 内存分配失败 */
exit (OVERFLOW);
(*L)->next = (*L)->prior = (*L); /* 指针域指向头结点 */
}

/* 销毁 */
/* 初始条件：循环双链表L已存在。操作结果：销毁循环双链表L */
void destroyList (duLinkList L) {
duLinkList p, q;

p = L->next; /* p指向第一个结点 */
while (p != L) { /* 尚未重新回到头结点 */
q = p->next;
     free (p);
     p = q;
}
free (L);
}

/* 判断循环双链表是否为空 */
/* 初始条件：循环双链表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE */
int listIsEmpty (duLinkList L) {
return (L->next == L && L->prior == L);
}

/* 循环双链表指定位置插入新元素 */
/* 操作结果：在带头结点的循环双链表L中第i个位置之前插入元素e */
status listInsertNode (duLinkList L, int i, elemType e) {
int j = 0;
duLinkList p = L, s;

while (j<i-1) { /* 寻找第i-1个结点 */
p = p->next;
if (p!=L) /* 计数时跳过头结点 */
     j++;
}

if (j>i-1) /* 插入位置不合理：i小于1 */
return ERROR;

/* 生成新结点，并插入L中 */
s = (duLinkList) malloc (LNODE_SIZE);
if(!s) /* 内存分配失败 */
exit (OVERFLOW);
s->data = e;
s->next = p->next;
p->next->prior = s;
p->next = s;
s->prior = p;

return OK;
}

/* 删除循环双链表指定位置元素 */
/* 操作结果：在带头结点的循环双链表L中，删除第i个元素，并由e返回其值 */
status listDeleteNode (duLinkList L, int i, elemType *e) {
int j = 0;
duLinkList p = L, q;

while (j<i-1) { /* 寻找第i-1个结点 */
     p = p->next;
     if (p!=L) /* 计数时跳过头结点 */
j++;
}
if (p->next == L) /* 第i-1个结点是尾结点 */
p = L;

if (j>i-1) /* 删除位置不合理：i小于1 */
return ERROR;

/* 删除并释放结点 */
q = p->next;
p->next = q->next;
q->next->prior = p;
*e = q->data;
free (q);

return OK;
}

/* 打印链表内容 */
/* 初始条件：循环双链表L已存在。操作结果：当链表不为空时，打印链表内容并返回OK，否则返回ERROR */
status printList (duLinkList L) {
duLinkList p = L->next; /* p指向第一个结点 */

if (listIsEmpty (L)) {
puts ("The linked list is empty! ");
return ERROR;
}

while (p != L) { /* 尚未重新回到头结点 */
printf ("%d\t", p->data);
p = p->next;
}
putchar ('\n');
return OK;
}

/* 反向打印链表内容 */
status printList2 (duLinkList L) {
duLinkList p = L->prior; /* p指向最后一个结点 */

if (listIsEmpty (L)) {
puts ("The linked list is empty! ");
return ERROR;
}

while (p != L) { /* 尚未重新回到头结点 */
printf ("%d\t", p->data);
p = p->prior;
}
putchar ('\n');
return OK;
}

int main (void) {
duLinkList L;
elemType e;
elemType a=1, b=2, c=3, d=4;
int index;

/* 初始化链表 */
initList (&L);
/* 插入若干元素 */
listInsertNode (L, 1, a);
listInsertNode (L, 1, b);
listInsertNode (L, 1, c);
listInsertNode (L, 1, d);

/* 正向、反向打印 */
printList (L);
printList2 (L);

/* 删除一个结点 */
listDeleteNode (L, 1, &e);

/* 正向、反向打印 */
printList (L);
printList2 (L);

destroyList (L); 

getch (); /* 屏幕暂留 */ 
return 0 ;
}