C语言排序,网络金融

By admin in 4858.com on 2019年3月26日

 

1.栈常用来贯彻的利用场景

C语言排序–Can you find it?(Hdu 2141)

Problem Description Give you three sequences of numbers A, B, C, then we
give you a number X. Now you need to calculate if you can find the three
numbers Ai, Bj, Ck, which satisfy the formula Ai+Bj+Ck = X.
Input There are many cases. Every data case is described as followed: In
the first line there are three integers L, N, M, in the second line
there are L integers represent the sequence A, in the third line there
are N integers represent the sequences B, in the forth line there are M
integers represent the sequence C. In the fifth line there is an integer
S represents there are S integers X to be calculated. 1<=L, N,
M<=500, 1<=S<=1000. all the integers are 32-integers.
Output For each case, firstly you have to print the case number as the
form “Case d:”, then for the S queries, you calculate if the formula can
be satisfied or not. If satisfied, you print “YES”, otherwise print
“NO”.
Sample Input

3 3 3
1 2 3
1 2 3
1 2 3
3
1
4
10

Sample Output

Case 1:
NO
YES
NO

题材大意: 输入数据第三排是三个数,分别表示多个数组的大小.
(四个数组的大小的最大值都以500) 接下来的三排是输入八个数组的数字.
然后第④排输入2个平头n表示接下去n排测试数据. 各样测试数据是二个整数m.
须求在上头的多少个数组中每一种数组找二个数(共多个数)相加之和十分该测试数据m.假使找到了就输出YES,要是不设有这么的四个数那么就输出NO.

大约思路:
因为题材给的数量各种数组最多有500个要素,那么只要多个for循环正是500*500*500势必超时,(姑且大家那边把第一次之第③数组叫为a,b,c数组)
这些时候大家可以把c数组排序,然后用八个for循环枚举a,b三个数组中装有结成的和k,然后再用二分查找在c数组中搜寻m-k这么些数.那样时间最多为500*500*log500≈2250000
可能是在a,b三个数组中具有组成的和k组成的数组中去二分查找m-c[i]其一数(以下代码就是).
代码如下:

#include 
#include 
using namespace std;
int a[501],b[501],m[250001],c[501],flag;
void find(int a[],int b,int n)
{
    int left,right,mid;
    left=0,right=n-1;
    while(left<=right)
    {
        mid=(left+right)/2;
        if(a[mid]==b)
        {
            flag=1;
            break;
        }
        else if(a[mid]>b)
            right=mid-1;
        else
            left=mid+1;
    }
}
int main()
{
    int i,j,k,n1,n2,n3,n4,ci=0;
    while(scanf("%d%d%d",&n1,&n2,&n3)!=EOF)
    {
        ci++;
        for(i=0;i

you find it?(Hdu 2141) Problem
Description Give you three sequences of numbers A, B, C, then we give
you a number X. Now you need to calculate if you can find th…

分治政策

正文包涵

  1. 分治的基本概念
  2. 二分查找
  3. 迅猛排序
  4. 归并排序
  5. 找出伪币
  6. 棋盘覆盖
  7. 最大子数组

源码链接:https://github.com/edisonleolhl/DataStructure-Algorithm/tree/master/Divede-and-conquer

出于工作中要求对大气数额开始展览火速校验,试验采纳读入内部存款和储蓄器List实体选用lamdba查找来促成。

函数调用  过程调度  表明式求值  树节点的深度优先遍历

分治的基本概念

  • 在排序算法中有种算法叫做归并排序,它选取了分治政策,在方针中,大家递归地求解四个难点,在每层递归中采纳如下八个步骤:

    • 演说(Divide)步骤将难点分割为一些子难点,子难点的样式与原难题一样,只是规模更小。
    • 消除(Conquer)步骤递归地求解出子难题,假使子难题的范畴丰富小,则甘休递归,直接求解。
    • 统一(Combine)步骤将子难题的解组合成原难题的解。
  • 当子难题丰硕大时,供给递归求解,大家誉为递归情状(recursive case)。

  • 当子难点充分小,不须要递归求解时,大家誉为“触底”,进入了主导气象(base
    case)。

  • 不可胜道时候,难点看上去并不是了如指掌的,能还是不能够用分治策略,可以取决于难题是或不是满意以下四条特色:

    • 该难点的局面压缩到一定的水准就足以简单地缓解;
    • 该难点能够表达为多少个规模较小的一样难点,即该难题具有最优子结构性格;
    • 选择该难点解释出的子难题的解能够统一为该难题的解;
    • 该难题所诠释出的各类子难题是互相独立的,即子难点之间不带有公共的子难点。
  • 递归式(recurrence)正是2个等式可能不等式,比如归并排序的最坏景况运营时刻:

           { θ(1)             若 n=1
      T(n)=|
           { 2T(n/2)+θ(n)     若 n>1
    

    求解可得 T(n)=θ(nlogn)

实在要求:实际读入内部存款和储蓄器数据
50W条记下主集数据,还富含约21个子集,子集最大记录数300W条记下。读入内部存款和储蓄器,校验出结果4分钟之内完结。

2.给定七个相同造型的硬币和三个天平,当中三个比其他都重的找到共索要至少多少次?

二分查找

  • 咱俩先看个简易的例子,二分查找,假若大家想要查找 x
    是不是留存于已排体系 a[] 中。

百度百科:借使线性表里唯有二个成分,则只要比较那么些因素和x就能够分明x是还是不是在线性表中。由此那么些标题满足分治法的率先个适用规则;同时大家注意到对于排好序的线性表L有以下性质:相比较x和L中随意3个成分L[i],若x=L[i],则x在L中的地方正是i;假如x<L[i],由于L是一日千里排序的,由此借使x在L中的话,x必然排在L[i]的前方,所以大家假诺在L[i]的眼下查找x即可;假若x>L[i],同理大家只要在L[i]的前面查找x即可。无论是在L[i]的前面依旧背后查找x,其艺术都和在L中查找x一样,只可是是线性表的规模压缩了。那就表达了此难题满意分治法的第四个和第⑤个适用标准。很明白此难点解释出的子难点相互独立,即在L[i]的先头或后边查找x是独立的子难点,因而满足分治法的第四个适用原则。

  • 二分查找的骨干考虑是将n个成分分成大致相当于的两部分,取a[n/2]与x做比较。

    • 如果x=a[C语言排序,网络金融。n/2]4858.com,,则找到x,算法中止;
    • 如果x<a[n/2],则只须求在 a[] 的左半有个别继续搜索 x;
    • 如果x>a[n/2],则只须求在 a[] 的右半部分继续搜索 x。
  • 容易明白,时间复杂度无非正是迭代的次数,O(logn)

  • 运用 while 循环的伪代码:

      BinarySearch(max,min,des)
          mid-<(max+min)/2
          while(min<=max)
              mid=(min+max)/2
              if mid=des then
                  return mid
              elseif mid >des then
                  max=mid-1
              else
                  min=mid+1
          return
    
  • 使用迭代的 Python 代码:

      def binary_search(A, x, low, high):
          if low == high:
              return -1
          mid = (low + high) // 2
          if A[mid] == x:
              return mid
          result_left = binary_search(A, x, low, mid)
          print("left", result_left)
          result_right = binary_search(A, x, mid+1, high)
          print("right", result_right)
          if result_left != -1:
              return result_left
          elif result_right != -1:
              return result_right
          else:
              return -1
    
      A = list(range(10))
      print(binary_search(A, 3, 0, len(A)-1))
    
  • 输出

      left -1
      right -1
      left -1
      right -1
      left -1
      right 3
      left 3
      left -1
      right -1
      left -1
      right -1
      left -1
      left -1
      right -1
      right -1
      right -1
      3
    

测试数据读入内部存款和储蓄器后占用约2-3G内部存款和储蓄器。那里测试了十六线程读取数据,但提速效果并不鲜明。SQLServer有谈得来的SQL执行排队机制(读入数据经过境遇一个小插曲,读入速度慢,占用内部存款和储蓄器大,无意中发觉是把记录照片流也读入了内部存款和储蓄器。实际处理数据经过并不须求照片新闻。去掉后速度进步一点都不小,占用内部存款和储蓄器也紧缩很多,现在遭遇类似操作应提前排除那类情状了)

3.一旦急需对10W个英文单词举办前缀匹配搜索,上面哪一种数据结构最合适

快快排序

  • 火速排序的为主考虑是基于分治法的

  • 对于输入的子系列L[p..r],假如局面丰硕小则间接开始展览排序,不然分三步处理:

    • 表明(Divide):将输入的连串L[p..r]细分成三个非空子体系L[p..q]和L[q+1..r],使L[p..q]中任一成分的值非常小于L[q+1..r]中任一成分的值。
    • 递归求解(Conquer):通过递归调用急忙排序算法分别对L[p..q]和L[q+1..r]拓展排序。
    • 集合(Merge):由于对演讲出的多少个子系列的排序是就地拓展的,所以在L[p..q]和L[q+1..r]都排好序后不要求实行其余总结L[p..r]就已排好序。
  • 以此消除流程是相符分治法的着力步骤的,由此,急迅排序法是分治法的经文应用实例之一。

  • 端详见前边写的排序算法:http://www.jianshu.com/p/7cb29ad6d0f7

多中将验脚本由另3个同事写的,大约有500个校验,实体字段合法性校验,及主集子集关联合检查验。初始获得脚本丢进来测试,结果半个钟头也没影响。果断甘休进度。然后正是惨痛的优化进度,曾经质疑那样的主意行不通。大约用了两周时间,达到5000个主集音讯10秒之内实现。50W数据也在3-六分钟成功。最终形成玖十五个冒出测试。校验结果符合规律重回。一切OK现已符合规律上线使用。

B+树  AVL树  哈希表  Trie树

归并排序

  • 也是分治政策的特出应用,具体见排序算法,小说了链接同上。

 

4.F(n)=F(n-1)+n+1(n>1)的递归终止条件是

x^n

  • 输入 x 与 n,求 x^n

  • 最朴素的办法正是把 x 连乘 x,那样须要时间复杂度为 Θ(n)

  • 只是只要把总括式分解成奇数和偶数的景况,时间复杂度降为 Θ(logn)

      x^n = x^(n/2) × x^(n/2)  当 n 为偶数
            x^(n-1/2) × x^(n-1/2) ×  当 n 为奇数
    

以下是在本次数据校验达成进度中总结出来应小心的一些地点。

F(0)=1  F(1)=0  F(0)=0  F(1)=1

找出伪币

  • 给您2个具备十五个硬币的荷包。16个硬币中有三个是假冒的,并且丰硕伪造的硬币比真正硬币要轻一些。你的职责是找出那几个伪造的硬币。为了帮助你成功这一任务,将提供一台可用来比较两组硬币重量的仪器,利用那台仪器,能够知晓两组硬币的份量是还是不是同样。

  • 能够想到,2个非常的粗略的措施正是暴力枚举法:

    • 正如硬币1与硬币2的轻重。假使硬币1比硬币2轻,则硬币1是伪造的;若是硬币2比硬币1轻,则硬币2是名不副实的。这样就完毕了任务。

    • 要是两硬币重量相等,则相比较硬币3和硬币4。同样,假若有3个硬币轻一些,则寻找伪币的天职成功。要是两硬币重量相等,则持续相比较硬币5和硬币6。依据那种艺术,可以最多通过五次相比来判断伪币的存在并能够找出这一伪币。

  • 除此以外一种艺术正是运用分而治之的措施:

    • 要是把16硬币的例证看成三个大的题材。

    • 率先步,把这一标题分成三个小标题。随机选用七个硬币看成第①组称为A组,剩下的七个硬币看成第壹组称为B组。那样,就把15个硬币的标题分成多个8硬币的题目来缓解。

    • 其次步,判断A和B组中是还是不是有伪币。能够利用仪器来比较A组硬币和B组硬币的重量。假使两组硬币重量相等,则能够断定伪币不设有,此时径直甘休算法。如若两组硬币重量不对等,则存在伪币,并且能够看清它放在较轻的那一组硬币中,然后继续把较轻组的硬币继续划分为两组,放在仪器中相比重量。从来如此迭代下去,直至两枚硬币比较,较轻的这枚正是伪币。

  • 当然,假诺硬币数量为奇数的话就不能够这么不难了,但是此地只是为了展示分治的考虑,所以先用偶数表明概念。


5.一个子串由两个A,九个B组成,且满意全数前缀子串中A个数>=B个数,问那规范串有?

棋盘覆盖

  • 题材讲述:在一个 2k×2k
    个方格组成的棋盘中,恰有2个方格与其余方格不一致,称该方格为一异样方格,且称该棋盘为一尤其棋盘。在棋盘覆盖难题中,要用图示的4种差异形态的L型骨牌覆盖给定的特殊棋盘重三特种方格以外的有着方格,且任何二个L型骨牌不得重叠覆盖。

    4858.com 1

    4858.com 2

  • 分析:

    • 当 k>0 时,将 2k×2k 棋盘分割为 4 个
      2(k-1)×2(k-1) 的 子棋盘,如下图 a 所示。

    • 新鲜方格必位于陆个较小子棋盘之第一中学,别的三个子棋盘中无尤其方格。为了将那一个无特殊方格的子棋盘转化为特殊棋盘,能够用一个L型骨牌覆盖那二个较小棋盘的会面处,如
      (b)所示,从而将原难题转化为四个较小范围的棋盘覆盖难题。递归地行使那种分割,直至棋盘简化为棋盘1×1。

      4858.com 3

  • 金镶玉裹福禄双全:每一次都对私分后的几个小方块进行判定,判断特殊方格是或不是在其间。这里的判定的法子是历次先记下下全部大方块的左上角(top
    left
    coner)方格的种类坐标,然后再与特种方格坐标进行相比,就足以知晓卓殊方格是不是在该块中。假使非凡规方块在其中,那平素递归下去求即可,如若不在,则遵照分割的多少个方块的比不上岗位,把右下角、左下角、右上角要么左上角的方格标记为独特方块,然后继续递归。那样大家就依据供给填写了全体棋盘。

壹 、由原来数据库校验改为内部存款和储蓄器校验,内部存款和储蓄器速度更快,数据库校验还会推动并发等待,死锁等难题。

6.CPU利用率与出新进度数关系

最大子数组

  • 题材叙述:输入3个整形数组,数组里有正数也有负数。数组中延续的三个或五个整数组成1个子数组,每一种子数组都有3个和。设计一种算法求出输入数组的最大子数组以及相应的子数组和是不怎么。

  • 譬如输入的数组为

      13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7
    

    那就是说最大的子数组为

      18,20,-7,12
    

    因而输出该子数组

      43, 7, 10
    

② 、加载数据足以行使多线程加载

过程数多时,提升并发进程数,能够狠抓CPU利用率

解法一:暴力求解

  • 五个 for 循环,时间复杂度 O(n^2)

  • 思路:

  • 代码:

    def di_cal_wrong(A):
        max_sub_sum = -float('inf')  # init
        for i in range(len(A)):
            for j in range(i+1, len(A)):
                if sum(A[i:j+1]) > max_sub_sum:
                    max_sub_sum = sum(A[i:j+1])
                    low = i
                    high = j
        return(max_sub_sum, low, high)
    
    A = [13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7]
    print(di_cal(A))
    
  • 输出:

    (43, 7, 10)
    
  • 思想:上述代码有错吗?

  • Python 列表的切片操作,假设放在类似于 Java 、C
    之类的言语中,想要完结的话得经过 for 循环然后挨家挨户增加,那时岂不是一个for 循环嵌套了?

  • 更正:每当 j 增加1后,令 sum = sum + A[J],然后再相比较 sum 是或不是低于
    max_sub_sum,那样就兑现了一次 for 循环嵌套。

  • 校对后的代码:

    def di_cal(A):
        sum = A[0]
        max_sub_sum = -float('inf')  # init
        for i in range(len(A)):
            sum = A[i]
            for j in range(i+1, len(A)):
                sum += A[j]
                if sum > max_sub_sum:
                    max_sub_sum = sum
                    low = i
                    high = j
        return(max_sub_sum, low, high)
    
  • 行使 timeit 模块测试八个函数的属性

    print(di_cal_wrong(A))
    print(di_cal(A))
    
    t1 = Timer("di_cal([13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7])", "from __main__ import di_cal")
    print("di_cal ", t1.timeit(number=1000), "seconds")
    
    t1 = Timer("di_cal_wrong([13,-3,-25,20,-3,-16,-23,18,20,-7,12,-5,-22,15,-4,7])", "from __main__ import di_cal_wrong")
    print("di_cal_wrong ", t1.timeit(number=1000), "seconds")
    
  • 输出

    (43, 7, 10)
    (43, 7, 10)
    di_cal  0.017742687098883683 seconds
    di_cal_wrong  0.05528770369116012 seconds
    
  • 可以看出,很强烈 di_cal_wrong(A) 代码的天性要差于
    di_cal(A),所以落成算法时必定要过细,Python
    不难选用,不过不能够把集成好的法力当作基本操作来采用。

叁 、主键使用整形加快查询速度 那点专门首要,速度提高上千倍。

并发进程导致内部存款和储蓄器访问减小

解法二:分治策略

  • 倘若大家要寻找 A[low..high] (假如low<high)的最大子数组,使用分治策略意味着要将以此数组分解为八个范畴尽量相等的子数组,即找到主旨地点:mid=(low+high)/2。

  • 然后分解为三个子数组:A[low..mid],A[mid+1..high]

  • 可以设想,A[low..high] 的最大子数组必然是以下三种状态之一

    • 一齐位于左侧子数组中 A[low,mid]
      中,此时得以解能够象征为:A[i..mid]
    • 全然位于右边子数组中 A[mid,high]
      中,此时得以解可以象征为:A[mid+1..high]
    • 超越了中间,此时解能够表示为 A[i..mid]+A[mid+1..j]
  • 如此那般,在任何情状下,三个标题能够分为三个子难点,大家得以递归地求解
    A[i..mid] 与
    A[mid+1..high],因为那五个子难点仍旧是最大子数组难题,只是规模压缩了1/2而已。

  • 所以大家先消除第三种情景:

    • 以 mid
      为着力,向左向右依次找最大子数组,那些时候只要求线性时间就能够找到了

    • find_max_crossing_subarray:

      def find_cross_suming_subarray(A, mid, low, high):
          # 最大子数组横跨中点,所以最大子数组的左边是A[i..mid],右边是A[mid+1..j]
          # 求 A[i..mid] 可以直接用暴力求解法,从 mid 开始从左依次相加,判断一下,然后赋值即可,求 A[mid+1..j] 是同样的方法
          left_sum, right_sum = 0, 0
          max_left_sum, max_right_sum = -float('inf'), -float('inf')
          # 注意 range(start,stop,step),包括start,不包括stop,所以对应的low-1 与 high+1
          for i in range(mid, low-1, -1):
              left_sum += A[i]
              if left_sum > max_left_sum:
                  max_left_sum = left_sum
                  low = i
          for j in range(mid+1, high+1, 1):
              right_sum += A[j]
              if right_sum > max_right_sum:
                  max_right_sum = right_sum
                  high = j
          return max_right_sum+max_left_sum, low, high
      
    • 有了第三种意况的拍卖,接下去能够编写递归的函数了,注意要在开头判断跳出递归的准绳:

      def divide_and_conquer(A, low, high):
          if low == high:
              return A[low], low, high
          mid = (low + high) // 2
      
          left_sum, left_low, left_high = divide_and_conquer(A, low, mid)
          print("left:", left_sum, left_low, left_high)
          right_sum, right_low, right_high = divide_and_conquer(A, mid+1, high)
          print("right:", right_sum, right_low, right_high)
          cross_sum, cross_low, cross_high = find_cross_suming_subarray(A, mid, low, high)
          print("cross:", cross_sum, cross_low, cross_high)
      
          if left_sum > right_sum and left_sum > cross_sum:
              return left_sum, left_low, left_high
          elif right_sum > left_sum and right_sum > cross_sum:
              return right_sum, right_low, right_high
          else:
              return cross_sum, cross_low, cross_high
      
    • 专注到递归后历次的结果都输出到控制台上,在处理递归难点时,小编意识
      log 比 debug
      代码要不难驾驭得多了,有趣味的爱侣能够一步一步看看是何许输出的

      left: 13 0 0
      right: -3 1 1
      cross: 10 0 1
      left: 13 0 0
      left: -25 2 2
      right: 20 3 3
      cross: -5 2 3
      right: 20 3 3
      cross: 5 0 3
      left: 20 3 3
      left: -3 4 4
      right: -16 5 5
      cross: -19 4 5
      left: -3 4 4
      left: -23 6 6
      right: 18 7 7
      cross: -5 6 7
      right: 18 7 7
      cross: -21 5 7
      right: 18 7 7
      cross: 17 3 4
      left: 20 3 3
      left: 20 8 8
      right: -7 9 9
      cross: 13 8 9
      left: 20 8 8
      left: 12 10 10
      right: -5 11 11
      cross: 7 10 11
      right: 12 10 10
      cross: 25 8 10
      left: 25 8 10
      left: -22 12 12
      right: 15 13 13
      cross: -7 12 13
      left: 15 13 13
      left: -4 14 14
      right: 7 15 15
      cross: 3 14 15
      right: 7 15 15
      cross: 18 13 15
      right: 18 13 15
      cross: 16 8 15
      right: 25 8 10
      cross: 43 7 10
      (43, 7, 10)
      

肆 、采取lamdba表明式查找数据 用联合查询代替for循环

区域性特征的下降会导致缺页率上涨和CPU利用率下跌

解法三:联机算法

  • 《算法导论》中的练习4.1-5提供了一种更高效地消除最大子数组的算法

  • 从数组的右边界开端,从左往右处理,记录到方今停止已经处理过的最大子数组。

  • 若果大家曾经掌握了 A[1..j]
    的最大子数组,那么往右处理时,能够服从如下性质:

    • 数组 A[1…j+1] 的最大子数组,有三种情状:

      • A[1…j] 的最大子数组

      • A[i…j+1]

  • 那正是说什么样求得 A[i…j+1] 呢?

    • 率先不难想通:假使一个数组 a[1..r]
      求和取得负值,那么下三回往右处理时,能够直接把在此以前的笔录整个清空,因为下次操作时的
      a[r+1],还不比直接把团结当作解(至少源点要从此处开头),因为
      a[1..r]+a[r+1]<a[r+1]。

    • 由此只要某次操作时,求和为负,那么直接把和清0,重新总括最大子数组,并且把源点设置为下一个要操作的序数。

    • 代码:

      def linear_time(A):
          sum, max_sub_sum, low, high, cur = 0, 0, 0, 0, 0
          for i in range(0, len(A)):
              sum += A[i]
              if sum > max_sub_sum:
                  max_sub_sum = sum
                  # 起点从0开始,从左往右操作
                  low = cur
                  high = i
              # 每当和小于0时,丢弃之前处理过的所有记录,最大和清0,并且起点从下一位开始
              if sum < 0:
                  sum = 0
                  cur = i + 1
          return max_sub_sum, low, high
      
  • 在网上查看了好久,上述解法应该属于联机算法,可是挺不难驾驭的,并且时间复杂度的确是
    O(n),常量空间,不须求帮衬空间拓展,相当慢。

百度周到:联机算法是在随心所欲时刻算法对要操作的数量只读入(扫描)二回,一旦被读入并拍卖,它就不须要在被纪念了。而在此处理进程中算法能对它早已读入的数额及时付给相应子种类难题的不易答案。

五 、依据数据量的轻重缓急采取分别选拔线性查找或二分查找进步查询速度

出现进度的内部存款和储蓄器访问扩张了访存的局地性格。

解法四:动态规划

  • 那种解法同样能够兑现线性时间复杂度

  • 假定有四个数组a[1..n],若记 b[i] 为:以 a[i]
    结尾的子数组的最大和,即

      b[i]=max{sum(a[j~k])}, 其中0<=j<=i,j<=k<=i。
    
  • 据此对此数组 a[0..n] 的最大子数组的和为

      max{b[0], b[1], b[2], .., b[n]}
    

    即求 b[] 的最大值

  • 由 b[i] 的概念可易知

      当 b[i-1]>0 时,b[i]=b[i-1]+a[i]
      否则 b[i]=a[i]。
    
  • 故b[i]的动态规划递归式为:

      b[i] = max(b[i-1]+a[i], a[i]),1<=i<=n
    
  • 代码如下:

      def dp(A):
          low, high = 0, 0
          B = list(range(len(A)))
          B[0] = A[0]
          max_sub_sum = A[0]
          for i in range(1, len(A)):
              if B[i-1] > 0:
                  B[i] = B[i-1] + A[i]
              else:
                  B[i] = A[i]
                  low = i
              if B[i] > max_sub_sum:
                  max_sub_sum = B[i]
                  high = i
          return max_sub_sum, low, high
    

倍感解法三 、解法四很像,等到时候学习动态规划了,再来好好斟酌探讨解法四的精髓。

六 、共用数码只取贰遍,在全部校验中全局使用。

7.500*400的疏散矩阵,有二十一个非0成分,设各类整形数占2个字节,则用长富组表示该矩阵时,所供给字节数是。

找出数组中最大的七个数

参考摄像:http://www.xuetangx.com/courses/course-v1:TsinghuaX+30240184\_p1+sp/courseware/b64e822fe8bf4fc18e86a560087efebc/e794869faa9844528206ba3e9ab6b640/

本人感觉摄像中前两种办法有点点难题,把 A[0] 作为 x1, x2
的初值,有个别刁钻的测试用例会有错误的出口,所以小编把初值都改为了负无穷大,相应的,相比较的次数会多一次,可是分析的思辨没变。

  • 输入:2个数组

  • 输出:数组中的最大值 x1 以及次大值 x2

  • 假使数组允许再一次成分,那么必有 x1 > x2 ; 不然 x1 ≥ x2

    录像中希望的出口是 x1 ≥ x2,那样的渴求放松了限制,把 A[0] 作为
    x1, x2
    的初值就好像没毛病,然而为了深切思考,笔者说了算严厉限定出口,那样对编制程序思想的增强会有较大帮扶。

  • 办法一——暴力枚举法:

    • 率先趟循环找出数组的最大值 x1,n 次相比

    • 第2趟循环找出数组开始到最大值序号之间的次大值

    • 其三趟循环找出数组最大值的序号到最后之间的次大值,与位置加起来是
      n-1 次相比较

    • 约莫需求通过 2n-1 次相比较

      def max2_force(A):
          x1 = -float('inf')
          x2 = -float('inf')
          for i in range(len(A)):
              if A[i] > x1:
                  x1 = A[i]
                  j = i
          for i in range(j):
              if A[i] > x2:
                  x2 = A[i]
          for i in range(j + 1, len(A)):
              if A[i] > x2:
                  x2 = A[i]
          return x1, x2
      
  • 艺术二——暴力枚举法立异版:

    • 唯有一趟循环,每一次循环时,先把当下值与次大值相比较,再进一步把次大值与最大值相比较

    • 最佳状态:每回相比较都低于次大值,所以比较次数为 n

    • 最坏情况:每趟相比都超出次大值,所以相比次数 2n

      def max2_force_improve(A):
          x1 = -float('inf')
          x2 = -float('inf')
          for i in range(len(A)):
              if A[i] > x2:
                  x2 = A[i]
                  if x2 > x1:
                      x1, x2 = x2, x1
          return x1, x2
      
  • 方法三——分治法:

    • 时间复杂度:T(n) = 2*T(n/2) + 2 = 5n/3 – 2

      def max2_divide_and_conquer(A, low, high):
          if low == high:
              return A[low], A[low]
          elif low + 1 == high:
              if A[low] > A[high]:
                  return A[low], A[high]
              else:
                  return A[high], A[low]
          else:
              mid = (low + high) // 2
              x1_left, x2_left = max2_divide_and_conquer(A, low, mid)
              x1_right, x2_right = max2_divide_and_conquer(A, mid + 1, high)
              if x1_left > x1_right:
                  if x2_left > x1_right:
                      return x1_left, x2_left
                  else:
                      return x1_left, x1_right
              else:
                  if x2_right > x1_left:
                      return x1_right, x2_right
                  else:
                      return x1_right, x1_left
      

并发测试 时意识 静态类中的静态属性不是平安的 因为静态类在内部存款和储蓄器中只有一份
去掉static 后二十四线程测试平常

8.在显要词随机分布意况下,二叉查找树的搜寻长度与哪些查找相当

 

斐波那契查找  插值查找  顺序查找  二分查找

以下为测试数据,及相关评释,能够直接忽略。感兴趣的的可以看看。

9.给定3个数组235617849,建立小根堆,数组体系是有点?


10.关于JAVA类加载。

一 、7万条记下

11.JAVA汇聚中迭代器Iterator的fail-fast机制,抛出的分外是?

A01.FindAll(x => !x.PersonStatus.In(“01”, “02”, “03”, “04”))

12.Java数据结构List和Set。

巡回查找,共加载152玖拾柒位,耗费时间:0.019549秒.

13.下列编辑器能够通过的

A01.FindAll(x => !(x.PersonStatus == “01” || x.PersonStatus == “02”
|| x.PersonStatus == “03” || x.PersonStatus == “04”))

short x[1][1] = new short[][];

循环查找,共加载1529六个人,耗时:0.0284169秒.

long []x[] = new long[1][1]

 

int x[][] = new int[1][1];

二 、3.3万条记录 x.CodeID == “ZB01″的有3300条记下

byte x[][] = new byte[][];

Codes.FindAll(x => x.CodeID == “ZB01” && (x.CodeItemName == “市辖区”
|| x.CodeItemName == “县”))

14.有关Java中等射程序调优响应能力和吞吐量描述。

巡回查找,共加载28七人,耗费时间:0.0139286秒.

15.有关Java锁说法科学的

Codes.FindAll(x => x.CodeID == “ZB01” && (x.CodeItemName.In(“市辖区”,
“县”)))

动用Lock的获得锁方法后,最佳使用finally代码块释放锁

巡回查找,共加载2八十七个人,耗费时间:0.0230568秒.

Synchronized和Lock都以可重入锁

 

Synchronized通过动用对象监视器由JVM达成

3、4000条记录 codeIds有3300条记录

Synchronized只好功能于艺术,不可能在代码块使用。

personTableList.A01.FindAll(x => !x.A0114.In(codeIds));

16.关于Oracle Hotspot Java虚拟机

A01 五千条记录 循环查找,共加载0人,耗费时间:0.1066983秒.

17.哪个种类形式会造成对应线程让出CPU?

A01 7万条记录 循环查找,共加载0人,耗费时间:1.7386399秒.

增长别的线程的调度优先级

foreach (var A01 in personTableList.A01)

抛出Runtime Ecxeption

            {

日增了子线程并调度执行线程

                if (!codes.Exists(x => x.CodeItemID == A01.A0114))

调用sleep函数

                {

18.JVM内部存款和储蓄器配置参数如下:_Xmx2048m _Xms2048m _Xmm1024m
_XX:MaxPermSize=256m_xxSurNokiarRatio=2,个中相当的小内部存款和储蓄器值和Sur红米r区总大小分别是

                    persons.Add(A01);

19.简述Java8在Java语法上的首要性创新。

                }

            }

 

地点形式代码,三个列表都以7W条记下时

循环查找,共加载7560一位,耗费时间:55.4800723秒.

巡回查找,共加载7560一位,耗费时间:107.4412256秒.

 

3、

A01.FindAll(x => x.W0111G == “”)

巡回查找,共加载18四位,耗时:0.0039961秒.

A01.FindAll(x => x.W0111G.IsSame(“”))

巡回查找,共加载18四位,耗费时间:0.0307353秒.

 

 

A01.FindAll(x => ids2.IndexOf(x.PersonID))  最快

A01.FindAll(x => x.PersonID.In(personIds)) 第二

A01.FindAll(x => ids2.Contains(x.PersonID))  第二 

A01.FindAll(x => ids2.Exists(p=>p == x.PersonID)) 最慢

 

同台查询 速度快

var query = (from A14 in DataList.A14

                         join A01 in DataList.A01

                           on A14.ID equals A01.ID

                         select new { A14.ID, A14.A1407, A01.A0141
}).ToList();

            personIds = query.FindAll(x => x.A0141 > x.A1407)

格外首要 主键字段 整形字段比字符串快上百倍

 

 

线性查找:Contains,Find,IndexOf都以线性查找。

二分查找:BinarySearch,因为二分查找必须是对有序数组才使得,所以寻找前要调用List的Sort方法。

敲定:假如List项的个数相比较小,用线性查找要略快于二分查找,项的个数越来越多二分算法优势越强烈。可依照真实景况选取适合的查找方法。

测试数据2条

耗时:0.0186627秒.

二分耗费时间:0.0356611秒.

 

 

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有