Pro5 从头到尾打印链表(java)

注:(1)这里体现了java数据结构与C语言的不同之处

(2)栈的操作直接利用stack进行

 1 package com.xsf.SordForOffer;
 2
 3 import java.util.Stack;
 4
 5
 6 /*
 7  *剑指offer
 8  *pro5 链表逆序输出
 9  * */
10
11 class ListNode{
12     //定义节点
13     int data;
14     ListNode next;
15 }
16
17 //利用栈反向打印
18 class PrintListReverse{
19     //输入一个头结点然后利用栈操作完成逆序输出
20     public void print_reverse(ListNode listNode){
21         Stack<ListNode> stack = new Stack<ListNode>();
22         //将节点入栈
23         while(listNode!=null){
24             stack.push(listNode);
25             listNode = listNode.next;
26         }
27         //节点出栈
28         while(!stack.empty()){
29             System.out.println(stack.pop().data);
30         }
31     }
32
33 }
34 public class Pro5LinklistReverse {
35     public static void main(String[] args) {
36         ListNode node1 = new ListNode();
37         ListNode node2 = new ListNode();
38         ListNode node3 = new ListNode();
39         node1.data = 1;
40         node2.data = 3;
41         node3.data = 5;
42         node1.next = node2;
43         node2.next = node3;
44         PrintListReverse test = new PrintListReverse();
45         test.print_reverse(node1);
46     }
47 }
时间: 2024-08-09 19:50:47

Pro5 从头到尾打印链表(java)的相关文章

Pro5 从头到尾打印链表

思路:利用栈的来实现,而递归本质上就是一个栈结构 1 #include <stdio.h> 2 #include <stdlib.h> 3 4 /* 5 剑指offer 6 Pro5 反转链表输出 7 xsfelvis 8 */ 9 //定义链表的结构类型 10 typedef struct LNode 11 { 12 int data; 13 struct LNode *next; 14 } *Linklist,LNode; 15 16 //打印链表函数 17 void Prin

剑指offer-从尾到头打印链表 java实现

题目描述: 输入一个链表,从尾到头打印链表每个节点的值. 代码实现: /** * public class ListNode { * int val; * ListNode next = null; * * ListNode(int val) { * this.val = val; * } * } * */ import java.util.ArrayList; import java.util.Stack; public class Solution { public ArrayList<In

从头到尾打印链表(剑指offer_6)

题目描述 从尾到头反过来打印出每个结点的值. 解题思路 1.使用递归 要逆序打印链表 1->2->3(3,2,1),可以先逆序打印链表2->3(3,2),最后再打印第一个节点1. 最后再打印第一个节点1. 而链表2->3可以看成一个新的链表,要逆序打印该链表可以继续使用求解函数,也就是在求解函数中调用自己,这就是递归函数. public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { Arr

链表--从头到尾打印链表

从尾到头打印链表 方法一: function printListFromTailToHead(head){//用数组的反转 const stack=[] let node=head while(node){ stack.push(node.val) node=node.next } return stack.reverse() } 方法二:function printListFromTailToHead(head){//用栈的方法 const stack=[] let node=head whi

3.从头到尾打印链表

输入一个链表,按链表从尾到头的顺序返回一个ArrayList. import java.util.Stack; import java.util.ArrayList; public class Solution { public ArrayList<Integer> printListFromTailToHead(ListNode listNode) { Stack<Integer> stack = new Stack<>(); while (listNode != n

面试:用 Java 逆序打印链表

昨天的 Java 实现单例模式 中,我们的双重检验锁机制因为指令重排序问题而引入了 volatile 关键字,不少朋友问我,到底为啥要加 volatile 这个关键字呀,而它,到底又有什么神奇的作用呢? 对 volatile 这个关键字,在昨天的讲解中我们简单说了一下:被 volatile 修饰的共享变量,都会具有下面两个属性: 保证不同线程对该变量操作的内存可见性. 禁止指令重排序. 共享变量:如果一个变量在多个线程的工作内存中都存在副本,那么这个变量就是这几个线程的共享变量. 可见性:一个线

java实现——005从尾到头打印链表

1 import java.util.Stack; 2 public class T005 { 3 public static void main(String[] args){ 4 Node n1 = new Node(1); 5 Node n2 = new Node(2); 6 Node n3 = new Node(3); 7 Node n4 = new Node(4); 8 Node n5 = new Node(5); 9 n1.next = n2; 10 n2.next = n3; 11

剑指Offer-3.从尾到头打印链表(C++/Java)

题目: 输入一个链表,按链表从尾到头的顺序返回一个ArrayList. 分析: 很简单的一道题,其实也就是从尾到头打印链表,题目要求返回ArrayList,其实也就是一个数组. 可以将链表中的元素全部压入栈中,再从栈中依次弹出元素,就可以得到倒序的链表输出. 当然也可以直接将链表中元素传入数组中,最后再翻转数组即可. 程序: C++ //use stack class Solution { public: vector<int> printListFromTailToHead(ListNode

从尾到头打印链表-剑指Offer

从尾到头打印链表 题目描述 输入一个链表,从尾到头打印链表每个节点的值 输入描述 输入为链表的表头 输出描述 输出为需要打印的“新链表”的表头 思路 单向链表是从头到尾指向的,从尾到头打印符合“后进先出”,所以我们使用栈结构Stack 代码 import java.util.ArrayList; import java.util.Stack; public class Solution03 { public ArrayList<Integer> printListFromTailToHead(