精华内容
下载资源
问答
  • 单链表的反转代码

    2019-09-23 16:41:04
    单链表的反转代码 单链表反转有2种实现,一种是有头结点的实现,另外一种是无头结点的实现,下面的代码解释了2种情形下的代码实现。 1.利用头结点实现单链表反转 //与下面的代码公用一个LNode结构 public static ...

    单链表的反转代码

    单链表反转有2种实现,一种是有头结点的实现,另外一种是无头结点的实现,下面的代码解释了2种情形下的代码实现。

    1.利用头结点实现单链表反转

    //与下面的代码公用一个LNode结构    
    public static void reverse(LNode node, LNode head) {
    
            if (node == null || node.next == null) return;
    
            head.next = node;
    
            LNode i = node;
            LNode j = node.next;
    
    
            while (j != null){
                i.next = j.next;
                j.next = head.next;
                head.next = j;
    
                //i的位置可以不用动
                j = i.next;
            }
        }
    

    2.无头结点的单链表反转

    package list;
    
    public class LNode {
    
            Object data;
        	LNode next;
    
            public LNode() {
        }
    
        public LNode(Object data) {
            this.data = data;
            this.next = null;
        }
    
        @Override
        public String toString() {
            return "LNode{" + "data=" + data + ", next=" + next + '}';
        }
        
        //main方法!!!!
        public static void main(String[] args) {
            LNode l1 = new LNode(1);
            LNode l2 = new LNode(2);
            LNode l3 = new LNode(3);
    
            l1.next = l2;
            l2.next = l3;
    
            // => LNode{data=1, next=LNode{data=2, next=LNode{data=3, next=null}}}
            System.out.println(l1);
    
            reverse(l1);
    
            // => LNode{data=3, next=LNode{data=2, next=LNode{data=1, next=null}}}
            System.out.println(l3);
        }
    
        public static void reverse(LNode node) {
            if (node == null || node.next == null) return;
    
            LNode head = node;
            LNode i = node;
            LNode j = node.next;
    
            while (j != null) {
                head.next = j.next;
                j.next = i;
    
                i = j;
                j = head.next;
            }
    
        }
    }
    
    展开全文
  • 鼠标反转代码

    2015-04-15 11:09:14
    反转鼠标,鼠标反转代码
  • CUDA图像反转代码

    2015-09-17 20:32:04
    CUDA图像反转供大家学习,代码用到opencv,环境配置见http://blog.csdn.net/xuhang0910/article/details/45601035
  • 时间反转代码

    2013-03-26 16:59:15
    网上找的一段时间反转程序,有信源信号产生方法和时反的过程,分享一下
  • 什么是优先级反转?简单从字面上来说,就是低优先级的任务先于高优先级的任务执行了,优先级搞反了。那在什么情况下会生这种情况呢?一起来看看
  • 单链表的反转是常见的面试题目,下面这篇文章主要给大家介绍了关于单链表实现反转的3种方法,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面来一起学习学习吧
  • c++二叉树反转代码

    2013-01-19 15:37:07
    c++实现二叉树反转代码,课程作业,供大家参考~~~
  • java字符反转代码

    2009-04-21 15:46:10
    字符反转 import java.awt.*; import java.awt.event.*; import javax.swing.*; import javax.swing.border.*; import javax.swing.event.*;
  • PWM电机正反转(内含完整的C语言代码).zip
  • 本篇文章是对c#图像灰度化、灰度反转、二值化的实现方法进行了详细的分析介绍,需要的朋友参考下
  • 下面小编就为大家带来一篇java 输入一个数字,反转输出这个数字的值(实现方法)。小编觉得挺不错的,现在就分享给大家,也给大家做个参考。一起跟随小编过来看看吧
  • 代码: class ListNode: def __init__(self,x): self.val=x; self.next=None; def nonrecurse(head): #循环的方法反转链表 if head is None or head.next is None: return head; pre=None; cur=head; h=...
  • 主要介绍了 Java 字符串反转实现代码的相关资料,需要的朋友可以参考下
  • 主要介绍了Java语言实现反转链表代码示例,小编觉得挺不错的,这里分享给大家,供需要的朋友参考。
  • 数组和队列反转

    2016-04-20 23:00:12
    一个很简单适用的自定义编写的C#基础实现队列和反转数组,让你从最基础的C#来开始你的代码量的积累。
  • 单向链表的反转 反转API: public void reverse():对整个链表反转; public Node reverse(Node curr):反转链表中的某个结点curr,并把反转后的curr结点返回; 使用递归可以完成反转,递归...代码如下: public class...

    单向链表的反转

    反转API:
    public void reverse():对整个链表反转;
    public Node reverse(Node curr):反转链表中的某个结点curr,并把反转后的curr结点返回;
    使用递归可以完成反转,递归反转其实就是从原链表的第一个存数据的结点开始,依次递归调用反转每一个结点,知道把最后一个结点反转完成,整个链表就反转完毕。图片图片代码如下:

    public class linkRevarse(){
    	....................
    	...............
    	.........
    	.......
    	....//上面省略了一些代码,想要看完整的代码,在下面的代码块中
    	//用来反转整个链表
        public void reverse(){
            //判断当前链表是否为空链表,如果是空链表,则结束运行,如果不是,则调用重载的reverse方法完成反转
            if(isEmpty()){
                return;
            }
            reverse(head.next);
        }
    
        //反转指定的结点curr,并把反转后的结点返回
        public Node reverse(Node curr){
            if(curr.next == null){
                head.next = curr;
                return curr;
            }
            //递归的反转当前结点curr的下一个结点,返回值就是链表反转后,当前结点的上一个结点
            Node pre = reverse(curr.next);
    
            //让返回的结点的下一个结点变为当前结点curr
            pre.next = curr;
    
            //把当前结点的下一个结点变为null
            curr.next = null;
    
            return curr;
        }
    }
    

    完整的代码块,在双向链表中添加反转

    import cn.itcast.demo.day02.linear.SequenceList;
    
    import java.util.Iterator;
    
    public class LinkList<T> implements Iterable<T> {
        //记录头结点
        private Node head;
        //记录链表的长度
        private int N;
    
        //节点类
        private class Node{
            //存储数据
            T item;
            //下一个节点
            Node next;
    
            //内部类的构造函数
            public  Node(T item,Node next){
                this.item = item;
                this.next = next;
            }
        }
    
        //LinkList的构造函数
        public LinkList(){
            //初始化头结点
            this.head = new Node(null,null);
            //初始化元素个数
            this.N = 0;
        }
    
        //清空链表
        public void clear(){
            head.next = null;
            this.N = 0;
        }
    
        //获取链表的长度
        public int length(){
            return N;
        }
    
        //判断链表是否为空
        public boolean isEmpty(){
            return N==0;
        }
    
        //获取指定位置i处的元素(非物理位置,0,1,2,3,......)
        public T get(int i){
                //通过循环,从头节点开始往后找,依次找i次就可以找到对应的元素
                /*
                    注:head0.item = null;
                    0,1,2,3,4,5.....,
                    index == 0时:取得时head1.item;
                    index == 1时:取得时head2.item;
                    index == 2时:取得时head3.item;
                    ......................
                    index == i-1时:取得时headi.item;
                 */
                Node n = head.next;
                for(int index = 0; index < i; index++){
                    n = n.next;
                }
                return n.item;
    
        }
        //向链表中添加元素t(非物理位置,0,1,2,3,......)
        public void insert(T t){
            //找到当前最后一个节点
            Node n = head;
            while (n.next != null){
                n = n.next;
            }
            //创建新节点,保存元素t
            Node newNode = new Node(t,null);
            //让当前最后一个节点指向新节点
            n.next = newNode;
            //元素个数+1
            N++;
        }
    
        //向指定位置i处,添加元素t(物理位置,1,2,3,......)
        public void insert(int i,T t){
            //找到i位置前一个节点
            Node pre = head;
            for(int index = 0; index < i-1; index++){
                pre = pre.next;
            }
    
            //找到i位置的节点
            Node curr = pre.next;
            //创建新节点,并且新节点需要指向原来i位置的节点
            Node newNode = new Node(t,curr);
            //原来i位置的前一个节点指向新节点
            pre.next = newNode;
            //元素个数+1;
            N++;
        }
    
        //删除指定位置i处的元素,并返回被删除的元素
        public T remove(int i){//(非物理位置,0,1,2,3,......)
            //找到i位置的前一个节点
            Node pre = head;
            for(int index = 0; index < i-1; index++){//??????????
                pre = pre.next;
            }
            //要找到i位置的节点
            Node curr = pre.next;
            //找到i位置的下一个节点
            Node nextNode = curr.next;
            //前一个节点指向下一个节点
            pre.next = nextNode;
            //元素个数-1
            return curr.item;
        }
    
        //查找元素t在链表中第一次出现的位置
        public int indexOf(T t){
            //从头节点开始,依次找到每一个结点,取出item和t进行比较如果相同就找到了
            Node n = head;
            for(int i = 1; n.next!=null; i++){
                n = n.next;
                if(n.item.equals(t)){
                    return i;
                }
            }
            return -1;
        }
    
        @Override
        public Iterator<T> iterator() {
            return new LIterator();
        }
    
        private class LIterator implements Iterator{
            private Node n;
            public LIterator(){
                this.n = head;
            }
    
            @Override
            public boolean hasNext(){
                return n.next != null;
            }
    
            @Override
            public Object next() {
                n = n.next;
                return n.item;
            }
    
        }
    
        //用来反转整个链表
        public void reverse(){
            //判断当前链表是否为空链表,如果是空链表,则结束运行,如果不是,则调用重载的reverse方法完成反转
            if(isEmpty()){
                return;
            }
            reverse(head.next);
        }
    
        //反转指定的结点curr,并把反转后的结点返回
        public Node reverse(Node curr){
            if(curr.next == null){
                head.next = curr;
                return curr;
            }
            //递归的反转当前结点curr的下一个结点,返回值就是链表反转后,当前结点的上一个结点
            Node pre = reverse(curr.next);
    
            //让返回的结点的下一个结点变为当前结点curr
            pre.next = curr;
    
            //把当前结点的下一个结点变为null
            curr.next = null;
    
            return curr;
        }
    }
    
    
    展开全文
  • 解题思路:这道题本来是让反转单链表的,不过前提肯定是要以建立单链表。因此我分成了两个方法,一个init建立单链表,一个reverse反转单链表。(幸好做了这道题,不然都不会发现自己忘了单链表怎么建立,查漏补缺)...

    解题思路:这道题本来是让反转单链表的,不过前提肯定是要建立单链表。因此我分成了两个函数,一个init建立单链表,一个reverse反转单链表。(幸好做了这道题,不然都不会发现自己忘了单链表怎么建立,查漏补缺)这里建立单链表用的是尾插法。反转单链表用了三个指针,两个辅助指针,还有一个链表的头指针。(这里也卡了我好久,差点把自己绕蒙了)

    #include <iostream>
    #include <stdlib.h>
    
    typedef struct Linklist{
    	int n;
    	struct Linklist *next;
    	}Linklist;
    
    Linklist * init(int &n){
    	Linklist *L=(Linklist*)malloc(sizeof(Linklist));//用尾插法建立链表还是弄个头节点方便
    	Linklist *q,*p;
    	L->next=nullptr;
    	q=L;
    	int i;
    	for(i=0;i<n;++i){//用尾插法,方便后面倒序
    		p=(Linklist*)malloc(sizeof(Linklist));
    		std::cout<<"Please input the " <<i+1<<" value"<<std::endl;
    		std::cin>>p->n;
    		q->next=p;
    		q=p;
    	}
    	p->next=nullptr;
    	q=L;
    	L=L->next;
    	free(q);//释放头节点,因为后面反转用不到,不释放就可能内存泄露了,还影响反转
    	return L;
    }
    
    Linklist * reverse(Linklist *&l){//反转单链表
    	Linklist *pre=nullptr,*pnext=nullptr;
    	while(l!=nullptr){
    		pnext=l->next;
    		l->next=pre;
    		pre=l;
    		l=pnext;
    	}
    	return pre;
    }
    
    int main(){
    	Linklist *p;
    	std::cout<<"Please input how much point you want to insert:"<<std::endl;
    	int n;
    	std::cin>>n;
    	p=init(n);
    	p=reverse(p);
    	//system("pause"); //我用的是vscode,所以return之前都要手动暂停一下,不然看不到结果
    	return 0;
    } 
    
    

    为了方便阅读,做了两张图,希望能辅助思考这个反转的思路

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 字符串反转的所有代码方法

    千次阅读 2016-04-18 11:59:25
    * 将字符串反转,传入的是字符数组,则void,传入的是字符串,则要返回字符串 * @param ch * @param begin * @param end */ public static void reverseStr0(char[] ch,int begin,int end) { ...
    package 编程之法;
    


    import java.util.ArrayDeque;
    import java.util.Deque;
    import java.util.LinkedList;
    import java.util.Queue;
    import java.util.Scanner;
    import java.util.Stack;
    /**
     * 三步翻转法
     * @author Administrator
     *
     */


    public class 字符串旋转 {


    /**
    * 将字符串反转,传入的是字符数组,则void,传入的是字符串,则要返回字符串
    * @param ch
    * @param begin
    * @param end
    */
    public static void reverseStr0(char[] ch,int begin,int end)
    {
    while(begin <end)
    {
    char temp = ch[begin];
    ch[begin++] = ch[end];
    ch[end--] = temp;


    }
    }
    /**
    * 将字符串按照指定个数反转
    * @param str
    * @param n
    * @return
    */
    public static char[] reverseStrN(String str,int n)
    {
    char[] ch = str.toCharArray();


    //编程考虑三层测试,功能测试,边界测试,非法输入测试
    //如果移动的字符个数超过了字符串的长度呢
    int len = ch.length;
    if(n > len)
    n = n%len;
    //若只有一个字符,就不让进入函数,提高效率
    if(len == 1)
    return ch;
    reverseStr0(ch,0,n-1);
    reverseStr0(ch,n,len-1);
    reverseStr0(ch,0,len-1);
    return ch;
    }
    /**
    * 7种字符串反转
    */


    //1. 递归反转字符串
    public static String reverseStr1(String str)
    {
    int len = str.length();
    //递归必须有结束条件,不然会栈溢出错误
    if(len <= 1)
    return str;


    String left = str.substring(0,len/2);
    String right = str.substring(len/2,len);
    return reverseStr1(right)+reverseStr1(left);
    }
    //2. 字符串String拼接,不推荐
    public static String reverseStr2(String s) {
    int length = s.length();
    String reverse = "";
    for (int i = 0; i < length; i++)
    reverse = s.charAt(i) + reverse;//及其不推荐,每一次+的时候都会申请新的内存空间,差评
    return reverse;
    }




    //3. 跟2差不多,不推荐,用StringBuilder改进
    public static String reverseStr3(String str)
    {
    // String res = "";//跟String有关的拼接操作都不推荐
    StringBuilder sb = new StringBuilder();
    char[] ch = str.toCharArray();
    for(int i = ch.length-1;i>=0;i--)
    {
    // res = res+ch[i];
    sb.append(ch[i]);
    }
    // return res;
    return sb.toString();
    }


    //4. 用jdk封装的接口
    public static String reverseStr4(String str)
    {
    return new StringBuilder(str).reverse().toString();


    }


    //5. 一想到字符串反转,就想到堆栈stack
    public static String reverseStr5(String str)
    {
    char[] ch = str.toCharArray();
    Stack<Character> stack  = new Stack<Character>();
    StringBuilder sb = new StringBuilder();
    for(int i = 0;i<ch.length;i++)
    {
    stack.push(ch[i]);
    }
    while(!stack.isEmpty())
    {
    sb.append(stack.pop());
    }
    return sb.toString();


    }
    //6. 这里练习一下队列,突然想到先进先出
    public static String reverseStr6(String str)
    {
    char[] ch = str.toCharArray();
    Queue<Character> queue = new LinkedList<Character>();
    StringBuilder sb = new StringBuilder();
    for(int i = 0;i<ch.length;i++)
    {
    queue.offer(ch[i]);
    }
    while(!queue.isEmpty())
    {
    sb.append(queue.poll());
    }
    return sb.toString();
    }
    //7. 新型栈
    public static String reverseStr7(String str)
    {
    char[] ch = str.toCharArray();
    // Deque<Character> deque = new ArrayDeque<Character>();
    // Deque<Character> deque = new LinkedList<Character>();
    LinkedList<Character> list = new LinkedList<Character>();
    StringBuilder sb = new StringBuilder();
    for(int i = 0;i<ch.length;i++)
    {
    // deque.addFirst(ch[i]);
    // deque.push(ch[i]);
    list.push(ch[i]);
    }
    while(!list.isEmpty())
    {
    // sb.append(deque.removeFirst());
    // sb.append(deque.pop());
    sb.append(list.pop());
    }
    return sb.toString();


    }


    //8. 推荐,效率源码
    public static String reverseStr8(String orig) {
    char[] s = orig.toCharArray();
    int n = s.length - 1;
    int halfLength = n / 2;
    for (int i = 0; i <= halfLength; i++) {//n/2
    char temp = s[i];
    s[i] = s[n - i];
    s[n - i] = temp;
    }
    return new String(s);
    }


    //9.更快,异或操作
    public static String reverseStr9(String s) {


    char[] str = s.toCharArray();


    int begin = 0;
    int end = s.length() - 1;


    while (begin < end) {
    str[begin] = (char) (str[begin] ^ str[end]);
    str[end] = (char) (str[begin] ^ str[end]);
    str[begin] = (char) (str[end] ^ str[begin]);
    begin++;
    end--;
    }
    return new String(str);
    }


    public static void main(String[] args)
    {
    Scanner sc = new Scanner(System.in);
    String str = sc.nextLine();
    char[] ch = reverseStrN(str,3);
    int i = 0;
    while(i < ch.length)
    {
    System.out.print(ch[i]+" ");
    i++;
    }
    System.out.print(reverseStr9(str));//字符串反转测试
    }
































    }

    展开全文
  • import java.util.Scanner; public class Test{ ... * 需求:把字符串反转 * 举例:键盘录入"abc" * 输出结果:"cba" *分析: *1,通过键盘录入获取字符串Scanner *2,将字符串转...
  • 解压后请阅读使用说明 在generatorConfig.xml中填好数据库配置 复制命令在cmd中运行
  • 单链表反转的python实现,简洁详细易于理解,附带注释易于分析
  • 快牛策略动量反转策略优化论文及Python代码分享给大家
  • js代码-js数组元素反转 reverse
  • C语言实现单链表反转

    2020-08-18 17:57:16
    主要介绍了C语言实现单链表反转,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友们下面随着小编来一起学习学习吧
  • 小车正反转源代码程序包
  • 图片颜色反转

    千次阅读 2020-04-18 18:30:44
    灰度图片颜色反转实现代码如下: import cv2 import numpy as np img = cv2.imread('image1.jpg',1) imgInfo = img.shape height = imgInfo[0] width = imgInfo[1] gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY) dst...
  • ucos试验代码实例1:任务优先级反转

    千次阅读 2014-11-16 15:21:28
    任务优先级反转: 原理是,信号量是稀缺资源,当一个低优先级的任务霸占了信号量,高优先级任务想要用这个信号量只好等待,于是呢,在这个间隙里,中优先级的任务(当然,这个任务是不想用该信号量的)就获得了...
  • 原本还想再写一个不使用额外内存的,发现貌似java实现不了, 如果哪位大神能实现欢迎... * 字符串反转 * * @author Kangbin * @date 2018-11-17 */ public class StrReverse { /** * 1.通过stringbuilder的re...
  • 线反转程序代码

    2014-10-31 12:43:27
    就是滴单片机关于数字键盘的一个线反转程序代码,洗完
  • c++反转字符串代码

    2014-04-09 16:32:07
    c++反转字符串 简单的代码 测试可用,已经实现了方法和main函数

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 198,119
精华内容 79,247
关键字:

反转代码