精华内容
下载资源
问答
  • 利用表格处理数据,我们经常会碰到的一种情况,那...案例一:数据透视快速完成多数据错序汇总案例说明:如上图我们需要1-3月数据明细中的数据,统一汇总到汇总表格中,单独分成1-3月3数行数据来显示,该怎么进行...

    利用表格处理数据,我们经常会碰到的一种情况,那就是如何多多表数据进行快速计算。将多个表格中的数据完成数据汇总和求和,这种操作对绝大多数人来说都比较陌生。今天我们就来学习一下,Excel常见的简单两种多表汇总方式,数据透视和Sum函数多表求和。

    案例一:数据透视快速完成多表数据错序汇总

    185f09beeea4a5d4bead2121ea55aded.png

    案例说明:如上图我们需要把1-3月数据明细中的数据,统一汇总到汇总表格中,单独分成1-3月3数行数据来显示,该怎么进行手动操作,操作演示图如下:

    2b86cf3ef79be740d3072309f74ea4f6.gif

    操作步骤:

    第一步:点击打开汇总页工作表,点击菜单栏,数据—合并计算,进入到数据透视多表合并操作界面,然后我们点击计入下一步;

    第二步:选择1-3月每个工作表的数据区域,点击确定这样就是全部选择所有工作表中的数据区域,我们就直接进入到了多表计算模式;

    第三步:将数据对齐方式,标签位置选择对应首行和左列对齐,这样最终的数据就会以我们固定的格式来汇总。

    案例二:利用Sum函数快速完成多表数据汇总

    8d8bbe780c9bc5a14bda83455385cb77.png

    案例说明:如上图1-3月每张工作表标题都是保持一样,显示着每个人每种产品的数据,如果按照这种格式将每张表的数据汇总求和到汇总表中该如何操作,这样的操作方式我们用简单的sum函数就能够完成。如下图所示:

    83617eb21083d7e72ea28e6c12fae9bd.gif

    函数公式:

    =Sum('*'!B2)

    函数说明:在各类工作表标题行、列都保持一致的情况下,如果要进行数据求和,我们可以直接用函数求和的办法即可实现数据汇总。

    函数解析:这个函数代表的意思就是:对任意工作表B2单元格的数据进行求和。

    通过上面两种多表求和操作,现在你学会如何快速进行数据汇总了吗?是不是突然绝对操作就是这么简单了?

    展开全文
  • 首先引入两个问题,给我们两个已经排好序的数组和链表我们要怎么把他们合并成一个数组或者链表 int[] arr1 = new int[]{3,1,9,7}; int[] arr2 = new int[]{6,10,16,50}; 时间复杂度和空间复杂度 时间复杂度 假设...

    排序算法

    排序算法,字面意思上来说,就是用来排序的算法,我主要从简单到复杂介绍几个常见的排序。
    首先引入两个问题,给我们两个已经排好序的数组和链表我们要怎么把他们合并成一个数组或者链表

    int[] arr1 = new int[]{3,1,9,7};
    int[] arr2 = new int[]{6,10,16,50};
    

    时间复杂度和空间复杂度

    时间复杂度

    假设我们有个数组,我们要查找数组中是否存在某个数
    如何来衡量写的算法效率更高呢,可以用时间吗?是不可以的。所以我们引入时间复杂度的概念。
    每访问一个元素,时间复杂度记为1,如果一个数组的长度为n,如果我们用遍历的方式来进行操作,那么访问n次才能够确定,时间复杂度记为n,其中单层for循环时间复杂度为n,双层for循环时间复杂度为n^2 以此类推
    常用的时间复杂度
    1(一般Hash结构为1)
    n( 一般为遍历)
    logn ( 一般为递减的遍历)
    n^n *(n次 循环遍历)

    空间复杂度

    为了衡量我们的算法用了多少额外的空间,我们引入空间复杂度,它是用来形容对空间开辟了多少的一个值,取决于原始数据大小

    有序数组和链表的合并

    数组的合并

    数组的合并的想法很简单,我们首先设置三个指针,两个指针来指向原有数组,一个指针指向合并后的数组,然后比较指针上的值。指针1指向arr1,指针二指向arr2,如果arr1 < arr2就把arr1的数放入新数组然后继续比较下一位。下面我们来看代码实现

    public static int[] mergeArr1(int[] arr1,int[] arr2){
        if (arr1 == null)return arr2;
        if (arr2 == null)return arr1;
        int[] result = new int[arr1.length + arr2.length];
        int p1 = 0;//用来指向arr1的位置的
        int p2 = 0;//用来指向arr2的位置的
        int pr = 0;//用来指向结构数组的位置
        while(p1 < arr1.length && p2 < arr2.length){
            if (arr1[p1] < arr2[p2]){
                result[pr] = arr1[p1];
                p1 ++;
            }else {
                result[pr] = arr2[p2];
                p2 ++;
            }
            pr ++;
        }
        //如果数组的数全取空了
        if (p1 == arr1.length){
            while (p2 < arr2.length){
                result[pr] = arr2[p2];
                p2 ++;
            }
        }else {
            while (p1 < arr1.length){
                result[pr] = arr1[p1];
                p1 ++;
            }
        }
        pr ++;
        return result;
    	}
    

    这个就是主要的流程,但是其中有很多代码冗杂,我们进行一些简化

    public static int[] mergeArr2(int[] arr1,int[] arr2){
        if (arr1 == null)return arr2;
        if (arr2 == null)return arr1;
        int[] result = new int[arr1.length + arr2.length];
        int p1 = 0;//用来指向arr1的位置的
        int p2 = 0;//用来指向arr2的位置的
        int pr = 0;//用来指向结构数组的位置
        //我们将判断数组是否取空了合并到这里来
        while(p1 < arr1.length || p2 < arr2.length){
            if (p2 >= arr2.length || p1 < arr1.length && arr1[p1] <= arr2[p2] ){
                result[pr] = arr1[p1];
                p1 ++;
            }else {
                result[pr] = arr2[p2];
                p2 ++;
            }
            pr ++;
        }
        return result;
    }
    

    链表的合并

    与数组的想法差不多,直接看代码吧

    public static Node mergeLinked(Node a,Node b){
      if (a == null)return b;
      if (b == null)return a;
      Node result = null;
      if (a.val < b.val){
          result = a;
          a = a.next;
      }else {
          result = b;
          b = b.next;
      }
      Node tail = result;
      while (a != null || b != null){
          if (b == null || a != null  && a.val < b.val){
              tail.next = a;
              tail = a;
              a = a.next;
          }else {
              tail.next = b;
              tail = b;
              b = b.next;
          }
      }
      return result;
    }
    

    排序算法

    排序的本质是什么?
    排序的本质是比较优先级,按照给的优先及比较然后交换,所有排序主要做的就是两个方法。

    比较
    public static boolean compare(int a ,int b ){
        if (a > b)return true;
        return false;
    }
    
    交换
    public static void change(int[] arr,int aIndex,int bIndex){
        int temp = arr[aIndex];
        arr[aIndex] = arr[bIndex];
        arr[bIndex] = temp;
    }
    

    冒泡排序

    首先介绍一下我们认识的第一个排序的方法,也是我觉得最简单的排序。冒泡排序的特点是一边比较一边交换,冒泡排序的主要思想是从第一个数到最后一个数逐次比较,如果数组中的数比选中的数要大就交换,如果不是就比较下一个知道所有数全比较完。以下是代码实现,其中的方法为上述方法。

    public static void changeSort(int[] arr){
        for (int j = 0 ; j < arr.length ; j++){//控制轮次
            for (int i = 0 ; i < arr.length-1-i;i++){
                if (compare(arr[i],arr[i+1])){
                    change(arr,i,i+1);
                }
            }
        }
    }
    

    虽然代码简单,但是性能不好。

    选择排序

    选择排序的思想呢和冒泡排序比较接近,选择排序是循环遍历数组找到一个最大值,然后再进行交换。以下是代码实现。

    public static void changeSout(int[] arr) {
        for (int j = 0; j < arr.length; j++) {
            int maxIndex = 0;
            for (int i = 0; i < arr.length - j; i++) {
                if (compare(arr[i], arr[maxIndex])) {
                    maxIndex = i;
                    //循环完一圈找到最大的数
                }
            }
            change(arr, maxIndex, arr.length - 1 - j);
        }
    }
    

    其实和冒泡排序没啥子太大区别也是双层循环嵌套,所以性能也不是太高。

    归并排序

    归并排序的思想比较容易理解,一个长的数组之间难以排序,但是只有两个数的数组就是天然有序的了,然后把有序的数组合并起来就排好序了。所以归并排序要做的就是把一个长数组对半分成两个数组,然后再把已经分开的数组再对半分直到数组里边只有两个值,然后把相邻的小数组合并。以下是代码实现。

    public static int[] mergeSort(int[] arr){
        //基于递归
        if (arr == null)return arr;
        return mergeSort(arr,0,arr.length);
    }
    
    
    
    public static int[] mergeSort(int[] arr,int begin,int end){//左闭又开区间
       if (end - begin > 2){
           //需要向下递归
           int[] resultA = mergeSort(arr,begin,begin + (end - begin)/2);
           int[] resultB = mergeSort(arr,begin+(end - begin)/2,end);
           return mergeArr2(resultA,resultB);
       }else if (end - begin == 1){
           return Arrays.copyOfRange(arr,begin,end);
       }else if (arr[begin] < arr[begin+1]){
           return new int[]{arr[begin],arr[begin + 1]};
       }else
           return new int[]{arr[begin + 1],arr[begin]};
    }
    

    快速排序

    快速排序也是基于递归实现,要想实现快速排序主要有以下几个步骤,
    一 选取组长
    二 数组的值与组长比较,小的放左边,大的放右边
    三 递归
    四 拼接
    以下是代码实现。

    //简单快速排序 但是在内部创建了很多的ArrarList 比较耗费空间
    public static ArrayList<Integer> quickSort(ArrayList<Integer> arr){
        if (arr == null || arr.size() <= 1)return arr;
        //选组长
        int leader = arr.get(0);
        //小的放左边,大的放右边
        ArrayList<Integer> left = new ArrayList<>();
        ArrayList<Integer> right = new ArrayList<>();
        for (int i = 1 ; i < arr.size();i++){
            if (arr.get(i) <= leader) left.add(arr.get(i));
            else right.add(arr.get(i));
        }
        //递归
        ArrayList<Integer> leftResult = quickSort(left);
        ArrayList<Integer> rightResult = quickSort(right);
        //拼接
        ArrayList<Integer> result = new ArrayList<>();
        result.addAll(leftResult);
        result.add(leader);
        result.addAll(rightResult);
        return result;
    }
    

    上边的快速排序是只有基础的思想,但是性能不好,我们对他进行一些改进,以下是代码实现

    public static void quickSort(int[] arr){
        quickSort(arr,0,arr.length-1);
    
    }
    
    public static void quickSort(int[] arr ,int low , int high){
        if (low >= high) return;
        int leader = arr[low];
        while(low < high){
            while (low < high && arr[high] >= leader) high--;
            arr[low] = arr[high] ;
            while (low < high && arr[low] <= leader) low++;
            arr[high] = arr[low] ;
        }
        arr[low] = leader;
        
        quickSort(arr,low,high-1);
        quickSort(arr,low+1,high);
    }
    
    展开全文
  • 分治算法入门

    2021-02-19 17:51:51
    一个复杂的问题分解成两个或者多个相同或相似的小问题,再小问题划分成更小的问题 分治算法可以求解的一些经典问题 二分搜索 大整数乘法 棋盘覆盖 合并排序 快速排序 线性时间选择 最接近点对问题 循环赛日程 ...

    分治算法

    韩顺平数据结构算法与笔记

    介绍

    一个复杂的问题分解成两个或者多个相同或相似的小问题,再把小问题划分成更小的问题

    分治算法可以求解的一些经典问题
    二分搜索
    大整数乘法
    棋盘覆盖
    合并排序
    快速排序
    线性时间选择
    最接近点对问题
    循环赛日程表
    汉诺塔

    难点:怎么把大问题划分成小问题

    基本步骤

    1)分解:将原问题分解为若干个规模较小,相互独立,与原问题形式相同的子问题

    2)解决:若子问题规模较小而容易被解决则直接解,否则递归地解各个子问题

    3)合并:将各个子问题的解合并为原问题的解。

    设计模式

    if |P|< nO		p代表问题的规模
    	then return(ADHOC(P))
    //将P分解为较小的子问题P1 ,P2..
    for i <-1 to k
    do yi <- Divide-and-Conquer(Pi)递归解决Pi |
    T <- MEREGE(12_,.yk)合并子问题
    return(T)
    

    其中|P|表示问题P的规模; n0为一阈值,表示当问题P的规模不超过n0时,. 问题己容
    易直接解出,不必再继续分解。ADHOC§是该分治法中的基本子算法,用于直接解
    小规模的问题P。~因此,当P的规模不超过n0时直接用算法ADHOC§求解。算法
    MERE(y/,2y2.yk)是该分治法中的合并子算法,用于将P的子问题P1 ,P2 …k的相应
    的解y.,2…yk合并为P的解。

    应用案例——汉诺塔

    思路

    我们从只有一个盘开始推导

    发现一个规律,我们可以把所有的盘看成只有两个盘,最下面的盘和上面所有的盘

    而且,总是把最下边的盘移动到第三个柱子上,然后把剩下上面的盘移动到第三个盘上就行了

    package 算法;
    //汉诺塔---------分治算法
    public class DAC {
    	public static void main(String[] args) {
    		hanoiTower(6, 'A', 'B', 'C');
    	}
    
    	/**
    	//汉诺塔的移动方案 -- 分治算法
    	 * @param num		盘子数目
    	 * @param a			第一个柱子
    	 * @param b			第二个柱子
    	 * @param c			第三个柱子
    	 */
    	public static void hanoiTower(int num,char a,char b,char c){
    		//如果只有一个盘
    		if(num == 1){
    			System.out.println("第一个盘从"+a+"->"+c);
    		}else{
    			//如果是 num>=2的情况,我们总是可以看做两个盘,最下面的盘和上面所有盘
    			//1.先把最上面的所有盘A->B
    			hanoiTower(num-1, a, c, b);
    			//2.把最下面的盘从A移动到C
    			System.out.println("第"+num+"个盘从"+a+"->"+c);
    			//3.把B塔所有盘--->C			移动过程使用到A塔
    			hanoiTower(num-1, b, a, c);
    		}
    	}
    }
    

    这个地方一定不能迷,我们在递归的时候,从那个柱子移动到那个柱子就是递归的时候前后位置一定要注意,a->c那就是abc a->b那就是acb,我们不能纠结这样写为啥就移上去了,自己知道流程就好

    展开全文
  • 去掉其中两个最大值和两个最小值的公式 去一行最高分最低分求平均值 在9个数值中去掉最高与最低然后求平均值 求最大值(n列) 如何实现求平均值时只对不等于零的数求均值? 得到单元格编号组中最大的数或最小的数 ...
  • EXCEL函数公式集

    热门讨论 2010-03-16 03:26:38
    去掉其中两个最大值和两个最小值的公式 去一行最高分最低分求平均值 在9个数值中去掉最高与最低然后求平均值 求最大值(n列) 如何实现求平均值时只对不等于零的数求均值? 得到单元格编号组中最大的数或最小的数 ...
  • 19、如何去掉单元格中间两个以上的空格? 30 20、打印表头? 31 七、Excel鲜为人知的35招秘技 31 1、建立分类下拉列表填充项 31 2、建立“常用文档”新菜单 32 3、让不同类型数据用不同颜色显示 32 4、制作“专业...
  • 1.3.5 给定一个整数数组和一个整数,返回两个数组的索引,这两个索引指向的数字的加和等于指定的整数。需要最优的算法,分析算法的空间和时间复杂度 1.3.6 假如给你一个新产品,你将从哪些方面来保障它的质量? ...
  • excel的使用

    2012-11-25 17:06:01
    实际输入的时候,通常应用等差数列输入法,先输入前二个值,定出自变量中数与数之间的步长,然后选中A2和A3两个单元格,使这二项变成一个带黑色边框的矩形,再用鼠标指向这黑色矩形的右下角的小方块“■”,当光标...
  • 0088. 合并两个有序数组 0101. 对称二叉树 0104. 二叉树的最大深度 0108. 将有序数组转换为二叉搜索树 0121. 买卖股票的最佳时机 0122. 买卖股票的最佳时机 II 0125. 验证回文串 0136. 只出现一次的数字 :point_...
  • 3、两个字的名字分散成多个字的距离;计算年龄,男、女性别转换成1或2。 4、任意列打印(例如:现有一张有[姓名、学号、性别、联系方式、语文、数学、总分、位次]等列,只想打印此中的[姓名、学号、语文、数学、...
  • B2.7 如果一个函数是两个其他函数的卷积,它的DFT 与另两个函数的DFT 是什么关系? 79 2.3.7 如何显示一幅图像的离散傅里叶变换? 83 2.3.8 当图像旋转后其离散傅里叶变换将会怎么样? 84 2.3.9 当图像平移后其...
  • arcgis工具

    2012-10-22 22:37:31
    26.快速把选择的要素另存为一图层并加载进来。 先选责需要另存图层的要素(直接选择或者属性),然后在图层上右键Selection/create Layer From Selected Features。 (以前都是直接export竟然没有发现) 27....
  • C++程序员面试宝典

    热门讨论 2013-04-01 13:36:19
    面试题155 什么是快速排序 176 面试题156 什么是希尔(Shell)排序 177 面试题157 什么是堆排序 179 13.7 排序算法的总结 180 第14章 软件工程(教学视频:39分钟) 182 14.1 软件工程基础 182 面试题158 什么是软件...
  • 最后左右两边的记录合并起来,得到的数据就是该点横向上的棋型,然后棋型的编号填入到Computer[x][y][n]中就行了(x、y代表坐标,n=0、1、2、3分别代表横、竖、左斜、右斜四方向)。而其他三方向的棋型也...
  • 16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • 算法导论(part2)

    2010-09-09 22:54:12
    ·动态规划的两个应用(第15.1节和第15.5节)。 ·利用随机化和线性规划技术的近似算法(第35.4节)。 ·为了使更多的算法可以更早地在书中出现,第1版中有关数学背景知识的三章内容从第一部分移到了附录中,即现在...
  • 算法导论(part1)

    2010-09-09 22:51:05
    ·动态规划的两个应用(第15.1节和第15.5节)。 ·利用随机化和线性规划技术的近似算法(第35.4节)。 ·为了使更多的算法可以更早地在书中出现,第1版中有关数学背景知识的三章内容从第一部分移到了附录中,即现在...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 17.介绍一下Hibernate的二级缓存 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message 属性, ...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message...
  • java面试宝典2012

    2012-12-16 20:43:41
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 135 17.介绍一下Hibernate的二级缓存 135 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • 16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • Java面试笔试资料大全

    热门讨论 2011-07-22 14:33:56
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • Java面试宝典2012新版

    2012-06-26 19:20:00
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • JAVA面试宝典2010

    2011-12-20 16:13:24
    16. hibernate进行多表查询每个表中各取几个字段,也就是说查询出来的结果集没有一个实体类与之对应如何解决; 123 17.介绍一下Hibernate的二级缓存 123 18、Spring 的依赖注入是什么意思? 给一个 Bean 的 message ...
  • vc++ 应用源码包_1

    热门讨论 2012-09-15 14:22:12
    压缩包内有两个源码包,一个是注册机源程序,另一个是解密机的源程序,一套完整的参考实例。 VC+MapX源码含GPS跟踪演示 VC3D 利用VC编程在界面上实现3D文字 在MFC应用程序中浏览PDF、Word文档文件 vcdialog 自...

空空如也

空空如也

1 2 3
收藏数 48
精华内容 19
关键字:

怎么快速把两个表合并