• Java实现单链表翻转


    单链表翻转比方有例如以下链表:

         

    须要依照C B A 输出,我们能够有好几种方法:

    package org.andy.test;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * @author andy
     * @version:2015-2-4 上午9:41:12
     * 
     * 
     */
    
    public class LinkedReverse {
    
    	/**
    	 * @param args
    	 */
    	public static void main(String[] args) {
    		// TODO Auto-generated method stub
    		N n = new N();
    		n.name = "A";
    
    		N n1 = new N();
    		n1.name = "B";
    
    		N n2 = new N();
    		n2.name = "C";
    
    		N n3 = new N();
    		n3.name = "D";
    		
    		n1.nextN = n2;
    		n.nextN = n1;
    		n2.nextN = n3;
    		N old = n;
    		while (old != null) {
    			System.out.println(old.name);
    			old = old.nextN;
    		}
    
    		System.out.println("链表翻转1");
    		N new1 = reverseOne(n);
    		while (new1 != null) {
    			System.out.println(new1.name);
    			new1 = new1.nextN;
    		}
    
    		/*
    		System.out.println("链表翻转2");
    		N new2 = reverseTwo(n, null);
    		while (new2 != null) {
    			System.out.println(new2.name);
    			new2 = new2.nextN;
    		}
    
    		System.out.println("链表翻转3");
    		N new3 = reverseThree(n);
    		while (new3 != null) {
    			System.out.println(new3.name);
    			new3 = new3.nextN;
    		}
    		
    		*/
    	}
    
    	//採用交换前后值
    	public static N reverseOne(N n) {
    		if (n != null) {
    			N preN = n; //前一个节点
    			N curN = n.nextN; //当前节点
    			N nextN ;   //后一个节点
    			while (null != curN) {
    				nextN = curN.nextN;
    				curN.nextN = preN;
    				preN = curN;
    				curN = nextN;
    			}
    			
    			n.nextN = null;
    			n = preN;
    			
    			return n;
    			
    		}
    		return null;
    	}
    
    	//採用递归实现
    	public static N reverseTwo(N n, N newN) {
    		// 採用递归 返回 返回条件是最后一个几点nextN为空
    		if (n == null) {
    			return newN;
    		}
    
    		N nextN = n.nextN;
    		n.nextN = newN;
    		return reverseTwo(nextN, n);
    	}
    
    	//最烂的实现方式
    	public static N reverseThree(N n) {
    		if (n == null) {
    			return null;
    		}
    		// 定义一个集合 。放在集合里面在单个反向指回
    		List<N> nList = new ArrayList<N>();
    		N p = n;
    		while (p != null) {
    			N node = new N();// 当前节点
    			node.name = p.name;
    			nList.add(node);
    			p = p.nextN;
    		}
    
    		// 在返现输出节点
    		n = null;
    		for (N rn : nList) {
    			if (n != null) {
    				// 假设n不为空时
    				rn.nextN = n;
    			}
    			n = rn;
    		}
    
    		return n;
    	}
    
    }
    
    // 定义一个节点
    class N {
    	public String name;
    	public N nextN;
    }
    


  • 相关阅读:
    面对复杂业务,if-else coder 如何升级?
    为什么StringBuilder是线程不安全的?
    Hashmap中文解释
    mysql 5.6 5.7 8.0新特性
    数据增强,扩充数据集
    神经网络参数优化器
    缓解过拟合
    损失函数
    神经网络的复杂度&指数衰减学习率&激活函数
    GRU&实例股价预测
  • 原文地址:https://www.cnblogs.com/yangykaifa/p/6698784.html
Copyright © 2020-2023  润新知