正文
java链表反转实例代码 java反转一个链表
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
几种常用的java 实现反转的方法
1.最简单的方法：
public static String reverse1(String str)
{
return new StringBuffer(str).reverse().toString();
}
2.最常用的方法：
public static String reverse3(String s)
{
char[] array = s.toCharArray();
String reverse = ""; //注意这是空串，不是null
for (int i = array.length - 1; i = 0; i--)
reverse += array[i];
return reverse;
}
3.常用方法的变形：
public static String reverse2(String s)
{
int length = s.length();
String reverse = ""; //注意这是空串，不是null
for (int i = 0; i length; i++)
reverse = s.charAt(i) + reverse;//在字符串前面连接， 而非常见的后面
return reverse;
}
4.C语言中常用的方法：
public static String reverse5(String orig)
{
char[] s = orig.toCharArray();
int n = s.length - 1;
int halfLength = n / 2;
for (int i = 0; i = halfLength; i++) {
char temp = s[i];
s[i] = s[n - i];
s[n - i] = temp;
}
return new String(s); //知道 char数组和String相互转化
}
相关问答
Q1: 用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;
}
}
Q2: java反转链表 大神给我添加个注释好么，我自己研究
public class Linktest {
//反转方法 ，传入一个链表
public static LinkNode reversal(LinkNode list){
//pre用来存放前一个链表节点
LinkNode pre =list;
//取出下一个链表节点 ,cru 用来存放当前链表节点
LinkNode cru = list.getNext();
//next用来存放下一个链表节点
LinkNode next;
//如果当前节点不为空(这里意思是 如果传进来的list 有下一个节点就继续执行)
while(null!=cru){
//取出当前节点的下一个节点
next = cru.getNext();
//把前一个节点赋予当前节点的下一个节点(这里产生实际改变)
cru.setNext(pre);
//把当前节点变量赋予前一个节点的变量
pre=cru;
//把下一个节点变量赋予当前
cru = next;
}
//循环体内会循环到方法传入的LinkNode 没有前一个节点为止
//因为几次交换的原因
//因为循环结束,所以把next赋空
list.setNext(null);
//因为循环的原因,前一个节点实际是第一个节点
list=pre;
//返回第一个节点
return list;
}
public static void main(String[] args) {
LinkNode head = new LinkNode(0);
LinkNode tmp = null;
LinkNode cur = null;
for (int i = 1; i 10; i++) {
tmp = new LinkNode(i);
if (1 == i) {
head.setNext(tmp);
} else {
cur.setNext(tmp);
}
cur = tmp;
}
LinkNode h = head;
while (null != h) {
System.out.print(h.getVal() + " ");
h = h.getNext();
}
head = reversal(head);
System.out.println("\n**************************");
//打印反转后的结果
while (null != head) {
System.out.print(head.getVal() + " ");
head = head.getNext();
}
}
}
Q3: 如何链表反转
链表反转
单向链表的反转是一个经常被问到的一个面试题，也是一个非常基础的问题。比如一个链表是这样的： 1-2-3-4-5 通过反转后成为5-4-3-2-1。最容易想到的方法遍历一遍链表，利用一个辅助指针，存储遍历过程中当前指针指向的下一个元素，然后将当前节点元素的指针反转后，利用已经存储的指针往后面继续遍历。源代码如下：
struct linka {
int data;
linka* next;
};
void reverse(linka* head)
{
if(head ==NULL)
return;
linka*pre, *cur, *ne;
pre=head;
cur=head-next;
while(cur)
{
ne = cur-next;
cur-next = pre;
pre = cur;
cur = ne;
}
head-next = NULL;
head = pre;
}
还有一种利用递归的方法。这种方法的基本思想是在反转当前节点之前先调用递归函数反转后续节点。源代码如下。不过这个方法有一个缺点，就是在反转后的最后一个结点会形成一个环，所以必须将函数的返回的节点的next域置为NULL。因为要改变head指针，所以我用了引用。算法的源代码如下：
linka* reverse(linka* p,linka* head)
{
if(p == NULL || p-next == NULL)
{
head=p;
return p;
}
else
{
linka* tmp = reverse(p-next,head);
tmp-next = p;
return p;
}
}
Q4: java linked list里的元素顺序反过来
定义一个LinkedListInteger templist = new LinkedList();来存储list里面java链表反转实例代码的值java链表反转实例代码，通过迭代list，将值插入在templistjava链表反转实例代码的头上，那么templist就是list的反转了，最后将templist赋值给list就行了！
如下代码：
public void reverse() {
LinkedListInteger list = new LinkedList();
LinkedListInteger templist = new LinkedList();
int i = 0;
while (i 6) {
list.add(i);
i++;
}
IteratorInteger it = list.iterator();
int m;
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的实现并没有同步化，如果在多线程应用程序中出现同时访问，而且出现修改操作的时候都要求外部操作同步化java链表反转实例代码；调用Iterator操作获得的Iterator对象在多线程修改Set的时候也自动失效，并抛出java.util.ConcurrentModificationException。这种实现机制是fail-fast，对外部的修改并不能提供任何保证。
Iterator是工作在一个独立的线程中，并且拥有一个 mutex锁，就是说Iterator在工作的时候，是不允许被迭代的对象被改变的。
Iterator被创建的时候，建立了一个内存索引表（单链表），这个索引表指向原来的对象，当原来的对象数量改变的时候，这个索引表的内容没有同步改变，所以当索引指针往下移动的时候，便找不到要迭代的对象，于是产生错误。
List、Set等是动态的，可变对象数量的数据结构，但是Iterator则是单向不可变，只能顺序读取，不能逆序操作的数据结构，当 Iterator指向的原始数据发生变化时，Iterator自己就迷失了方向。
所以如果像下面这么写就会抛出异常java.util.ConcurrentModificationException
：
public void reverse() {
LinkedListInteger list = new LinkedList();
int i = 0;
while (i 6) {
list.add(i);
i++;
}
IteratorInteger it = list.iterator();
int m;
while (it.hasNext() i = 0) {
m = it.next();
list.add(m);
list.remove(0);
i--;
}
System.out.println(list);
}
Q5: c语言，链表的反转，请写出代码，并讲解下，谢了！！！！！
扣着的是头节点（头子）
车是首节点（首子）
马是次节点（次子）
牙签细的是指针指向，香头发黑的是指向，铁头细的是指向。
根据步骤写程序的伪算法（3步4循环，7张图片搞定），如下：
以下是while循环（条件：香头指向不为空）
第一个循环把马弄到车前面，
第二个循环把相弄到马前面
第三个循环把士弄到相前面
........
直到香指向为空后停止循环。
代码如下：只需要一个首结点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链表反转实例代码和java反转一个链表的介绍到此就结束了，不知道你从中找到你需要的信息了吗 ？如果你还想了解更多这方面的信息，记得收藏关注本站。
