链表逆置java

1. 单链表的逆置怎么办

#include <stdio.h>

#include <stdlib.h>

typedef struct node

{

int data;

struct node *next;

}Node;

//创建链表

Node *CreatList(void)

p = (Node *)malloc(sizeof(Node));

p->data = i;

if(head == NULL)

q = head = p;

else

q->next = p;

q = p;

scanf("%d", &i);

}

p->next = NULL;

return head;

}

//链表的逆置

Node *ReverseList(Node *head)

{

Node *p, *q, *r;

p = head;

q=r=NULL;

while(p)

//输出链表

void PrintList(Node *head)

{

Node *p;

p = head;

while(p)

{

printf("%d ", p->data);

p = p->next;

}

}

int main(void)

{

Node *head;

head = CreatList();

printf("链表逆置前的数据: ");

PrintList(head);

head = ReverseList(head);

printf("链表逆置后的数据: ");

PrintList(head);

存储表示：

① 用一组任意的存储单元来存放线性表的结点（这组存储单元既可以是连续的，也可以是不连续的）

② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系，在存储每个结点值的同时，还必须存储指示其后继结点的地址（或位置）信息（称为指针（pointer）或链(link)）

链式存储是最常用的存储方式之一，它不仅可用来表示线性表，而且可用来表示各种非线性的数据结构。

2. 如何实现将带头结点单链表A中的数据逆置后储存在带头结点单链表B中用java语言，最好将代码写出来，

#include<stdio.h>

//逆置带有头结点的单链表，这是C语言代码，仅供参考。
node*reverse(node*head){
	node*p=head->next,*q=NULL,*t;
	while(p){
		t=p;
		p=p->next;
		t->next=q;
		q=t;
	}
	head=t;
	returnhead;
}

intmain(){
	return0;
}

3. 单链表的逆置,帮我解释一下这个算法,void reverse (LinkList...

void
reverse
(LinkList
&L)
//单链表的逆置{\x09LinkList
a,b,c;
a=L;b=L->next
;
//
L为头结点
\x09while
(b->next
!=NULL)
//
主要思想就在这了,从第一个结点开始,只要\x09{
它的下一个结点不为NULL,则将
->next反\x09\x09c=b->next
;
向,先将->next保存,再反指\x09\x09b->next
=a;
\x09\x09a=b;
//
这两名循环上面\x09\x09b=c;\x09}\x09b->next
=a;
//
->next为空的话,由于后面没了,直接反向\x09L->next
->next
=NULL;
//
L->next此时指向的是反向前的第一个结点,反向后这个结点改为指向
NULL,
即收尾\x09L->next=b;
//头结点指向第一个结点
}
//描述的可能不是很清楚,你画个链表图的话应该有助于理解

4. 如何将一个单向链表逆置

1. 先找到最后一个节点，作为新链表的头

2. 然后循环找出所有的节点，链到新的表头上就可以了。

#include<iostream>
usingnamespacestd;
structNode
{
intdata;
Node*next;
};
structNode*create(intn)
{
Node*head=NULL,*p;
inti=0;
intd;
while(i<n)
{
p=new(structNode);
scanf("%d",&p->data);
p->next=NULL;
if(head==NULL)
head=p;
else
{
p->next=head;
head=p;
}
i++;
}
returnhead;
}
voidshow(Node*h)
{
Node*p;
p=h;
while(p!=NULL)
{
printf("%d	",p->data);
p=p->next;
}
printf("
");
}
structNode*reverse(structNode*h)
{
structNode*p,*q,*head;
p=h;
intcount=0;
while(p->next!=NULL)
{p=p->next;count++;}//???????????????????????
head=p;//???????????
//head->next=NULL;
while(count>0)
{
q=h;
while(q->next!=p&&q!=NULL)
{
q=q->next;
}//?????????????β???
p->next=q;
//q->next=NULL;
p=q;
if(q==h)
q->next=NULL;
count--;
}
returnhead;
}
intmain()
{
Node*h1,*h2;
h1=create(8);
show(h1);
h2=reverse(h1);
show(h2);
return0;
}

5. java数据结构，单链表的逆置

如图吧，还是挺好理解的。

6. 实现单链表逆置

就是头插法，图片真心懒得画……
每一步实现的是这样的过程：
0（初始化）、q为每一步运算的主要节点位置，初始化为第一个；
1、r=q的后续，把q的后续记录下来；
2、q-》next=p，把q的后续指向p（也就是开始），换句话说，把q放在了最开始；
3、p=q，把新的开始设置为新插入的q（下一次循环时，他就是p了）；
4、q=r，把下一步要进行运算的主要节点设置为r，也就是当前运算节点的下个节点。

相当于，一队小朋友双手搭着前一个人的肩。从第二个开始，把他挪到第一个人前面去，然后对下一个人做同样操作。
自己画画图吧，指针就是这么个东西。

7. 单链表逆置的详细设计

#include<iostream>
using namespace std;
struct Number //链表的类型
{
char data; //链表当前结点的值
struct Number *next; //链表当前结点指向下一结点的指针
}*number;
void CreateList(Number *&L) //创建链表
{
Number *s,*r; //定义两个链表类型的临时指针
char x; //定义一个临时字符变量
L=(Number *)malloc(sizeof(Number)); //为头结点开辟空间
L->next=NULL; //此时头结点的后继指针和前驱指针赋值为空
r=L; //是r指针指向头结点
x=getchar(); //用x接受一个从键盘输入的字符
while(x!=' ') //控制当输入回车键时结束
{
s=(Number *)malloc(sizeof(Number)); //开辟下一结点的空间
s->data=x;
r->next=s; //r的后继指针指向s
r=s; //是s指向r
x=getchar(); //用x接受一个从键盘输入的字符
}
r->next=NULL; //当创建结束时，r的后继指针为空
}
void PrintList(Number *L) //输出链表
{
Number *p=L->next; //定义一个临时指针并指向链表的第一个结点
while(p!=NULL) //判断结点是否为空，空就结束
{
cout<<p->data; //输出结点的值
p=p->next; //指向下一个结点
}
cout<<endl; //换行
}
void InverseList(Number *L) //链表的逆置
{
Number *p=L->next,*q=L->next;
q=q->next;
p->next=NULL;
p=q;
while(p!=NULL)
{
q=q->next;
p->next=L->next;
L->next=p;
p=q;
}
}
void DestroyList(Number *&L) //销毁链表
{
Number *p=L,*q=p->next;
while(q!=NULL)
{
free(p); //释放p的空间
p=q;
q=p->next;
}
cout<<释放链表<<endl;
}
int main()
{
cout<<请输入一个链表:;
CreateList(number); //调用创建链表
cout<<********************************************************************************;
cout<<输入的链表为：<<endl;
PrintList(number); //调用输出链表
InverseList(number); //调用逆置链表
cout<<此链表的逆置为：<<endl;
PrintList(number); //调用输出链表
cout<<********************************************************************************;
DestroyList(number); //调用销毁链表的函数
return 0;
}

8. 链表逆置问题

链表主要靠NEXT指针找到下一个元素，如果原来A->NEXT指向 B，就B->NEXT指向A，即原来是通过A找到B的，现在是通过B找到A。把除了头结点之外的所有节点进行这样的变换，即可实现逆置。
你的代码中还应该加一个对空链表的特殊处理。

9. 用java来编写一个单链表类的成员函数，实现对头结点的单链表就地逆置的操作

逆置有两种方法，第一是把所有节点反过来。还有一种就是改变节点中的值。
第一种情况，其实可以考虑用头插法，来实现逆置。
下面的算法是基于头插法的思想，逆置链表的，仅供参考。
LinkList anti_linklist(LinkList demo)
{
LInkList *p,*q;//work pointer
LinkList head;
head=new LinkList();
head->next=null;//init head pointer
p=demo->head->next;//make p points to the first node
if(p==null)
return null;//the linklist is null
while(p!=null)
{
q=p;
q->next=head->next;
head->next=q;
p=p->next;
}
}

10. 如何实现将带头结点单链表A中的数据逆置后储存在带头结点单链表B中用java语言

最简单的方法，遍历A，将值存在一个数组中，然后倒序从数组中取值放在B中