精华内容
下载资源
问答
  • // 打印之后的链表 System.out.println("反转之后的链表为:"); resNode.print(); } public static LinkedNode reverseList(LinkedNode node) { // 如果为空链表或者只有一个节点的链表则不需要处理 if (node == ...

    public class LinkedNode {

    Integer id;

    LinkedNode next;

    public LinkedNode(Integer id) {

    this.id = id;

    }

    // 打印链表

    public void print(){

    System.out.print(this.id);

    if (this.next != null) {

    System.out.print("->");

    this.next.print();

    } else {

    System.out.println();

    }

    }

    }

    public class TestLinkedNode {

    public static void main(String[] args) {

    LinkedNode node1 = new LinkedNode(1);

    LinkedNode node2 = new LinkedNode(2);

    LinkedNode node3 = new LinkedNode(3);

    LinkedNode node4 = new LinkedNode(4);

    LinkedNode node5 = new LinkedNode(5);

    node1.next = node2;

    node2.next = node3;

    node3.next = node4;

    node4.next = node5;

    // 打印链表

    System.out.println("链表:");

    node1.print();

    LinkedNode resNode = reverseList(node1);

    // 打印之后的链表

    System.out.println("反转之后的链表为:");

    resNode.print();

    }

    public static LinkedNode reverseList(LinkedNode node) {

    // 如果为空链表或者只有一个节点的链表则不需要处理

    if (node == null || node.next == null) {

    return node;

    }

    // 声明当前节点,前继节点和后继节点

    LinkedNode cur = node;

    LinkedNode pre = null;

    LinkedNode temp = null;

    while (cur != null) {

    // 先将当前节点的后继节点存起来,因为这个值稍后会改变

    temp = cur.next;

    // 翻转,将当前节点的后继节点设为前继节点

    cur.next = pre;

    // 移动指针下一个前继承节点就是当前节点

    pre = cur;

    cur = temp;

    }

    return pre;

    }

    }

    运行结果:

    链表:

    1->2->3->4->5

    反转之后的链表为:

    5->4->3->2->1

    来源:https://www.cnblogs.com/gaopengpy/p/12288822.html

    展开全文
  • 刷leetcode基础题的时候用到了单链表的反转,记录一下反转方法,并用Java语言实现。 提示:以下是本篇文章正文内容,下面案例可供参考 一、单链表结构 首先要明确 单链表节点的构成,一般来说节点包括两个域: ...

    文章目录

    • 前言
    • 一、链表结构
    • 一、单链表反转(从前到后遍历)效率高,推荐
    • 二、单链表反转(利用栈)
    • 三、单链表反转(利用递归)难理解,可以学习学习
    • 总结

     


    前言

    刷leetcode基础题的时候用到了单链表的反转,记录一下反转方法,并用Java语言实现。


    提示:以下是本篇文章正文内容,下面案例可供参考

    一、单链表结构

    1. 首先要明确 单链表节点的构成,一般来说节点包括两个域:
    2. 数据域data,   指针域next.。
    3. 数据域用来存储当前节点的数据值,指针域用来存储当前指针指向的内容。

    二、单链表反转(从前到后遍历)效率高、推荐

    1. 基本思路:
      1. 链表的反转关键就是让指针域进行变更,
      2. 初始状态:结点Null→A→B→C→Null 
      3. 需要调整为:结点Null←A←B←C←Null.
      4. 因为最开始是从A开始,所以需要先定义一个链表类型的节点 prev,用于存储当前节点的前置节点。
      5. 再定义一个链表类型的节点next,用来临时存储当前节点的下一个节点。
      6. 最后return prev结点,因为结点之间有指针链接,所以会输出反转后的链表。
    2. 具体实现(Java):
      public ListNode reverse(ListNode head){
          ListNode prev = null;//定义一个前置结点。
          while(head != null){
              //这里要把next放在这里定义,不提前的原因是需要先满足head!= null的条件。
              ListNode next = head.next;
              head.next = prev;//调整指针域,让结点指向前置结点。
              //为下一次做准备
              prev = head;
              head = next;
          }
          return prev;
      }
      /*单链表的定义 Definition for singly-linked list*/
      public class ListNode {
            int val;
            ListNode next;
            ListNode() {}
            ListNode(int val) { this.val = val; }
            ListNode(int val, ListNode next) { this.val = val; this.next = next; }
      }

       

    三、单链表反转(利用栈)内存消耗高,不推荐

    1. 基本思路:
      1. 链表的反转关键就是让指针域进行变更,
      2. 初始状态:结点Null→A→B→C→Null 
      3. 需要调整为:结点Null←A←B←C←Null.
      4. 那么考虑借助栈后进先出的结构特点,每次读取一个结点入栈,最后统一出栈构建新的单链表。
      5. 得到的单链表即为原始单链表的反转。
    2. 具体实现(Java):
      /*单链表的定义 Definition for singly-linked list*/
      public class ListNode {
            int val;
            ListNode next;
            ListNode() {}
            ListNode(int val) { this.val = val; }
            ListNode(int val, ListNode next) { this.val = val; this.next = next; }
      }
      public ListNode reverse(ListNode head){
          Stack<Integer> stack = new Stack<>();
          ListNode node = head;
          ListNode prev = null;
          //单链表结点入栈
          while(node != null){
              stack.push(node.val);
              node = node.next;
          }
          //栈中结点出栈构建新的单链表
          while(stack.pop() != null){
              prev.val = stack.pop();
              prev = prev.next;
          }
          return prev;
      }

       

    四、单链表反转(利用递归)也不咋地,不推荐,但是不太好理解,可以学习学习。

    1. 基本思路:
      1. 链表的反转关键就是让指针域进行变更,
      2. 初始状态:结点Null→A→B→C→Null 
      3. 需要调整为:结点Null←A←B←C←Null.
      4. 那么我们用递归方法,就是让在调整第一个链表的结点的指针域之前,先反转后续结点。
      5. 层层深入,直至到尾结点为止才开始链表的反转。
      6. 最后给出反转后的单链表。
    2. 具体实现(Java):
      /*单链表的定义 Definition for singly-linked list*/
      public class ListNode {
            int val;
            ListNode next;
            ListNode() {}
            ListNode(int val) { this.val = val; }
            ListNode(int val, ListNode next) { this.val = val; this.next = next; }
      }
      //利用递归反转单链表
      public ListNode reverse(ListNode head){
          //判断边界情况
          if(head == null || head.next == null)
              return head;
          
          ListNode temp = head.next;//定义链表结点temp暂存当前节点(也就是第一个结点)的指针域。   
          
          ListNode newHead = reverse(head.next);  //对链表进行递归反转。递归就体现在这里 
          
          //这两步属于善后工作。
          temp.next = head;  //调整结点的指针域指向初始第一个结点。
          head.next = null;  //初始第一个结点指向null.
          
          return newHead;  //输出反转后的单链表。
      }

       


    总结

    以上,就是总结的内容。推荐使用第一种反转链表,递归法可以多看看,有利于理解递归思想。

    展开全文
  • 给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。 如果反转后整数超过 32 位的有符号整数的范围[−231,231− 1] ,就返回 0。 (这里是2的31次方) 假设环境不允许存储 64 位整数(有符号或...

    目录

    题目

    思路1:

    结果1:

    思路2:

    结果2:


    题目

    给你一个 32 位的有符号整数 x ,返回将 x 中的数字部分反转后的结果。

    如果反转后整数超过 32 位的有符号整数的范围 [−231,  231 − 1] ,就返回 0。

    (这里是2的31次方)

    假设环境不允许存储 64 位整数(有符号或无符号)。
     

    示例 1:

    输入:x = 123
    输出:321
    示例 2:

    输入:x = -123
    输出:-321
    示例 3:

    输入:x = 120
    输出:21
    示例 4:

    输入:x = 0
    输出:0
    提示:

    -231 <= x <= 231 - 1

    思路1:

    通过数学计算:

    1.对x(输入值)取余获得最后一位pop,使x除10来删除x的最后一位(我在前面的博客有解释,这里就直接说结论了)。

    2.result=result*10+pop,就是让result前移一位,加上个位的pop

    3.在result生成之前要判断这个数是否超范围,因为int类型的数如果超范围,就会根据二进制码删去前面超的部分,出现错误,所以要先判断。(判断思路就是先比较前一位,在比较最后一位)

    下面直接上代码:

    package LeetCode;
    
    public class ZhengShuFanZhuan2 {
        public static void main(String[] args) {
            System.out.println(reverse(-1253424759));
        }
        public static int reverse(int x) {
            int result=0;
            for(int pop=0;x!=0;x/=10){
                pop=x%10;
                if(result<Integer.MIN_VALUE/10||(result==Integer.MIN_VALUE/10&&pop<Integer.MIN_VALUE%10)
                        ||result>Integer.MAX_VALUE/10||(result==Integer.MAX_VALUE/10&&pop>Integer.MAX_VALUE%10)) {
                    return 0;
                }
                result = result * 10 + pop;
            }
            return result;
        }
    }

    结果1:

    思路2:

     通过字符串反转:这个方法的时间空间消耗都远大于上面的方法,在这道题使用是不合适的,不过这种方法还是比较重要的。

    1.先将x转化为字符串,初始化一个flag变量记录x是否为负数。

    2.反转字符串,创建一个StringBuilder,然后从后往前变量x得到的字符串并接入StringBuilder;这里也可以利用栈先进后出的性质,全压栈在全出栈(注释掉部分)

    3.判断临界,这里是先转化为double类型比较,也可以转化为long。

    4.最后转化为int类型输出

            String s=Integer.toString(x);
            Stack<Character> stack=new Stack();
            boolean flag=false;
            if(s.charAt(0)=='-'){
                flag=true;
            }
    /*        while(i<s.length()){
                stack.add(s.charAt(i++));
            }*/
            StringBuilder stringBuilder=new StringBuilder();
            if(flag){
                stringBuilder.append('-');
            }
            for(int i=s.length()-1;i>=(flag?1:0);i--){
                stringBuilder.append(s.charAt(i));
            }
    /*        while(!stack.isEmpty()){
                stringBuilder.append(stack.pop());
            }*/
            double d=Double.parseDouble(stringBuilder.toString());
            if(Integer.MIN_VALUE>d||Integer.MAX_VALUE<d){
                return 0;
            }
            return (int)d;

    结果2:

     

    来源:力扣(LeetCode)
    链接:https://leetcode-cn.com/problems/reverse-integer 

    展开全文
  • 思路是把这一批词按最后一个字排序,于是想到了先把这些词反转一下,如把12345转为54321,好像以前在夜息的文章里看过用shell可以实现,就百度了一下,找到几个可行的解决方法,现记录一下。shell实现字符串反转,一...

    在做关键词清洗过程中,需要将一类不符合某个字结尾的词过滤出来,思路是把这一批词按最后一个字排序,于是想到了先把这些词反转一下,如把12345转为54321,好像以前在夜息的文章里看过用shell可以实现,就百度了一下,找到几个可行的解决方法,现记录一下。

    shell实现字符串反转,一句命令搞定!

    cat keywords.txt|while read line;do echo $line|rev;done

    命令的:

    echo 12345|rev

    54321

    python 的:

    echo 12345|python -c ‘print raw_input()[::-1]'

    sed 的:

    echo 12345|sed ‘/\n/!G;s/\(.\)\(.*\n\)/&\2\1/;//D;s/.//'

    awk 的:

    echo 12345|awk ‘BEGIN{FS=””}{for(a=NF;a>0;a–)printf(“%s”,a==1?$a”\n”:$a)}'

    纯 bash 的:

    echo 12345|{ read;for((i=${#REPLY};i>0;i–))do echo -n “${REPLY:$[i-1]:1}”;done;echo; };

    c 的:

    gcc -o a -O2 -x c #include #include int main(int argc,char *argv[]) { if(argc != 2) { printf("%s reverse lines of a string\n",argv[0]); exit(1); } int i=0; char *p; p=argv[1]; i=strlen(argv[1])-1; for(i;i>=0;i--) { printf("%s%s",&p[i],(i==0)?"\n":""); p[i]='\0'; } })&& ./a "12345" ;rm -f a

    展开全文
  • 本文就带大家展示几种常见的字符串反转方法。 准备知识 在学习字符串反转方法之前,先了解几个背景知识点: String类被final修饰,是不可变的; String类并未提供reverse()方法,但StringBuilder/StringBuffer...
  • 1.最简单的方法:public static String reverse1(String str){return new StringBuffer(str).reverse().toString();}利用StringBuffer的对象import java.util.*;public class Main{public static void main(String[]...
  • 字符串反转:ArrayList反转:Demo: Code: package com.test; import java.util.ArrayList;... public class Test03 { public static void main(String[] args) { // 字符反转: // 方法1:---str.char...
  • 五种方法已经封装到类中,话不多说,直接上代码。package com.csdn.strreverse;import java.util.Stack;public class Reverse {String str = new String();public Reverse(String str) {this.str = str;}//用数组...
  • Python字符串反转方法

    2021-12-04 16:09:29
    Python字符串反转 # 循环反向迭代法 juzi = "精神" result = "" for ch in juzi: result = ch+result # 反向赋值给result,字符串整合 ...b.reverse() # 使用列表的reverse()方法进行反转 b = ''.join(b)
  • 第一种方法运用api var strReverse = str.split(' ').reverse().join(' '); 分别打印 第二种方法:for循环加slice function stringReverse(str) { var words = [],result = '',point = 0; for (var i = 0; i &...
  • 代码演练: StringBuilder 的添加方法: 把上面添加的代码改写一下, 因为返会的是对象, 对象可以继续调用方法, 所以可以写成链式编程的形式. 完整代码: ...调用反转方法: ...
  • php反转字符串方法

    2021-03-22 22:03:32
    在面试php相关工作的过程中,我们很可能会遇到这个问题,怎么反转字符串。下面我们就为大家解答这个问题。推荐教程:PHP视频教程方法一使用strrev()函数反转字符串。语法strrev(string)例子...
  • java中字符串反转是一个常见的题目,那么今天来总结一下在java中反转字符串的方法到底有哪些: 1、使用java库函数中的方法reverse() private static String reverse1(String s) { StringBuilder st=new ...
  • 下面本篇文章就给大家介绍2种在java中实现数组反转的简单方法。有一定的参考价值,希望对大家有所帮助。【视频教程推荐:java教程】方法一:使用循环,交换数组中元素的位置使用循环,在原数组中交换元素的位置:第...
  • 字符串反转的9种方法

    2021-01-20 01:42:35
    1. 使用Array.Reverse方法对于字符串反转,我们可以使用.NET类库自带的Array.Reverse方法public static string ReverseByArray(string original){char[] c = original.ToCharArray();Array.Reverse(c);return new ...
  • }//调用反转方法 head =reverse2(head); System.out.println("\n**************************");//打印反转后的结果 while (null !=head) { System.out.print(head.getRecord()+ " "); head=head.getNextNode(); } }...
  • 反转此ArrayList的最简单方法是什么?ArrayList aList = new ArrayList<>();//Add elements to ArrayList objectaList.add("1");aList.add("2");aList.add("3");aList.add("4");aList.add("5");while (aList....
  • 这篇文章主要介绍了Python字符串逐字符或逐词反转方法,本文对逐字符或逐词分别给出两种方法,需要的朋友可以参考下 目的 把字符串逐字符或逐词反转过来,这个蛮有意思的。 方法 先看逐字符反转吧,第一种设置切片的...
  • 第一种:创建一个新数组使用reverse()的方法进行反转。 let arr = [1,2,3,4] let arr1 = arr.reverse() console.log(arr1); //[4, 3, 2, 1] 第二种:利用数组循环,使用unshift()方法将新项添加到数组的开头,并...
  • Stringbuilder 的添加和反转方法
  • 举个????来讲解: ''' 方法1:内建函数reversed() 注意:reversed()函数返回的是一个迭代器,而不是一个List,所以需要list函数转换一下 ...reserve 和 reserved区别 参见另外一文章 ...方法2:内建函数
  • 本篇博客转载他人 文章目录1.反转列表法2.循环反向迭代法3.反向循环迭代法4.倒序切片法5.遍历索引法6.列表弹出法7....Python中,列表可以进行反转,我们只要把字符串转换成列表,使用reverse()方法,进行反
  • JavaScript数组反转教程

    千次阅读 2021-02-25 21:27:36
    本教程将向您展示在JavaScript中使用和不使用 reverse 方法反转数组的五种方法,以及可以使用的代码段。 如何使用Reverse方法反转JavaScript中的数组 当需要在JavaScript中反转数组时,可以使用 reverse 方法,该...
  • Python实现字符串反转的几种方法

    千次阅读 2021-02-25 15:27:09
    1.题目: 在Python环境下用尽可能多的方法反转字符串,例如将s = "abcdef"反转成 "fedcba" 第一种:使用字符串切片 result = s[::-1] 第二种:使用列表的reverse方法 l = list(s) l.reverse() result = "".join(l) ...
  • 1、以下方法中,head指向的节点即头节点的下标(index)为0,即第一个有数据的节点的下标为1。 2、以下方法中,未判断各种特殊情况,如下一个节点不存在的情况,因为如果下一个节点不存在,next为null,正好赋值给了...
  • 单链表的反转,有一个单链表,我们要如何对他进行反转呢?这里我们以leetcode——206为例子 附上题目链接力扣https://leetcode-cn.com/problems/reverse-linked-list/ 目录 一.头结点插入法 二.栈 三.三指...
  • JAVA中常用的反转

    2021-03-08 07:50:19
    这三者其实构成了面向对象的三个基本要素:类、方法和域。三者是一种组合关系,一个Class包含若干个Method和若干个Field。通常,我们用到反转时的起点便是Class。有Class,可以获得对method以及field的access。 同时...
  • golang反转切片

    2021-06-02 09:00:46
    var arr = []int{4: 1, 5: -1} // months := [...]string{1: "January", 12: "December"} arr = rev(arr) fmt.Println(arr) } func rev(slice []int) []int { fmt.Println(slice) for i, j := 0, len(slice)-1...
  • 数组的复制,反转,查找,排序以及Arrays工具类1.数组的复制注:是数组的复制,而不是新的数据引用旧的数组的地址值,这样修改新的数组,旧的数组会改变,这叫数组的赋值public class Test03 {public static void ...
  • 1.内建函数 reversed() li = [1,2,3,4,5,6] a = list(reversed(li)) print(a) 注意:reversed()函数返回的是一个迭代器,而不是一个List,所以需要list函数转换一下 2.内建函数sorted 语法 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 236,934
精华内容 94,773
关键字:

反转方法