反轉單鏈表java

㈠ 用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;
}
}

㈡ 用Java實現的數據鏈表翻轉程序

publicclassMain{
	staticclassNode<T>{
		Tdata;
		Node<T>next;
		privateNode(Tdata,Node<T>next){
			this.data=data;
			this.next=next;
		}
	}

	publicstaticvoidmain(String[]args){
		Node<Integer>l=newNode<Integer>(null,newNode<Integer>(1,newNode<Integer>(2,newNode<Integer>(3,newNode<Integer>(4,newNode<Integer>(5,null))))));
		Node<Integer>curr=l;
		if(reverseAt(l,3)){
			while((curr=curr.next)!=null)
				System.out.println(curr.data);
		}
	}
	
	@SuppressWarnings("unchecked")
	publicstatic<T>booleanreverseAt(Node<T>h,intp){//hadheadnode
	if(p<1)//invalidposition
	returnfalse
		Object[]l=newObject[p];
		Node<T>curr=h.next;
		for(inti=0;i<p&&curr!=null;i++,curr=curr.next){//save
			l[i]=curr;
		}
		if(curr==null){//pbiggerthanthelistlength;
			returnfalse;
		}
		for(inti=p-1;i>0;i--){//reverse
			((Node<T>)l[i]).next=((Node<T>)l[i-1]);
		}
		((Node<T>)l[0]).next=curr;//link
		h.next=(Node<T>)l[p-1];//head
		returntrue;
	}

}

㈢ 請用C或者Java語言寫出實現將單向鏈表順序反轉的函數。

ListItem* reverseList(ListItem *pHead){
ListItem *p1,*p2;
p1=pHead;
p2=0;
while(p1!=0){
pHead=p1;
p1=p1->next;
pHead->next=p2;
p2=pHead;
}
return pHead;
}

㈣ Java語言寫出實現將單向鏈表順序反轉的函數

假設鏈表的節點定義如下:
class Node{
int i;
Node next;
}
那麼其反轉函數為:

void reverse(Node l){
if(l==null) return;
Node p=null,q=l,r=l.next;
while(r!=null){
q.next=p;
p=q;
q=r;
r=r.next;
}
q.next=p;
l=q;
}

㈤ 數據結構，單鏈表反轉問題，

扣著的是頭節點（頭子）

車是首節點（首子）

馬是次節點（次子）

牙簽細的是指針指向，香頭發黑的是指向，鐵頭細的是指向。

根據步驟寫程序的偽演算法（3步4循環，7張圖片搞定），如下：

第一個循環把馬弄到車前面，

第二個循環把相弄到馬前面

第三個循環把士弄到相前面

........

直到香指向為空後停止循環。

代碼如下：只需要一個首結點pHead,就能把鏈表找到，並倒置。具體代碼如下

p香=pHead->pNext;

p鐵=p香->pNext;

p香->pNext=NULL;

P香=p鐵

while(p香 ！=NULL)

{

p鐵=p香->pNext;

p香->pNext=pHead->pNext;

pHead->pNext=p香；

p香=p鐵；

}

對照偽演算法（三步四循環），和上面的代碼是一一對應的：

第一步：香頭指向首子，鐵頭指向次子

第二步：刪掉首子指向次子（鐵頭所指向的那個子）的牙簽

第三步：香頭跟著鐵頭

以下循環條件：（條件：香頭指向不為空）

{

循環1：鐵頭移動到香頭的下一個指向

循環2：香頭的下一個指向首子

循環3：頭子的下一個跟著香頭

循環4：香頭跟著鐵頭

}

自己用道具操作幾遍，然後把流程背會，以後自己根據流程寫代碼即可。

㈥ java反轉鏈表 大神給我添加個注釋好么，我自己研究

publicclassLinktest{
//反轉方法，傳入一個鏈表
publicstaticLinkNodereversal(LinkNodelist){
//pre用來存放前一個鏈表節點
LinkNodepre=list;
//取出下一個鏈表節點,cru用來存放當前鏈表節點
LinkNodecru=list.getNext();
//next用來存放下一個鏈表節點
LinkNodenext;
//如果當前節點不為空(這里意思是如果傳進來的list有下一個節點就繼續執行)
while(null!=cru){
//取出當前節點的下一個節點
next=cru.getNext();
//把前一個節點賦予當前節點的下一個節點(這里產生實際改變)
cru.setNext(pre);
//把當前節點變數賦予前一個節點的變數
pre=cru;
//把下一個節點變數賦予當前
cru=next;
}
//循環體內會循環到方法傳入的LinkNode沒有前一個節點為止
//因為幾次交換的原因

//因為循環結束,所以把next賦空
list.setNext(null);
//因為循環的原因,前一個節點實際是第一個節點
list=pre;
//返回第一個節點
returnlist;
}
publicstaticvoidmain(String[]args){
LinkNodehead=newLinkNode(0);
LinkNodetmp=null;
LinkNodecur=null;
for(inti=1;i<10;i++){
tmp=newLinkNode(i);
if(1==i){
head.setNext(tmp);
}else{
cur.setNext(tmp);
}
cur=tmp;
}
LinkNodeh=head;
while(null!=h){
System.out.print(h.getVal()+"");
h=h.getNext();
}
head=reversal(head);
System.out.println("
**************************");
//列印反轉後的結果
while(null!=head){
System.out.print(head.getVal()+"");
head=head.getNext();
}
}
}

㈦ 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);
}

㈧ 如何實現單鏈表反轉

將每個結點依次插入新的空鏈表的頭結點和第一個結點之間
假設原鏈表頭結點是H;
typedef struct lnode *link;
link newH;

newH=(lnode *)malloc(sizeof(lnode));
newH->next=NULL;
link q,n;

p=H->next;
while(p!=NULL)
{
q=p;
p=p->next;
if(newH->next==NULL)
{
newH->next=q;
q->next=NULL;

}
else {
newH->next=q;
q->next=n;
}
n=q;
}

㈨ java:已知單鏈表H,利用棧的原理寫一個演算法將其倒置

import myjava.Node;
import myjava.SinglyLinkedList;
import myjava.SeqStack;
public class ReverseLinkedList<E> extends SinglyLinkedList<E> {
public ReverseLinkedList(){
super();
}
public void reverse(ReverseLinkedList<E> list){
SeqStack<E> stack = new SeqStack<E>();
Node<E> p = this.head ;
while(p != null){
stack.push(p.data);
p = p.next;
}
list.clear();
while(!stack.isEmpty()){

list.add(stack.pop());
}
}
public static void main (String[] args) {
ReverseLinkedList<Integer> list = new ReverseLinkedList<Integer>();
for(int i = 1;i < 6;i++){
list.add(0,new Integer(i));
}
System.out.println("單列表 "+list.toString());
list.reverse(list);
System.out.println("逆轉後 "+list.toString());
}
}

㈩ java數據結構，單鏈表的逆置

如圖吧，還是挺好理解的。