java鏈表的逆序

Ⅰ 關於java實現鏈表的問題，求高手解惑啊

我看了好長時間，終於明白你哪裡錯了。
1）先說一個你的程序不是演算法問題的錯誤，你的鏈表的header裡面不應該存放具體數據，也就是說header裡面的data應該不用。雖然你的outputLink 方法把header里的data也輸出了，但是reverse方法忽略了header里的數據，而且你不可能創建長度為0的鏈表，因為你的構造方法裡面header不管n為多少，都會有數據。
2）reverse里的錯誤就是q與p在循環里是同一個對象，q.next就是p.next，循環第二行q.next=rev.header，因此p.next也是rev.header，所以最後一行p=p.next，p永遠不會是null，死循環。
3）想說一個不是錯誤的問題，不要把java與c弄混，不要把c語言的用法套到java里，比如java裡面是不建議在另一個類中直接調用其他類的數據域的，像你這里header.data，在Link類里調用Node的data數據域，這樣會出問題，應該使用get與set方法。還有最好每個類都有構造方法，Node類也應該有一個。
個人意見，僅供參考，謝謝。

Ⅱ 有一個單項鏈表，從第一個節點開始遍歷，只允許遍歷一遍，用Java程序實現倒序列印所有節點

// 需要藉助一個容器
String[] cont = new String[list.size()];
Iterator ite = list.iterator();
int j = list.size() - 1;
while(ite.hasNext() && j > -1){
cont[j] = ite.next();
j--;
}
for(String str: cont){
log.info(str);
}

Ⅲ 單向鏈表迭代器如何將鏈表逆序輸出

將一條鏈表按逆序輸出

假若頭結點為L,則有;

p=q=L;/*p,q為指向頭結點的兩個指針*/

while(p->next!=NULL)

p=p->next;/*讓p指向鍵表的最後一個要訪問結點*/

while(1)

{

while(q->next!=p)

q=q->next;/*讓q向後找,找到最後一個要列印的結點*/

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

p=q;/*p向前移動一個*/

q=L;/*q又指向頭結點*/

if(p=L)/*訪問完了退出*/

break;

}

你參考吧

Ⅳ JAVA 語言！定義單鏈表，完成下了演算法： 1、從鍵盤上依次輸入21、18、30、75、42、56，逆序創建單鏈表

我想java.util.LinkedList的源碼可以幫助你解決大部分問題，包括你想要的這5個功能實現。

Ⅳ 將一個鏈表按逆序排列,即將鏈頭當鏈尾,鏈尾當鏈頭

修改了兩個地方，詳見注釋：

NODE*revrese(NODE*head){//由於你的鏈表是不帶頭結點的,所以要採用頭指針的演算法

NODE*p1,*p2,*p3;
p1=head;
p2=p3=NULL;
while(p1){
p2=p1->next;//防止斷鏈,讓q2臨時指向p1的後繼
p1->next=p3;//反復令前驅變後繼,後繼變前驅
p3=p1;//使當前鏈表作為下次要改變為後繼的鏈表。
p1=p2;//繼續處理下一個結點
}
returnp3;

}

voidmain(){

NODE*head;
head=creat();
print(head);
printf("
");
print(revrese(head));//逆轉函數返回一個頭指針指向逆轉的鏈表。

}

Ⅵ JAVA 鏈表逆序

public class List {

Node head;
Node tail;

public void reverse0(List list) {
Node last = reverse(list.head);
list.tail = last;
list.tail.next = null;
}

public Node reverse(Node hd) {

if (hd == null) {
return null;
} else if (hd.next == null) {
head = hd; // the last one becomes the head
} else {
Node node = reverse(hd.next);
node.next = hd;
}
return hd;
}
}

class Node {
int data;
Node next;

public Node(int i) {
data = i;
}
}

Ⅶ java linked list里的元素順序反過來

定義一個LinkedList<Integer> templist = new LinkedList<>();來存儲list裡面的值，通過迭代list，將值插入在templist的頭上，那麼templist就是list的反轉了，最後將templist賦值給list就行了！

如下代碼：

publicvoidreverse(){
LinkedList<Integer>list=newLinkedList<>();
LinkedList<Integer>templist=newLinkedList<>();
inti=0;
while(i<6){
list.add(i);
i++;
}
Iterator<Integer>it=list.iterator();
intm;
while(it.hasNext()&&i>=0){
m=it.next();
templist.addFirst(m);
i--;
}
list=templist;
System.out.println(list);
}

運行結果為：

5 4 3 2 1 0

從API中可以看到List等Collection的實現並沒有同步化，如果在多線程應用程序中出現同時訪問，而且出現修改操作的時候都要求外部操作同步化；調用Iterator操作獲得的Iterator對象在多線程修改Set的時候也自動失效，並拋出java.util.。這種實現機制是fail-fast，對外部的修改並不能提供任何保證。

Iterator是工作在一個獨立的線程中，並且擁有一個 mutex鎖，就是說Iterator在工作的時候，是不允許被迭代的對象被改變的。

Iterator被創建的時候，建立了一個內存索引表（單鏈表），這個索引表指向原來的對象，當原來的對象數量改變的時候，這個索引表的內容沒有同步改變，所以當索引指針往下移動的時候，便找不到要迭代的對象，於是產生錯誤。

List、Set等是動態的，可變對象數量的數據結構，但是Iterator則是單向不可變，只能順序讀取，不能逆序操作的數據結構，當 Iterator指向的原始數據發生變化時，Iterator自己就迷失了方向。

所以如果像下面這么寫就會拋出異常java.util.

：

publicvoidreverse(){
LinkedList<Integer>list=newLinkedList<>();
inti=0;
while(i<6){
list.add(i);
i++;
}
Iterator<Integer>it=list.iterator();
intm;
while(it.hasNext()&&i>=0){
m=it.next();
list.add(m);
list.remove(0);
i--;
}
System.out.println(list);
}

Ⅷ 如何用java雙鏈表實現對一個string的查找，插入，刪除，逆序輸出

LinkedList 這個類就是 雙鏈表！

Ⅸ 誰有Java鏈表的習題，急需。。。

一、單項選擇題
1．Java是從（）語言改進重新設計。
A．Ada B．C++ C．Pasacal D．BASIC
答案：B
2．下列語句哪一個正確（）
A． Java程序經編譯後會產生machine code
B． Java程序經編譯後會產生byte code
C． Java程序經編譯後會產生DLL
D．以上都不正確
答案：B
3．下列說法正確的有（）
A． class中的constructor不可省略
B． constructor必須與class同名，但方法不能與class同名
C． constructor在一個對象被new時執行
D．一個class只能定義一個constructor
答案：C
4．提供Java存取資料庫能力的包是（）
A．java.sql B．java.awt C．java.lang D．java.swing
答案：A
5．下列運算符合法的是（）
A．&& B．<> C．if D．:=
答案：A
6．執行如下程序代碼
a=0;c=0;
do{
--c;
a=a-1;
}while(a>0);
後，C的值是（）
A．0 B．1 C．-1 D．死循環
答案：C
7．下列哪一種敘述是正確的（）
A． abstract修飾符可修飾欄位、方法和類
B．抽象方法的body部分必須用一對大括弧{ }包住
C．聲明抽象方法，大括弧可有可無
D．聲明抽象方法不可寫出大括弧
答案：D
8．下列語句正確的是（）
A．形式參數可被視為local variable
B．形式參數可被欄位修飾符修飾
C．形式參數為方法被調用時，真正被傳遞的參數
D．形式參數不可以是對象
答案：A

9．下列哪種說法是正確的（）
A．實例方法可直接調用超類的實例方法
B．實例方法可直接調用超類的類方法
C．實例方法可直接調用其他類的實例方法
D．實例方法可直接調用本類的類方法
答案：D


二、多項選擇題
1．Java程序的種類有（）
A．類（Class） B．Applet C．Application D．Servlet
2．下列說法正確的有（）
A．環境變數可在編譯source code時指定
B．在編譯程序時，所能指定的環境變數不包括class path
C． javac一次可同時編譯數個Java源文件
D． javac.exe能指定編譯結果要置於哪個目錄（directory）
答案：BCD
3．下列標識符不合法的有（）
A．new B．$Usdollars C．1234 D．car.taxi
答案：ACD
4．下列說法錯誤的有（）
A．數組是一種對象
B．數組屬於一種原生類
C． int number=[]={31,23,33,43,35,63}
D．數組的大小可以任意改變
答案：BCD
5．不能用來修飾interface的有（）
A．private B．public C．protected D．static
答案：ACD
6．下列正確的有（）
A． call by value不會改變實際參數的數值
B． call by reference能改變實際參數的參考地址
C． call by reference不能改變實際參數的參考地址
D． call by reference能改變實際參數的內容
答案：ACD
7．下列說法錯誤的有（）
A．在類方法中可用this來調用本類的類方法
B．在類方法中調用本類的類方法時可直接調用
C．在類方法中只能調用本類中的類方法
D．在類方法中絕對不能調用實例方法
答案：ACD
8．下列說法錯誤的有（）
A． Java面向對象語言容許單獨的過程與函數存在
B． Java面向對象語言容許單獨的方法存在
C． Java語言中的方法屬於類中的成員（member）
D． Java語言中的方法必定隸屬於某一類（對象），調用方法與過程或函數相同
答案：ABC
9．下列說法錯誤的有（）
A．能被java.exe成功運行的java class文件必須有main()方法
B． J2SDK就是Java API
C． Appletviewer.exe可利用jar選項運行.jar文件
D．能被Appletviewer成功運行的java class文件必須有main()方法
答案：BCD

三、判斷題
1．Java程序中的起始類名稱必須與存放該類的文件名相同。（）
答案：正確
2．Unicode是用16位來表示一個字的。（）
答案：正確
3．原生類中的數據類型均可任意轉換。（）
答案：錯誤

1.分別寫出BOOL,int,float,指針類型的變數a 與「零」的比較語句。
答案：
BOOL : if ( !a ) or if(a)
int : if ( a == 0)
float : const EXPRESSION EXP = 0.000001
if ( a < EXP && a >-EXP)
pointer : if ( a != NULL) or if(a == NULL)

2.請說出const與#define 相比，有何優點？
答案：1） const 常量有數據類型，而宏常量沒有數據類型。編譯器可以對前者進行類型安全檢查。而對後者只進行字元替換，沒有類型安全檢查，並且在字元替換可能會產生意料不到的錯誤。
2） 有些集成化的調試工具可以對const 常量進行調試，但是不能對宏常量進行調試。
3.簡述數組與指針的區別？
數組要麼在靜態存儲區被創建（如全局數組），要麼在棧上被創建。指針可以隨時指向任意類型的內存塊。
(1)修改內容上的差別
char a[] = 「hello」;
a[0] = 『X』;
char *p = 「world」; // 注意p 指向常量字元串
p[0] = 『X』; // 編譯器不能發現該錯誤，運行時錯誤
(2) 用運算符sizeof 可以計算出數組的容量（位元組數）。sizeof(p),p 為指針得到的是一個指針變數的位元組數，而不是p 所指的內存容量。C++/C 語言沒有辦法知道指針所指的內存容量，除非在申請內存時記住它。注意當數組作為函數的參數進行傳遞時，該數組自動退化為同類型的指針。
char a[] = "hello world";
char *p = a;
cout<< sizeof(a) << endl; // 12 位元組
cout<< sizeof(p) << endl; // 4 位元組
計算數組和指針的內存容量
void Func(char a[100])
{
cout<< sizeof(a) << endl; // 4 位元組而不是100 位元組
}
4.類成員函數的重載、覆蓋和隱藏區別？
答案：
a.成員函數被重載的特徵：
（1）相同的范圍（在同一個類中）；
（2）函數名字相同；
（3）參數不同；
（4）virtual 關鍵字可有可無。
b.覆蓋是指派生類函數覆蓋基類函數，特徵是：
（1）不同的范圍（分別位於派生類與基類）；
（2）函數名字相同；
（3）參數相同；
（4）基類函數必須有virtual 關鍵字。
c.「隱藏」是指派生類的函數屏蔽了與其同名的基類函數，規則如下：
（1）如果派生類的函數與基類的函數同名，但是參數不同。此時，不論有無virtual關鍵字，基類的函數將被隱藏（注意別與重載混淆）。
（2）如果派生類的函數與基類的函數同名，並且參數也相同，但是基類函數沒有virtual 關鍵字。此時，基類的函數被隱藏（注意別與覆蓋混淆）
5. There are two int variables: a and b, don』t use 「if」, 「? :」, 「switch」or other judgement statements, find out the biggest one of the two numbers.
答案：( ( a + b ) + abs( a - b ) ) / 2


6. 如何列印出當前源文件的文件名以及源文件的當前行號？
答案：
cout << __FILE__ ;
cout<<__LINE__ ;
__FILE__和__LINE__是系統預定義宏，這種宏並不是在某個文件中定義的，而是由編譯器定義的。
7. main 主函數執行完畢後，是否可能會再執行一段代碼，給出說明？
答案：可以，可以用_onexit 注冊一個函數，它會在main 之後執行int fn1(void), fn2(void), fn3(void), fn4 (void);
void main( void )
{
String str("zhanglin");
_onexit( fn1 );
_onexit( fn2 );
_onexit( fn3 );
_onexit( fn4 );
printf( "This is executed first.\n" );
}
int fn1()
{
printf( "next.\n" );
return 0;
}
int fn2()
{
printf( "executed " );
return 0;
}
int fn3()
{
printf( "is " );
return 0;
}
int fn4()
{
printf( "This " );
return 0;
}
The _onexit function is passed the address of a function (func) to be called when the program terminates normally. Successive calls to _onexit create a register of functions that are executed in LIFO (last-in-first-out) order. The functions passed to _onexit cannot take parameters.

8. 如何判斷一段程序是由C 編譯程序還是由C++編譯程序編譯的？
答案：
#ifdef __cplusplus
cout<<"c++";
#else
cout<<"c";
#endif
9.文件中有一組整數，要求排序後輸出到另一個文件中
答案：
＃i nclude
＃i nclude
using namespace std;
void Order(vector& data) //bubble sort
{
int count = data.size() ;
int tag = false ; // 設置是否需要繼續冒泡的標志位
for ( int i = 0 ; i < count ; i++)
{
for ( int j = 0 ; j < count - i - 1 ; j++)
{
if ( data[j] > data[j+1])
{
tag = true ;
int temp = data[j] ;
data[j] = data[j+1] ;
data[j+1] = temp ;
}
}
if ( !tag )
break ;
}
}
void main( void )
{
vectordata;
ifstream in("c:\\data.txt");
if ( !in)
{
cout<<"file error!";
exit(1);
}
int temp;
while (!in.eof())
{
in>>temp;
data.push_back(temp);
}
in.close(); //關閉輸入文件流
Order(data);
ofstream out("c:\\result.txt");
if ( !out)
{
cout<<"file error!";
exit(1);
}
for ( i = 0 ; i < data.size() ; i++)
out<

10. 鏈表題：一個鏈表的結點結構
struct Node
{
int data ;
Node *next ;
};
typedef struct Node Node ;
(1)已知鏈表的頭結點head,寫一個函數把這個鏈表逆序 ( Intel)
Node * ReverseList(Node *head) //鏈表逆序
{
if ( head == NULL || head->next == NULL )
return head;
Node *p1 = head ;
Node *p2 = p1->next ;
Node *p3 = p2->next ;
p1->next = NULL ;
while ( p3 != NULL )
{
p2->next = p1 ;
p1 = p2 ;
p2 = p3 ;
p3 = p3->next ;
}
p2->next = p1 ;
head = p2 ;
return head ;
}
(2)已知兩個鏈表head1 和head2 各自有序，請把它們合並成一個鏈表依然有序。(保留所有結點，即便大小相同）
Node * Merge(Node *head1 , Node *head2)
{
if ( head1 == NULL)
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
Node *p1 = NULL;
Node *p2 = NULL;
if ( head1->data < head2->data )
{
head = head1 ;
p1 = head1->next;
p2 = head2 ;
}
else
{
head = head2 ;
p2 = head2->next ;
p1 = head1 ;
}
Node *pcurrent = head ;
while ( p1 != NULL && p2 != NULL)
{
if ( p1->data <= p2->data )
{
pcurrent->next = p1 ;
pcurrent = p1 ;
p1 = p1->next ;
}
else
{
pcurrent->next = p2 ;
pcurrent = p2 ;
p2 = p2->next ;
}
}
if ( p1 != NULL )
pcurrent->next = p1 ;
if ( p2 != NULL )
pcurrent->next = p2 ;
return head ;
}
(3)已知兩個鏈表head1 和head2 各自有序，請把它們合並成一個鏈表依然有序，這次要求用遞歸方法進行。 (Autodesk)
答案：
Node * MergeRecursive(Node *head1 , Node *head2)
{
if ( head1 == NULL )
return head2 ;
if ( head2 == NULL)
return head1 ;
Node *head = NULL ;
if ( head1->data < head2->data )
{
head = head1 ;
head->next = MergeRecursive(head1->next,head2);
}
else
{
head = head2 ;
head->next = MergeRecursive(head1,head2->next);
}
return head ;
}

Ⅹ 鏈表反序

/*
*鏈表應用要求：1建立 2刪除 3輸出 4反序 5主函數
*/
#include<iostream>
#include<iomanip>
using namespace std;

typedef struct Lnode{
int data;
struct Lnode *next;
}Lnode,*LinkList;
//初始化鏈表
bool initList(LinkList &L)
{
L=new Lnode;
if(L==NULL){
cerr<<"內存分配錯誤！"<<endl;
return false;
}
L->next=NULL;
return true;
}
//創建鏈表
bool createList(LinkList &L)
{
int n,data;
LinkList p=L,r;
cout<<"輸入鏈表元素的個數：";
cin>>n;
cout<<"輸入鏈表中的元素：";
for(int i=0;i<n;++i){
cin>>data;
r=new Lnode;
if(r==NULL){
cerr<<"內存分配錯誤！"<<endl;
return false;
}
r->data=data;
r->next=p->next;
p->next=r;
p=r;
}
p->next=NULL;
return true;
}
//刪除鏈表中的元素
bool deleteList(LinkList L)
{
int pos;
LinkList p=L;
if(p->next==NULL){
cout<<"鏈表是空的！"<<endl;
return false;
}
cout<<"輸入你要刪除的位置：";
cin>>pos;
for(int i=0;i<pos-1;++i){
p=p->next;
}
LinkList q=p->next;
cout<<"你刪除的第"<<pos<<"個位置的元素是："<<q->data<<endl;
p->next=q->next;
delete q;
return true;
}
//逆序輸出鏈表中的元素
bool invertList(LinkList &L)
{
LinkList p=L->next;
if(p==NULL) return false;
else invertList(p); //採用遞歸的方式逆序輸出鏈表
cout<<p->data<<setw(5);
return true;
}
//輸出鏈表中的元素
bool dispList(LinkList L)
{
LinkList p=L->next;
if(p==NULL){
cout<<"鏈表是空的！"<<endl;
return false;
}
cout<<"鏈表中的元素為：";
while(p){
cout<<p->data<<setw(5);
p=p->next;
}
cout<<endl;
return true;
}
void main()
{
LinkList L;
initList(L);
createList(L);
dispList(L);
deleteList(L);
dispList(L);
cout<<"逆序輸出的元素為：";
invertList(L);
cout<<endl;
}
題目中的將鏈表逆序，如果用單鏈表實現有點麻煩，我再想想有沒有好的辦法。
上面的程序中我只是將鏈表的元素逆序輸出，至於將鏈表逆序，我想好了會回復你的。