代码编织梦想

从尾到头打印链表,解法一:借助栈

public ArrayList<Integer> printListFromTailToHead(ListNode listNode){
		ArrayList<Integer> list=new ArrayList<>();
		Stack<ListNode>stack=new Stack<>();
		while(head!=null){
			stack.push(head);
			head=head.next;
		}
		while(!stack.empty()){
			list.add(stack.pop().val);
		}
		return list;
	}

解法二:递归

public  ArrayList<Integer> printListReverse2(ListNode headNode){
		ArrayList<Integer> list=new ArrayList<>();
		if(headNode!=null){
			if(headNode.next!=null){
				list=printListReverse2(headNode.next);
			}
			list.add(headNode.val);
		}
		return list;
	}

完整代码如下,其中包含了添加节点的方法add()方法、基本打印节点的方法list(),替换空格的方法replaceSpace()和其他无关方法和本章节没有关系,可以删去。

package www.it.com;

import java.util.ArrayList;
import java.util.List;
import java.util.Stack;

public class ReplaceSpace {
	
	public ListNode head=new ListNode(0);
	//替换字符串中的空格
	public static String replaceSpace(StringBuffer str){
		if(str==null)
			return null;
		StringBuilder sb=new StringBuilder();
		for(int i=0;i<str.length();i++){
			if(String.valueOf(str.charAt(i)).equals(" ")){
				sb.append("20%");
			}
			else{
				sb.append(str.charAt(i));
			}
		}
		return String.valueOf(sb);
	}
	//从尾到头打印链表,解法一:借助栈
	public ArrayList<Integer> printListFromTailToHead(ListNode listNode){
		ArrayList<Integer> list=new ArrayList<>();
		Stack<ListNode>stack=new Stack<>();
		while(head!=null){
			stack.push(head);
			head=head.next;
		}
		while(!stack.empty()){
			list.add(stack.pop().val);
		}
		return list;
	}
	//从尾到头打印链表,解法一:借助栈2
	public int[] reversePrint(ListNode head) {
        if(head == null){
            return new int[0];
        }
        Stack<Integer> stack = new Stack();
        while(head.next!= null){
            stack.push(head.val);
            head = head.next;
        }
        stack.push(head.val);//注意这句
        //while(head!= null){
        //    stack.push(head.val);
        //    head = head.next;
        //}
        //stack.push(head.val);//注意这句
        int[] res = new int[stack.size()];
        int i = 0;
        while(!stack.isEmpty()){
            res[i++] = stack.pop();
        }
        return res;
    }
	
	//解法二:递归
	public  ArrayList<Integer> printListReverse2(ListNode headNode){
		ArrayList<Integer> list=new ArrayList<>();
		if(headNode!=null){
			if(headNode.next!=null){
				list=printListReverse2(headNode.next);
			}
			list.add(headNode.val);
		}
		return list;
	}
	
public void add(ListNode listNode){
		
		ListNode temp=head;
		while(true){
			if(temp.next==null){
				break;
			}
			temp=temp.next;
		}
		temp.next=listNode;
	}
	
	public void list(){
		if(head.next==null){
			System.out.println("链表为空");
			return;
		}
		ListNode temp=head.next;
		while(true){
			if(temp==null){
				break;
			}
			//输出节点信息
			System.out.println(temp);
			temp=temp.next;
		}
	}
	
	public static void main(String[] args) {
//		1、替换字符串中的空格
//		StringBuffer sb=new StringBuffer("We Are Happy");
//		String s=replaceSpace(sb);
//		System.out.println(s);
		
//		2、从尾到头打印链表,解法一:借助
		ListNode l1=new ListNode(1);
		ListNode l2=new ListNode(2);
		ListNode l3=new ListNode(3);
		ListNode l4=new ListNode(4);
		ListNode l5=new ListNode(5);
		ListNode l6=new ListNode(6);
		ListNode l7=new ListNode(7);
		ListNode l8=new ListNode(8);
		ReplaceSpace rs=new ReplaceSpace();
		rs.add(l1);
		rs.add(l2);
		rs.add(l3);
		rs.add(l4);
		rs.add(l5);
		rs.add(l6);
		rs.add(l7);
		rs.add(l8);
		rs.list();
		System.out.println("---------------------------");
		ArrayList<Integer> list=rs.printListReverse2(l1);
		//使用栈完成倒置时,i到list.size()结束,不打印头结点。
		for(int i = 0;i < list.size(); i ++){
			System.out.println(list.get(i));
			}
//		int[] s=rs.reversePrint(l1);
//		for(int i=0;i<s.length;i++){
//			System.out.println(s[i]);
//		}
		
		
	}
	
}
 class ListNode{
	int val;
	public int getVal() {
		return val;
	}
	public void setVal(int val) {
		this.val = val;
	}
	ListNode next;
	
	public ListNode(int val){
		this.val=val;
	}
	
	@Override
	public String toString() {
		return "ListNode [val=" + val + "]";
	}
	
	
}

版权声明:本文为博主原创文章,遵循 CC 4.0 BY-SA 版权协议,转载请附上原文出处链接和本声明。
本文链接:https://blog.csdn.net/qq_38268534/article/details/118802540

从尾到头打印链表(java)_不贰过先生的博客-爱代码爱编程

题目: 输入一个链表的头结点,从尾到头反过来打印出每个结点的值。 链表的结点定义如下: struct ListNode{ int m_nKey; ListNode* m_pNext; } 第一思路: 我的第一思路是从头到尾输出类比数组那样,于是乎想把链表中的链表结点的指针反转过来,改变链表的方向,然后实现从头到尾输出(结果为从尾到头输出),可是发现修改

从尾到头打印链表 java_小小白的成长之路的博客-爱代码爱编程

从尾到头打印链表 java 题目描述 输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。 代码1:推荐 /** * public class ListNode { * int

剑指offer-从尾到头打印链表_lee_jiaqi的博客-爱代码爱编程

输入一个链表,按链表值从尾到头的顺序返回一个ArrayList。 解题思路: 通常打印一个只读操作不希望打印时修改内容。题目要求从尾到头打印列表值,这里一定要遍历链表,遍历列表是从头到尾,而输出顺序是从尾到头,自然而然想到

C语言:从尾到头打印链表-爱代码爱编程

双12买了本《剑指offer》,里面好多题目之前都做过,但仅限于做出来,当时没有思考太多,很多都是直接调类(用的java)。今天开始重新学习,想着用C再实现一遍,这次要考虑更深层的东西,比如时间复杂度这些。 言归正传,再次学习还是从链表开始,第一道关于链表的题目是从尾到头打印链表。看到这道题,我第一反应想的是:把链表反转,然后再依次输出每个结点的值就好了

递归算法:从尾到头打印链表-爱代码爱编程

题目链接 https://www.nowcoder.com/practice/d0267f7f55b3412ba93bd35cfa8e8035?tpId=13&tags=&title=&diffculty=0&judgeStatus=0&rp=1&ru=/ta/coding-interviews&q

链表-从尾到头打印链表C++-爱代码爱编程

题目 面试题6:从尾到头打印链表 题目:输入一个链表的头结点,从尾到头反过来打印出每个结点的值。 代码 /// LeetXodeTest.cpp : 定义控制台应用程序的入口点。 #include "stdafx.h" #include <iostream> #include <vector> #include<ar

Leetcode从尾到头打印链表-爱代码爱编程

文章目录 从尾到头打印链表题目描述示例具体代码1.利用栈2.利用reverse函数3.改变链表结构 从尾到头打印链表 题目描述 输入一个链表的头节点,从尾到头反过来返回每个节点的值(用数组返回)。 示例 输入:head = [1,3,2] 输出:[2,3,1] 具体代码 1.利用栈 代码如下(示例): class Solutio

c语言从尾到头输出链表,c语言程序设计习题之从尾到头打印链表-爱代码爱编程

c语言程序设计习题之从尾到头打印链表。c++链表应用实例。 题目来自剑指Offer c++算法题目:输入一个链表的头结点,从头到尾反过来打印出每个结点的值。 c++练习代码实例: #include #include using namespace std; struct LinkNode { int m_Data; struct

JZ3 从尾到头打印链表 python-爱代码爱编程

JZ3 从尾到头打印链表 my version出错记录 链表无法用索引标记ListNode[i]的写法是错误的# -*- coding:utf-8 -*- class ListNode: def __init__(self, x): self.val = x self.next = None class Sol

JZ6 从尾到头打印链表-爱代码爱编程

剑指offer 数据结构–链表 描述 输入一个链表的头节点,按链表从尾到头的顺序返回每个节点的值(用数组返回)。 如输入{1,2,3}的链表如下图: 返回一个数组为[3,2,1] 0 <= 链表长度 <= 10000 示例1 输入: {1,2,3} 返回值: [3,2,1] 解法: 方法一: 首先想到是从尾到头打印,

JZ6 从尾到头打印链表(简单)-爱代码爱编程

描述 输入一个链表的头节点,按链表从尾到头的顺序返回每个节点的值(用数组返回)。 如输入{1,2,3}的链表如下图:   返回一个数组为[3,2,1] 0 <= 链表长度 <= 10000 示例1 输入:{1,2,3} 返回值:[3,2,1] 示例2 输入:{67,0,24,58} 返回值:[5

javaSE---string-爱代码爱编程

目录 字符串类型 定义字符串 String 1、String类被final修饰,这个类不能被继承​ 2、String的底层实现 常量池 1.Class文件常量池《在磁盘上》 2.运行时常量池《在方法区》 3.字符串常量池《在堆区》 哈希表 底层实现 直接赋值:创建一次对象  使用new关键字:创建两次对象  +拼接 手动入

【LeetCode - Java】190. 颠倒二进制位 (简单)-爱代码爱编程

目录 1. 题目描述2. 解题思路3. 代码实现3.1 数值运算(C语言版)3.2 数值运算3.3 二进制运算逐位逆转3.3 对比 1. 题目描述 2. 解题思路 题目明确这是二进制位的运算,那么我们就得从常数转换为二进制入手。最常规的方法,把常数除二取余然后直接乘对应的位权,完事了。对于C语言来说,确实是这样子的,因为在C语言当中有无

Spring Boot集成Sharding-JDBC实现数据分表+读写分离(三)-爱代码爱编程

分享之前先参考:数据分离数据源配置 今天紧接着分享数据分表和读写分离,也是我们常用的业务场景之一: 1、相关jar包和三个数据源同上一篇保持一致: 2、相关建表语句/实体类/mapper/xml配置:  2.1、建表语句: CREATE TABLE `tbl_user0` ( `id` bigint(20) NOT NULL AUTO_I

微服务架构 | 5. 服务容灾_基于微服务的容灾机房设计-爱代码爱编程

5. 服务容灾 前言1. 服务容灾基础知识1.1 由一个服务资源耗尽引发的连锁反应1.2 服务雪崩效应1.3 四种客户端弹性模式1.4 服务容灾的几种解决方案1.5 服务降级的参考指标1.6 服务限流的作用1.