鏈表逆置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中