精华内容
下载资源
问答
  • Java实现单向链表反转

    2020-08-27 21:30:19
    主要为大家详细介绍了Java实现单向链表反转,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • javaJava实现单向链表反转.pdf
  • JAVA实现单向链表反转

    千次阅读 2013-06-04 03:11:23
    上一篇《Java实现单向链表反转》中存在一个last是从前往后反转的。本片文章要实现的是从后往前反转。大体思路差不多。就是在临时变量.cur,pre的替换保存花费了些心思。整理一下一下,下面是可运行的Java代码。 ...

    《单向链表反转》
    最近正在面试,求职Android应用方向的工作。基础知识还可以,但是算法,呵呵。做手机客户端的基本涉及算法不多,大多是架构设计,解耦,以及功能优化,UI,IO等。好了废话不多说。进入正题!

    单向链表,你懂得。再此不多做解释。单向链表的反转,时间复杂度,空间复杂度低一些才是好算法吗。基本目前是做到了O(n).思路就是,声明三个引用pre,cur,tempNext,pre,cur分别指向第一个元素和第二个元素。tempNext存住第三个元素的引用。反转前两个,p2---->p1 (注意此时p2.next 已断开)需要原来指向第二个的引用指向第三个,既pre,cur移动到p2,p3 ,也就是pre 引用p2, cur引用p3 .跟第一次pre,cur分别指向p1,p2类似,如此往复下去.
    需要注意的几点,
    1 本身JAVA代码,需要注意Java是值传递还是引用传递。如果不注意的话,变量交换就会有问题。真的,亲!
    2 各种临时变量的记录。不要绕晕了。同时也要注意上一点。 



    上代码!!!自己写的,可运行。

    </pre><pre name="code" class="java">package com.main;
    
    public class Main  {
    
    	public static void main(String[] args) {
    		String [] str={"11","2","45","67","23","44","55","89","74","10"};
    		
    		RevertListfromHead rl= new RevertListfromHead(str);
    
    	}
    
    }
    package com.main;
    
    public class RevertListfromHead {
    	
    	
    	public RevertListfromHead(String[] str) {
    
    		MyLinkList mList = new MyLinkList(str);
    
    		mList.printList(mList.head);
    
            System.out.println("--------------------------");
    		System.out.println("after revert list is ");
    
    		mList.head=mList.revertLinkedList(mList.head);
    		mList.printList(mList.head);
    	}
    	
    	class MyLinkList {
    		private Node head;
    
    
    		private int mlength; 
    
    		public MyLinkList(String[] str) {
    
    			head = new Node(str[0]);
    			Node currentNode = head;
    			for (int i = 1; i < str.length; i++) {
    
    				currentNode.next = new Node(str[i]);
    
    				currentNode = currentNode.next;
    				
    			}
    			mlength = str.length;
    		}
    
    		public Node revertLinkedList(Node _head) {
    
    			int sum=0;
    			if (null == _head) {   
    	            return head;   
    	        }   
    	        Node pre = _head;   
    	        Node cur = _head.next;   
    	        Node tempnext;   
    	        while (null != cur) {   
    	        	tempnext = cur.next;   
    	            cur.next=pre;   
    	            pre = cur;   
    	            cur = tempnext;  
    	            sum++;
    	        }   
    	        //将原链表的头节点的下一个节点置为null,再将反转后的头节点赋给head      
    	        head.next=null;   
    	        head = pre;   
    	        
    	        return head;   
    	}
    
    	public void printList(Node _head) {
    			Node tempNode = _head;
    			while (tempNode != null) {
    				System.out.println("current data is : " + tempNode.data);
    				tempNode = tempNode.next;
    			}
    		}
    
    	}
    
    	static class Node {
    		String data;
    		Node next;
    
    		public Node(String _data) {
    			this.data = _data;
    		}
    	}
    
    }
    展开全文
  • java实现单向链表反转

    2019-09-18 09:51:49
    //将原链表的头节点的下一个节点置为null,再将反转后的头节点赋给head     head.next= null ;   head = pre;      return  head;   }    ...
    1. package com.main;  
    2.   
    3.   
    4.   
    5. public class Main  {  
    6.   
    7.     public static void main(String[] args) {  
    8.         String [] str={"11","2","45","67","23","44","55","89","74","10"};  
    9.           
    10.         RevertListfromHead rl= new RevertListfromHead(str);  
    11.   
    12.     }  
    13.   
    14. }  
    15. package com.main;  
    16.   
    17. public class RevertListfromHead {  
    18.       
    19.       
    20.     public RevertListfromHead(String[] str) {  
    21.   
    22.         MyLinkList mList = new MyLinkList(str);  
    23.   
    24.         mList.printList(mList.head);  
    25.   
    26.         System.out.println("--------------------------");  
    27.         System.out.println("after revert list is ");  
    28.   
    29.         mList.head=mList.revertLinkedList(mList.head);  
    30.         mList.printList(mList.head);  
    31.     }  
    32.       
    33.     class MyLinkList {  
    34.         private Node head;  
    35.   
    36.   
    37.         private int mlength;   
    38.   
    39.         public MyLinkList(String[] str) {  
    40.   
    41.             head = new Node(str[0]);  
    42.             Node currentNode = head;  
    43.             for (int i = 1; i < str.length; i++) {  
    44.   
    45.                 currentNode.next = new Node(str[i]);  
    46.   
    47.                 currentNode = currentNode.next;  
    48.                   
    49.             }  
    50.             mlength = str.length;  
    51.         }  
    52.   
    53.         public Node revertLinkedList(Node _head) {  
    54.   
    55.             int sum=0;  
    56.             if (null == _head) {     
    57.                 return head;     
    58.             }     
    59.             Node pre = _head;     
    60.             Node cur = _head.next;     
    61.             Node tempnext;     
    62.             while (null != cur) {     
    63.                 tempnext = cur.next;     
    64.                 cur.next=pre;     
    65.                 pre = cur;     
    66.                 cur = tempnext;    
    67.                 sum++;  
    68.             }     
    69.             //将原链表的头节点的下一个节点置为null,再将反转后的头节点赋给head        
    70.             head.next=null;     
    71.             head = pre;     
    72.               
    73.             return head;     
    74.     }  
    75.   
    76.     public void printList(Node _head) {  
    77.             Node tempNode = _head;  
    78.             while (tempNode != null) {  
    79.                 System.out.println("current data is : " + tempNode.data);  
    80.                 tempNode = tempNode.next;  
    81.             }  
    82.         }  
    83.   
    84.     }  
    85.   
    86.     static class Node {  
    87.         String data;  
    88.         Node next;  
    89.   
    90.         public Node(String _data) {  
    91.             this.data = _data;  
    92.         }  
    93.     }  
    94.   
    95. }  

    转载于:https://my.oschina.net/u/1270794/blog/165004

    展开全文
  • Java实现单向链表反转示例

    千次阅读 2019-02-15 12:52:11
    例如有一单向链表 54-&gt;30-&gt;37-&gt;61-&gt;1-&gt;60-&gt;25-&gt;76-&gt;60-&gt;95 原链表头节点54,尾节点:95 实现效果: 95-&gt;60-&gt;76-&gt;25-&gt;...

    例如有一单向链表
    54->30->37->61->1->60->25->76->60->95
    原链表头节点54,尾节点:95

    实现效果:
    95->60->76->25->60->1->61->37->30->54
    新链表头节点95,尾节点54

    实现原理:
    从头节点开始遍历整个链表,对每个节点指向的前后节点引用进行交换,最后设置头节点和尾节点

    Java类:
    Node.java 节点对象,包含节点本身属性及方法
    NodeList.java 链表操作类,记录链表头节点和尾节点,操作链表例如链表追加,链表反转等方法
    TestNode.java 测试类

    实现代码:

    package demo;
    /**
     * 节点实体类
     * @author sunlh
     *
     */
    public class Node {
    
    	private Node pre;// 上一个节点
    	
    	private Node next;// 下一个节点
    	
    	private int data;// 数据
    	
    	public Node(int data) {
    		this.data = data;
    	}
    
    	public void append(Node node) {
    		if (this.next == null) {
    			this.next = node;
    			node.pre = this;
    		} else {
    			this.next.append(node);
    		}
    		
    	}
    		
    	public Node getPre() {
    		return pre;
    	}
    
    	public void setPre(Node pre) {
    		this.pre = pre;
    	}
    
    	public Node getNext() {
    		return next;
    	}
    
    	public void setNext(Node next) {
    		this.next = next;
    	}
    
    	public void setData(int data) {
    		this.data = data;
    	}
    
    	public boolean hasPre() {
    		return this.pre != null;
    	}
    	
    	public boolean hasNext() {
    		return this.next != null;
    	}
    	
    	public int getData() {
    		return data;
    	}
    }
    
    package demo;
    
    public class NodeList {
    	
    	Node head;
    	Node last;
    	
    	/**
    	 * 追加
    	 * @param node
    	 */
    	public void append(Node node) {
    		if (head.getNext() == null) {
    			head.setNext(node);
    			node.setPre(head);
    		} else {
    			head.getNext().append(node);
    		}	
    	}
    	
    	/**
    	 * 遍历 
    	 */
    	public String toString() {
    		Node curr = head;
    		StringBuilder sBuilder = new StringBuilder();
    		while (curr != null) {
    			sBuilder.append(curr.getData()).append(curr.hasNext() ? "->" : "");
    			curr = curr.getNext();
    		}
    		return sBuilder.toString();
    	}
    	
    	/**
    	 * 倒置反转
    	 */
    	public String reverse() {
    		Node curr = head;
    		Node newHead = null;
    		Node newLast = null;
    		while (curr != null) {
    			Node pre = curr.getPre();
    			Node next = curr.getNext();
    			if (pre == null) newLast = curr; // 前一个节点为空,作为新的尾节点
    			if (next == null) newHead = curr;// 后一个节点为空,作为新的头节点
    			curr.setNext(pre);// 当前节点的下一个节点作为当前节点的上一个节点
    			curr.setPre(next);// 当前节点的上一个节点作为当前节点的下一个节点
    			curr = curr.getPre();// 继续处理原链表节点的下一个节点
    		}
    		head = newHead;// 设置头节点
    		last = newLast;// 设置尾节点
    		return this.toString();
    	}
    }
    
    package demo;
    
    public class TestNode {
    	
    	public static void main(String[] args) throws InterruptedException {
    		NodeList list = new NodeList();
    		System.out.println("构造长度为10的双向链表");
    		for (int i = 0; i < 10; i++) {
    			int r = (int)(Math.random() * 100);
    			Node node = new Node(r);
    			if (i == 0) {
    				list.head = node;// 头节点
    			} else {
    				list.head.append(node);
    			}
    			list.last = node;// 尾节点
    		}
    		
    		// 遍历
    		System.out.println(list.toString());
    		
    		// 倒置反转
    		System.out.println(list.reverse());
    		
    	}
    }
    

    结果输出:

    构造长度为10的双向链表
    38->74->40->81->77->34->91->93->92->0
    0->92->93->91->34->77->81->40->74->38
    
    展开全文
  • 2.1 实现思路 递归:从尾部开始处理 非递归:从头部开始处理 2.2 实现 package com.algorithm.common.link.reverse; /** * @author: chuanchuan.lcc * @date: 2021-06-03 22:50 * @modifiedBy: chuanchuan.lcc...

    在这里插入图片描述

    1.概述

    转载:https://www.jb51.net/article/136185.htm

    遇到了这个问题,记录一下

    2.案例1

    2.1 实现思路

    递归:从尾部开始处理

    在这里插入图片描述
    非递归:从头部开始处理

    在这里插入图片描述

    展开全文
  • JAVA 实现带头结点的链表根据节点大小按顺序新增、修改、删除节点该文章已实现单向链表的创建及遍历等操作。 那么在此基础上,如何实现单向链表反转呢? 实现思路: 1. 先定义一个节点 reverseHead = new ...
  • 使用Java实现单向链表,并完成链表反转。 算法和数据结构是程序员逃不过的一个坎,所以趁着闲余时间,开始学习基础的算法和数据结构。这里记录下自己实现简单的单项链表的过程,如有错误,敬请指正。 明确需求 在...
  • package node; import ... import java.util.Stack; public class model { private node head=new node(1,“aa”); public StacknodeStack=new Stack<>(); //添加...
  • Java单向链表反转

    2021-09-01 14:09:59
    单向链表反转就是将链表的指针方向改变。由于单链表没有指向前一个结点的指针,所以,我们定义一个指向前一个节点的指针pre,用于存储每一个节点的前一个结点;定义一个保存当前节点的指针cur以及下一个节点指针的...
  • private class LIterator implements java.util.Iterator{ private LinkList.Node n; public LIterator() { this.n = head; } @Override public boolean hasNext() { return n.next!=null; }...
  • 思路很简单,就是从第二个节点开始,把每个节点都插入到头节点之后。 需要两个临时变量存储每次循环状态下第一个节点...//反转链表 public void reverse(){ HeroNode temp = head; if (temp.next==null){ System.ou
  • 下面的程序示例演示了如何构建链表节点,向单向链表插入节点、删除节点、反转单向链表和串联两个单向链表:import java.io.BufferedReader; import java.io.IOException; import java.io.InputSt...
  • java实现单向链表

    2019-12-23 10:00:38
    java实现的链表,包含常用的方法,例如: add(); 添加 add(Object o,int index); 指定位置添加 remove(); 删除 ... 链表反转 package link; import java.util.Iterator; import java.util.NoSuch...
  • Java实现单向链表

    2017-09-04 18:01:00
    Java实现链表的思想可以参考 ...下面实现几点关于单向链表的一些操作: 1 public class LinkList<E> { 2 private Node<E> first; 3 private Node<E> last; 4 private int size; 5 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 5,098
精华内容 2,039
关键字:

java实现单向链表反转

java 订阅