7.10题目总结

最新推荐文章于 2020-04-25 20:28:34 发布
最新推荐文章于 2020-04-25 20:28:34 发布
阅读量141 收藏
点赞数
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liuzewei2015/article/details/95307679
版权

目录

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

用两个栈实现一个队列的pop和push功能

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

非递归实现先序、中序遍历

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。假设输入的前序遍历和中序遍历的结果中都不含重复的数字。例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

请实现一个函数，将一个字符串中的每个空格替换成“%20”。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。

public class replaceSpaceTest {
//请实现一个函数，将一个字符串中的每个空格替换成“%20”
// 。例如，当字符串为We Are Happy.则经过替换之后的字符串为We%20Are%20Happy。
    public String replaceSpace(StringBuffer str) {
        int num = 0;
        char[] chars = str.toString().toCharArray();
        for(int i = 0; i < str.length(); i++){
            if(chars[i] == ' '){
                num++;
            }
        }

        int len = chars.length + num*2-1;//新数组长度
        char[] newchars = new char[len+1];

        for(int j = chars.length-1; j > -1; j--){
            if(chars[j] != ' '){
                newchars[len--] = chars[j];
            }else{
                newchars[len--] = '0';
                newchars[len--] = '2';
                newchars[len--] = '%';
            }
        }
        return String.valueOf(newchars);
    }

    @Test
    public void Test1(){
        char[] cha  = new char[60];
        for(int i = 0;i<10;i++){
            if(i%5 != 0){
                cha[i] = 'l';
            }else{
                cha[i] = ' ';
            }
        }
        String str = String.valueOf(cha);//将字符数组转化为字符串
        System.out.println(str);
//        List list = Arrays.asList(cha);
//        for(int i=0;i<cha.length;i++){
//            System.out.println(cha[i]);
//        }
        replace(cha);
        str = String.valueOf(cha);//将字符数组转化为字符串
        System.out.println(str);

        String str2 =  "1398782323**565446";
        char[] chars =  str2.toCharArray();
        replace2(chars);
        str = String.valueOf(chars);
        System.out.println(str);

        String str3 =  "139878 232 3  565446";
        StringBuffer stringBuffer = new StringBuffer(str3);
        System.out.println(replaceSpace(stringBuffer));

    }

    public void replace(char[] chas){
        if(chas == null || chas.length == 0){
            return;
        }
        int num = 0;
        int len = 0;
        for(len = 0; len < chas.length && chas[len] != 0; len++){
            if(chas[len] == ' '){
                num++;
            }
        }
        int j = num*2 + len -1;//新数组的长度
        for(int i = len-1;i>-1;i--){
            if(chas[i] != ' '){
                chas[j--] = chas[i];
            } else{
                chas[j--] = '0';
                chas[j--] = '2';
                chas[j--] = '%';
            }
        }
    }
//数字字符和*的重新编排位置
    public void replace2(char[] chas){
        if(chas == null || chas.length == 0){
            return;
        }
        int num = 0;
        int j = chas.length - 1;//数组总长度
        for(int i = chas.length -1; i > -1; i--){
            if(chas[i] <= '9' && chas[i] >= '0' ){//如果是数字字符
                chas[j--] = chas[i];
            }else{
                num++;
            }
        }
        for(int i = 0;i<num;i++){
            chas[i] = '*';//前num位置放*
        }
    }
}

用两个栈实现一个队列的pop和push功能

public class stackAndQueue {
    Stack<Integer> stack1 = new Stack<Integer>();
    Stack<Integer> stack2 = new Stack<Integer>();
    public void push(int node) {
        stack1.push(node);
    }

    public int pop() {
        int result;
//        if(stack1 == null && stack2 == null){
//            return -1;
//        }
        if(stack1.isEmpty() && stack2.isEmpty() ){//判断栈是否为空
            return -1;
        }
        if(stack2.empty()){
            while(!stack1.empty()){
                stack2.push(stack1.pop());//
            }
        }
        result = stack2.pop();
        return result;
    }
}

把一个数组最开始的若干个元素搬到数组的末尾，我们称之为数组的旋转。 输入一个非减排序的数组的一个旋转，输出旋转数组的最小元素。 例如数组{3,4,5,1,2}为{1,2,3,4,5}的一个旋转，该数组的最小值为1。 NOTE：给出的所有元素都大于0，若数组大小为0，请返回0。

public class minNumberInRotateArrayTest {
    public int minNumberInRotateArray(int [] array) {
        if(array.length == 0 || array == null){
            return 0;
        }
        int left = 0;
        int right = array.length - 1;
        int result;
        while (right >= left+1){
            int mid = left + (right - left + 1) / 2;
            if(array[mid] >= array[left]){
                left = mid;
            } else{
                right = mid;
            }
        }
        if(array[left] > array[right]){
            result = array[right];
        }else {
            result = array[left];
        }
        return result;
    }

    public int process(int[] array, int left, int right){
        int mid = left + (right - left + 1) / 2;
        int result;
        while (right >= left+1){
            if(array[mid] > array[left]){
                left = mid;
            }else {
                right = mid;
            }
            process(array, left, right);
        }
        if(array[left] > array[right]){
            result = array[right];
        }else {
            result = array[left];
        }
        return array[mid];
    }
}

大家都知道斐波那契数列，现在要求输入一个整数n，请你输出斐波那契数列的第n项（从0开始，第0项为0）。

一只青蛙一次可以跳上1级台阶，也可以跳上2级。求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。

public class FibonacciTest {
    public int Fibonacci(int n) {
        return process(n);
    }

    public int process(int n){
        int count = 0;
        int result = 0;
        while( count <= n){
            result = process(count-1) + process(count-2);
            count--;
        }
        return result;
    }

    public int Fibonacci1(int n) {
        if(n <= 1) return n;
        else return Fibonacci1(n-1)+Fibonacci1(n-2);
    }
    @Test
    public void Test1(){
//        int a = Fibonacci1(5);
        int a = Fibonacci2(5);
        System.out.println(a);

    }

    public int Fibonacci2(int n){
        return process2(n, 0, 1);
    }
    public int process2(int n, int acc1, int acc2){
        if(n == 0) return 0;
        if(n == 1) return acc2;
        else return process2(n-1, acc2, acc1+acc2);
    }
    //使用矩阵乘法解题
    public int Fibonacci3(int target){
        if(target < 1){
            return -1;
        }
        if(target == 1){
            return 1;
        }
        if(target == 2){
            return 2;
        }
        int[][] matix  = {{1,1},{1,0}};//系数矩阵
        int[][] matixR = {{1,0},{0,1}};//初始化单位矩阵
        for(int i = 0;i<target-2 ;i++){//矩阵的n-2次的阶乘，后面是更优的解法
            matixR = matixMultiCommon(matixR, matix);
        }
        return matixR[0][0] + 1*matixR[0][1];
    }

    //乘法：常数级别时间复杂度
    public int[][] matixMulti(int[][] matrix1, int[][] matrix2){//矩阵乘法.matrix1与matrix2均为n阶矩阵
        int[][] matrix = new int[matrix1.length][matrix1.length];
        for(int i = 0; i < matrix1.length; i++){
            for(int j = 0; j < matrix1.length; j++){
                for(int h = 0; h<matrix1.length;h++){
                    matrix[i][j] += matrix1[i][h] * matrix2[h][j];
                }
            }
        }
        return matrix;
    }
    public int[][] matixMultiCommon(int[][] matrix1, int[][] matrix2){
        //矩阵乘法.matrix1与matrix2为能相乘的任意俩个矩阵
        int[][] matrix = new int[matrix1.length][matrix2[0].length];
        for(int i = 0; i < matrix1.length; i++){
            for(int j = 0; j < matrix2[0].length; j++){
                for(int h = 0; h<matrix2.length;h++){
                    matrix[i][j] += matrix1[i][h] * matrix2[h][j];
                }
            }
        }
        return matrix;
    }
    public int[][] matrixPower(int[][] m, int p){//矩阵m的p次方，m为n阶矩阵
        int[][] res = new int[m.length][m[0].length];
        for(int i = 0;i<res.length;i++){
            res[i][i] = 1;//初始化为单位矩阵
        }
        int[][] temp = m;
        for(;p!=0;p>>=1){
            if((p & 1) == 1){
                res  = matixMultiCommon(res, temp);
            }
            temp = matixMultiCommon(temp,temp);
        }
        return res;
    }

    @Test
    public void Test3(){
        int a = Fibonacci3(4);
        System.out.println(a);
        System.out.println( Fibonacci3(5));
        System.out.println( Fibonacci3(6));
    }

}
public class JumpFloorTest {
//    一只青蛙一次可以跳上1级台阶，也可以跳上2级。
//    求该青蛙跳上一个n级的台阶总共有多少种跳法（先后次序不同算不同的结果）。
    public int jumpFloor(int target){//使用递归
        if(target == 1) return 1;
        if(target == 2) return 2;
        return jumpFloor(target-1) + jumpFloor(target - 2);

    }
    public int jumpFloor1(int target){//使用迭代
        if(target == 1) return 1;
        if(target == 2) return 2;
        int a = 1;
        int b = 2;
        int total = 0;
        for(int i = 3; i <= target;i++){
            total = a+b;
            a = b;
            b = total;
        }
        return total;
    }

}

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

翻转了链表再输出的（改变了链表结构）

    public ArrayList<Integer> printListFromTailToHead(Node head) {
        ArrayList arrayList = new ArrayList();
        Node pre = null;
        Node next = null;
        while (head != null){
            next = head.next;
            head.next = pre;
            pre = head;
            head = next;
        }
        head = pre;
        while (pre!=null){
            arrayList.add(pre.data);//把节点的值传进链表
            pre = pre.next;
        }
        return arrayList;
    }
}
递归版本：(推荐)
    public void printListFromTailToHead2(Node head) {
        if(head.next !=null){
            printListFromTailToHead2(head.next);
        }
        System.out.println(head.data);
    }

非递归实现先序、中序遍历

    //非递归实现先序遍历
    public void preOrderUnRecur(Node head){
        System.out.println("pre-order");
        if(head != null){
            Stack<Node> stack = new Stack<>();
            stack.add(head);
            while (!stack.empty()){
                head = stack.pop();
                System.out.println(head.value);
                if(head.left!= null)
                    stack.push(head.left);
                if(head.right != null)
                    stack.push(head.right);
            }
        }
    }
    //非递归实现中序遍历
    //1先把头节点压入栈中；2依次把头结点的左子树head = head.left 压入栈中; 3直到head为空，打印head的值
    //时head = head.right 继续重复2; 当stack为空且head为空时，整个过程停止；
    public void inOrderUnRecur(Node head){
        System.out.println("inOrderUnRecur");
        if(head != null){
            Stack<Node> stack = new Stack<>();
            while (!stack.isEmpty() || head != null){
                if (head != null){
                    stack.add(head);
                    head = head.left;
                }else{
                    head = stack.pop();
                    System.out.println(head.value);
                    head = head.right;
                }
            }
        }
    }

输入某二叉树的前序遍历和中序遍历的结果，请重建出该二叉树。
假设输入的前序遍历和中序遍历的结果中都不含重复的数字。
例如输入前序遍历序列{1,2,4,7,3,5,6,8}和中序遍历序列{4,7,2,1,5,3,8,6}，则重建二叉树并返回。

//通过先序和中序数组生成后序数组
    public int[] getPosArray(int[] pre, int[] in){
        if(pre == null || in == null){
            return null;
        }
        int len = pre.length;
        int[] pos = new int[len];//后序数组的长度
        HashMap<Integer,Integer> map = new HashMap<Integer, Integer>();
        for(int i=0; i<len;i++){
            map.put(in[i],i);//中序数值及其索引
        }

        return pos;
    }
    //从左往后一次填好后序数组
    //si为后序数组s该填的位置
    //返回值为s该填的下一个位置
    public int setPos(int[] p,int pi,int pj, int n,int ni,int nj,
                      int[] s,int si, HashMap<Integer,Integer> map){
        if(pi > pj){
            return si;
        }
        s[si--] = p[pi];
        int i = map.get(p[pi]);//头节点在中序数组中的位置为i
        si = setPos(p,pj-nj+i-1,pj,n,i+1, nj, s, si, map);//后序数组s该填的位置
        return setPos(p, pi+1, pi+i-ni, n, ni, i-1, s, si, map);
    }
    private Node reBuild(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn){
        if(startPre>endPre || startIn > endIn){
            return null;
        }
        int root = pre[startPre];
        int rootLocate = locate(root, in, startIn, endIn);
        Node rootNode = new Node(root);
        rootNode.left = reBuild(pre, startPre+1,
                startPre+rootLocate-1, in, startIn+1, rootLocate-1);//建立左子树
        rootNode.right = reBuild(pre, startPre+rootLocate-startIn+1,
                endPre, in, rootLocate+1, endIn);//建立右子树
        return rootNode;
    }

    private int locate(int root, int[] in,int startIn, int endIn){
        for(int i = startIn;i<=endIn;i++){
            if(root == in[i])
                return i;
        }
        return -1;
    }
    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
        
        if(pre == null || in == null || pre.length != in.length){
            return null;
        }else{
            TreeNode root= reBuild(pre,0,pre.length-1,in,0,in.length-1);
            return root;
        }
    }
     private TreeNode reBuild(int[] pre, int startPre, int endPre, int[] in, int startIn, int endIn){
        if(startPre>endPre || startIn > endIn){
            return null;
        }
        TreeNode rootNode = new TreeNode(pre[startPre]);
        for(int i = startIn;i <= endIn;i++){
            if(pre[startPre] == in[i]){
            rootNode.left = reBuild(pre, startPre+1,
                startPre+i-startIn, in, startIn, i-1);//建立左子树
            rootNode.right = reBuild(pre, startPre+i-startIn+1,
                endPre, in, i+1, endIn);//建立右子树
                break;
            }
        }
        return rootNode;
    }

 

lzw2019sun
关注
专栏目录
MS-DOS7.10镜像文件
09-11
VMware下安装MS-DOS7.10的镜像文件
第五次测试复盘
qq_44788119的博客
09-08 759
1. 对某二叉树进行先序遍历的结果是ABDEFC,中序遍历的结果是DBFEAC，则后序遍历的结果是（B） A DEEFAC B DFEBCA C CFEDBA D CEFBDA 解析 先序遍历：根 -> 左子树 -> 右子树 中序遍历：左子树 -> 根 -> 右子树 后序遍历：左子树 -> 右子树 -> 根 1、根据先序遍历，根节点为A 2、根据后序遍历，A左子...
用两个栈来实现一个队列，完成队列的Push和Pop操作。 队列中的元素为int类型
Liam_fang的博客
10-31 2037
对于这道题目，需要知道栈和队列的性质，栈是先进后出的，而队列是先进先出的。对于栈我们可以看成是一个装羽毛球的球筒，第一个放入球筒的球在最底部，最后一个球放在最上部具体的可参照该链接。对于队列，就像买票排队，先排的先出，。言归正传，假如输入1,2,3则该程序也需要按顺序输出1,2,3，该题目用Java的解法如下所示。 import java.util.Stack; public clas
Java 面试题-1
liyifan687的博客
04-25 809
1. OSI的7层从上到下 应用层 -表示层 -会话层 - 传输层 -网络层 - 数据链路层 - 物理层 2. 以下哪些不是 javaScript 的全局函数( C ) A. eval B. escape C. setTimeout D. parseFloat 3. rmdir和rm rmdir删除一个空文件夹 使用方式： rmdir [-p] dirNa...
迅雷笔试题
Tiantian的博客
01-15 1023
原文转载：https://blog.csdn.net/Hackbuteer1/article/details/11482103 2014迅雷校招笔试题 一、单选题（20题，每题2分）1、有变量int i = 0; int a = i++; int b=++a; int c = a+b; 请问表达式 a?b:c 的值是（）A、0              B、1              C、2 ...
【C++后台开发面经】面试总结第三波：针对后台开发相关基础知识分类总结
qq_36417014的博客
04-25 4209
后端面试总结 1、数据结构 链表和数组的区别 内存分布：链表是无连续的内存空间，通过指针来实现链式存储；数组是一段连续的内存空间，一般大小需提前知道。 增：链表：无序链表：O(1)，有序链表：O(n)；数组：无序数组：内存充足O(1)，内存不充足O(O(n)+1)=O(n)，有序数组：O(n) 查找+移动 删：链表：O(O(n)+1)=O(n) 找到+删除；数组：末尾 O(1)，非末尾...
MSDOS 7.10 dos系统
04-06
MSDOS 7.10 DOS系统
MS-DOS7.10完整安装光盘
04-23
MS-DOS 7.10 是微软公司推出的个人计算机操作系统的一个早期版本，它在1990年代末期被广泛使用。这个系统是基于DOS的，提供了对当时硬件的全面支持，尤其对于那些需要简单、高效运行的老式应用程序和游戏来说，MS-...
IAR For ARM 7.10 破解
04-19
iar7.10 破解 同时支持低版本的破解
MSDOS7.10.iso
05-05
MSDOS7.10 制作DOS启动盘用，内含华硕更新BIOS工具
Java面试-企业实战面试题4
longlong_agoDe的博客
08-14 710
1. 选择题 1.1 已知一棵二叉树，如果先序遍历的节点顺序是：ADCEFGHB ，中序遍历是：CDFEGHAB ， 则后序遍历结果为：（ D ） A. CFHGEBDA B. CDFEGHBA C. FGHCDEBA D. CFHGEDBA 知识点 对于二叉树的遍历方式一般分为三种先序、中序、后序三种方式： 先序遍历（根左右） 若二叉树为空，则不进行任何操作：否则1、访问根结点。 2、先序方式遍...
栈的基础知识
u010061734的专栏
10-20 540
栈分为
c++实现二叉树的寻找、删除、遍历、查找
Mr_fightingboy的博客
07-25 2123
     大家都知道二叉树最大的特点即只有两个节点，因此可以大致构建这一个二叉树类：      #ifndef TREE_H #define TREE_H class Tree { public：     int data;   //value值     Tree *pleft;//左节点     Tree *pright;//右结点     Tree *pfather//父节点     T...
关于组织参加“第八届‘泰迪杯’数据挖掘挑战赛”的通知-4页
最新发布
11-03
关于组织参加“第八届‘泰迪杯’数据挖掘挑战赛”的通知-4页
PyMySQL-1.1.0rc1.tar.gz
11-03
PyMySQL-1.1.0rc1.tar.gz
技术资料分享CC2530中文数据手册完全版非常好的技术资料.zip
11-03
技术资料分享CC2530中文数据手册完全版非常好的技术资料.zip
docker构建php开发环境
11-03
docker构建php开发环境
VB程序实例59_系统信息_显示分辨率.zip
11-03
VB程序实例，可供参考学习使用，希望对你有所帮助
pytz-2016.7-py2.6.egg
11-03
pytz库的主要功能 时区转换：pytz库允许用户将时间从一个时区转换到另一个时区，这对于处理跨国业务或需要处理多地时间的数据分析尤为重要。 历史时区数据支持：pytz库不仅提供了当前的时区数据，还包含了历史上不同时期的时区信息，这使得它在处理历史数据时具有无与伦比的优势。 夏令时处理：pytz库能够自动处理夏令时的变化，当获取某个时区的时间时，它会自动考虑是否处于夏令时期间。 与datetime模块集成：pytz库可以与Python标准库中的datetime模块一起使用，以确保在涉及不同时区的场景中时间的准确性。
MS-DOS7.10安装包：探索经典的DOS系统
总结来说，MS-DOS7.10完整安装光盘是MS-DOS操作系统发展史上的一个经典之作，它不仅代表了一个时代的操作系统技术，也为用户提供了学习、维护和特殊用途操作的多种可能。虽然在现代计算机环境中，基于图形用户界面的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值