反转单链表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数据结构，单链表的逆置

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