1.4 算法分析

练习

1.4.1 证明从N个数中取三个整数的不同组合为 N(N-1)(N-2)/6.     /*下面的证明也恰好符合帕斯卡恒等式(1.1.27)*/

方法一:直接根据排列组合的知识---C(N,3)=N(N-1)(N-2)/6

方法二:数学归纳法如下

1.4.2 修改TreeSum,正确处理两个较大的int值相加可能溢出的情况          /*对一些"极端"情况进行考虑*/

public class ThreeSum
{
    public static int count(int[] a)
    {
        int N=a.length;
        int cnt=0;
        for(int i=0;i<N;i++)
            for(int j=i+1;j<N;j++)
                for(int k=j+1;k<N;k++)
                    if((long)a[i]+a[j]+a[k]==0)   //采用long来避免溢出情况
                        cnt++;
        return cnt;
    }

    public static void main(String[] args)
    {
        @SuppressWarnings("deprecation")
        int[] a=In.readInts(args[0]);
        StdOut.println(count(a));
    }
}

1.4.3 修改DoublingTest,使用StdDraw产生类似于正文中的标准图像和对数图形,根据需要调整比例使图像总能够充满窗口的大部分区域     /*进一步对库函数StdDraw的理解和运用,以及根据图像分析增长的数量级*/

public class DoublingTest
{
    public static double timeTrial(int N)
    {
        int MAX=1000000;
        int[] a=new int[N];
        for(int i=0;i<N;i++)
            a[i]=StdRandom.uniform(-MAX, MAX);
        Stopwatch timer=new Stopwatch();
        ThreeSum.count(a);
        return timer.elapsedTime();
    }

    public static void main(String[] args)
    {
        int MAX=4000;int i=0;
        int len=(int)(Math.log(MAX/250)/Math.log(2))+1;
        int[] arrN=new int[len];
        double[] timeN=new double[len];
        for(int N=250;N<=MAX;N+=N)
        {
            double time=timeTrial(N);
            StdOut.printf("%7d %5.1f\n",N,time);
            arrN[i]=N;
            timeN[i++]=time;
        }
//        drawStandard(arrN,timeN);
        drawLog(arrN,timeN);
    }
    //绘制标准图形
    public static void drawStandard(int[] n,double[] time)
    {
        StdDraw.setXscale(-0.5,1.2*n[n.length-1]/1000.0);
        StdDraw.setYscale(-0.5,time[n.length-1]*1.2);
        //建立坐标系
        StdDraw.setPenColor(StdDraw.BLACK);
        StdDraw.setPenRadius(0.001);
        StdDraw.line(0, 0, 1.1*n[n.length-1]/1000, 0);
        StdDraw.line(0, 0,0, 1.1*time[n.length-1]);
        for(int i=1;i<1.1*n[n.length-1]/1000.0;i++)
            StdDraw.text(i,-0.2,i+"K");
        for(double t=2;t<time[n.length-1]*1.1;t+=2)
            StdDraw.text(-0.2, t, t+"");
        //绘制图像
        StdDraw.setPenColor(StdDraw.BOOK_RED);
        StdDraw.setPenRadius(0.02);
        for(int i=0;i<n.length;i++)
            StdDraw.point(n[i]/1000.0, time[i]);
    }
    //绘制对数图形
    public static void drawLog(int[] arrN,double[] timeN)
    {
        //将时间转换为其对数
        double[] timelog=new double[timeN.length];
        for(int i=0;i<timeN.length;i++)
            timelog[i]=Math.log(timeN[i]);
        StdDraw.setXscale(-0.5,1.2*arrN[arrN.length-1]/1000.0);
        StdDraw.setYscale(-0.5,timelog[arrN.length-1]*1.2);
        //建立坐标系
        StdDraw.setPenColor(StdDraw.BLACK);
        StdDraw.setPenRadius(0.001);
        StdDraw.line(0, 0, 1.1*arrN[arrN.length-1]/1000, 0);
        StdDraw.line(0, 0,0, 1.1*timelog[arrN.length-1]);
        for(int i=1;i<1.1*arrN[arrN.length-1]/1000.0;i++)
            StdDraw.text(i,-0.2,i+"K");
        for(double t=0;t<timelog[arrN.length-1]*1.1;t+=timelog[arrN.length-1]/5)
            StdDraw.text(-0.2, t, String.format("%.2f",t));
        //绘制图像
        StdDraw.setPenColor(StdDraw.BOOK_RED);
        StdDraw.setPenRadius(0.02);
        for(int i=0;i<arrN.length;i++)
            StdDraw.point(arrN[i]/1000.0, timelog[i]);
    }
}

注:以下的实现中并没有根据需要比例自动调整,此外也多了一个MAX来确定范围(上面写的还是有一定问题,待改进)

1.4.5 给出下面这些量的近似    /*主要参考表1.4.2典型的近似   进一步理解近似*/

a. N+1~N

b. 1+1/N~1

c. (1+1/N)(1+2/N)~1

d. 2N3-15N2+N~2N3

e. lg(2N)/lgN~1

f. lg(N2+1)/lgN~2

g. N100/2N~?(模拟了一下,N非常大时NaN)

1.4.6 给出以下代码段的运行时间的增长数量级(作为N的函数):    /*粗略了解求解增长数量级的方式*/

     a. int sum=0;
        for(int n=N;n>0;n/=2)
            for(int i=0;i<n;i++)
                sum++;

     b. int sum=0;
        for(int i=1;i<N;i*=2)
            for(int j=0;j<i;j++)
                sum++;

     c. int sum=0;
        for(int i=1;i<N;i*=2)
            for(int j=0;j<N;j++)
                sum++;

增长数量级取决于 sum++的运行次数

a. (N+N/2+N/4...)   总共有 log2N 个元素,最后一个元素满足 2^(k-1)<=N

b. (1+2+4+...)  最后一个元素满足 2k<=N

c. NlogN

1.4.7 以统计涉及输入数字的算术操作(和比较)的成本模型分析ThreeSum.

即统计 if (a[i] + a[j] + a[k] == 0) 语句执行的次数,由表1.4.4可知 D---N3/6-N2/2+N/3~N3/6

1.4.8 编写一个程序,计算输入文件中相等的整数对的数量.如果你的第一个程序是平方级别的,请继续思考并以Array.sort()给出一个线性对数级别的解答

/*如何将一个N2的算法改进到NlogN是一个很重要也经常需要做的优化*/

public class H1_4_8
{
    public static void main(String[] args)
    {
        //这段是为了产生一些随机数
//        int max=100000;
//        Out out=new Out("h1_4_08.txt");
//        for(int i=0;i<300000;i++)
//            out.printf("%d ", StdRandom.uniform(-max, max));

        In in = new In("h1_4_08.txt");
        int[] a = in.readAllInts();
        in.close();

        Stopwatch timer = new Stopwatch();
        int cnt = countFast(a);
        StdOut.println("elapsed time = " + timer.elapsedTime());
        StdOut.println(cnt);
        timer = new Stopwatch();
        cnt = count(a);
        StdOut.println("elapsed time = " + timer.elapsedTime());
        StdOut.println(cnt);
    }
    //暴力解法
    public static int count(int[] arr)
    {
        int cnt=0;
        for(int i=0;i<arr.length;i++)
            for(int j=i+1;j<arr.length;j++)
                if(arr[i]==arr[j])
                    cnt++;
        return cnt;
    }
    //采用排序后的快速计数
    public static int countFast(int[] arr)
    {
        Arrays.sort(arr);
        int cnt=0;
        for(int i=0;i<arr.length;i++)
        {
            int j=i;
            while(j<arr.length-1&&arr[i]==arr[j+1])
            {
                cnt++;
                j++;
            }
        }
        return cnt;
    }
}

1.4.9 已知由倍率实验可得某个程序的时间倍率为2b且问题规模为N0时程序的运行时间为T,给出一个公式预测该程序在处理规模为N的问题时所需的运行时间.    /*对1.4.6节倍率实验巩固*/

首先,由倍率实验时间之间关系为  T(2*N)/T(N)=2b  -->从而只需知 N=2kN0 -->k=log2(N/N0)  --->T(N)=T*k=T*log2(N/N0)

1.4.10 修改二分查找算法,使之总是返回和被查找的键匹配索引的最小元素(且仍然能够保证对数级别的运行时间)      /*二分查找重复元素的一种处理情况*/

public class H1_4_10
{
    public static int rank(int key, int[] a) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            // Key is in a[lo..hi] or not present.
            int mid = lo + (hi - lo) / 2;
            if      (key < a[mid]) hi = mid - 1;
            else if (key > a[mid]) lo = mid + 1;
            else
            {
                while(mid>0&&a[--mid]==key);  //该语句排除了左边与之相同的值
                return mid+1;
            }
        }
        return -1;
    }

    public static void main(String[] args)
    {
        int[] arr=new int[]{1,4,1,2,3,3,1,4,5,7,3,5};
        Arrays.sort(arr);
        StdOut.println(Arrays.toString(arr));
        StdOut.println(rank(3,arr));
        StdOut.println(rank(4,arr));

    }
}

注:但上述算法的最坏情况并不是logN,例如全部数均相同等极端情况

1.4.11 为StaticSETofInts添加一个实例方法howMany(),找出给定键的出现次数且在最坏情况下所需的运行时间和logN成正比.     /*对于数组中重复元素的处理*/

public class StaticSETofInts
{
    private int[] a;

    public StaticSETofInts(int[] keys) {
        // defensive copy
        a = new int[keys.length];
        for (int i = 0; i < keys.length; i++)
            a[i] = keys[i];
        // sort the integers
        Arrays.sort(a);
    }

    public boolean contains(int key) {
        return rank(key) != -1;
    }

    public int rank(int key) {
        int lo = 0;
        int hi = a.length - 1;
        while (lo <= hi) {
            // Key is in a[lo..hi] or not present.
            int mid = lo + (hi - lo) / 2;
            if      (key < a[mid]) hi = mid - 1;
            else if (key > a[mid]) lo = mid + 1;
            else return mid;
        }
        return -1;
    }

    public int howMany(int key)
    {
        int cnt=0;
        int k=rank(key);     //该语句耗费logN
        int temp=k;
        while(k>=0&&a[k--]==key)   //左边重复情况
            cnt++;
        while(temp>=0&&temp<a.length-1&&a[++temp]==key)  //右边重复情况
            cnt++;
        return cnt;
    }

    public static void main(String[] args)
    {
        int[] arr=new int[]{1,4,5,5,2,1,4,2,3,12,2,12};
        StaticSETofInts setints=new StaticSETofInts(arr);
        StdOut.println(setints.howMany(12));
    }
}

注:以上情况同样全部元素全相同等特殊情况运行时间非logN---暂时没想到改进方案

1.4.12 编写一个程序,有序打印给定的两个有序数组(含有N个int值)中的所有公共元素,程序在最坏情况下所需的运行时间和logN成正比     /*寻找公共元素,以下方法在合并两个有序数组也采用类似方法*/

public class H1_4_12
{
    //该函数前提是arrA和arrB均是已排序数组
    public static void printTheCommonNum(int[] arrA,int[] arrB)
    {
        int ai=0,bi=0;
        int len=arrA.length+arrB.length;     //最坏情况每个元素至少参与一次比较
        for(int i=0;i<len;i++)
        {
            if(arrA[ai]>arrB[bi])
            {
                bi++;
                if(bi==arrB.length)  //避免数组溢出
                    break;
            }
            else if(arrA[ai]<arrB[bi])
            {
                ai++;
                if(ai==arrA.length)  //避免数组溢出
                    break;
            }
            else
            {
                StdOut.printf("%d  ", arrA[ai]);
                ai++;bi++;
                if(ai==arrA.length||bi==arrB.length)  //避免数组溢出
                    break;
            }
        }
    }

    public static void main(String[] args)
    {
        int[] arr1=new int[]{2,2,3};
        int[] arr2=new int[]{1,2,3};
        printTheCommonNum(arr1, arr2);
    }
}

只有一个循环,长度为2N,因此为2N正比于N

1.4.13 根据正文中的假设分别给出表示以下数据类型的一个对象所需的内存量:  /*以下假设基于对象开销16字节,一般内存的使用都会被填充为8字节(总内存8的倍数)*/

 

时间: 2024-12-29 19:15:04

1.4 算法分析的相关文章

算法分析的正确姿势

[本系列博文会对常见的数据结构及相应算法进行分析与总结,并会在每篇博文中提供几道相关的一线互联网企业面试/笔试题来巩固所学及帮助我们查漏补缺.项目地址:https://github.com/absfree/Algo.由于个人水平有限,叙述中难免存在不清晰准确的地方,希望大家可以指正,谢谢大家:)] 一.前言 在进一步学习数据结构与算法前,我们应该先掌握算法分析的一般方法.算法分析主要包括对算法的时空复杂度进行分析,但有些时候我们更关心算法的实际运行性能如何,此外,算法可视化是一项帮助我们理解算法

算法分析与设计复习

算法分析与设计复习 2016年初,研一上学期期末考试前,复习并总结算法分析与设计科目的内容.复习过程参照<算法导论>中文第2版,同时参照PPT,章节划分根据PPT内容 概要: 第一章 概述 第二章 插入排序&分治策略 第三章 复杂度分析 第四章 堆与堆排序 第五章 快速排序 第六章 线性时间排序 第一章 概述 算法的应用范围 算法在诸如生物等诸多领域有其应用 算法的意义 算法在很多情况下让不可能完成的事情变成了可能,让处理的很慢的过程变快. 一个铺垫 一串不全为0的数,怎么取能拿到一段

拓扑排序之变量序列算法分析

拓扑排序之变量序列 巧若拙(欢迎转载,但请注明出处:http://blog.csdn.net/qiaoruozhuo) 题目描述: 假设有n个变量(1<=n<=26,变量名用单个小写字母表示),还有m个二元组(u,v),分别表示变量u小于v.那么,所有变量从小到大排列起来应该是什么样子的呢? 例如有4个变量a,b,c,d,若以知a<b,c<b,d<c,则这4个变量的排序可能是a<d<c<b.尽管还有可能其他的可能,你只需找出其中的一个即可. 输入: 输入为一

某某水表-M1卡数据算法分析

# 某某水表-M1卡数据算法分析 ## 卡片数据-----------------------------扇区数据 | 金额:--- |:---13EC 0000 0000 0000 0000 0000 03EB BD1B | 51.0013E7 0000 0000 0000 0000 0000 03F0 AD2B | 50.9513E2 0000 0000 0000 0000 0000 03F5 AD2B | 50.8513DD 0000 0000 0000 0000 0000 03FA 9D

算法分析

算法就是一系列解决问题的指令,对于给定的输入,能够在有限时间内获得预期的输出.一个好的算法和一篇好的文章一样,都是不断努力,反复修正的结果.算法分析主要从运行时间和存储空间两方面讨论算法的效率.相信有些人会有跟我一样的感觉,对于一些算法,有时我们一眼就能看出它的时间复杂度,但就是无法比较规范的表达出来.本文就系统的整理一下如何规范推导算法的时间和空间复杂度. 算法分析的一个依据是,输入规模(又称问题规模,记为 n),根据直觉,程序的运行时间随着问题规模的增大而变长.那么怎么衡量程序的运行时间呢?

[MD5变形算法练习] AutoRun Design Specialty算法分析

[破文标题][MD5变形算法练习] AutoRun Design Specialty算法分析[破文作者]静心学习[作者邮箱][email protected][作者主页]http://www.cnblogs.com/dacainiao/[破解工具]OD, DEDE, IDA[破解平台]xp sp3[软件名称]AutoRun Design Specialty[软件大小]6.98MB[原版下载]http://www.alleysoft.com/autorundesignspecialty/ARDSS

数据结构与算法分析绪论

数据结构+算法=程序 逻辑结构:集合.线性.树.图 物理结构:顺序.链式 算法分析: (渐进)时间复杂度: 基本语句的执行次数(基本语句:执行次数与整个算法执行次数成正比的语句,通常是最内层循环的循环体) 非递归:找执行次数最大的基本语句放入大O: 递归:(迭代法)可迭代的展开方程的右边,直到没有可以迭代的项为止,这时通过对右边的和进行估算来估计方程的解http://www.cnblogs.com/python27/archive/2011/12/09/2282486.html 最好情况.最坏情

数据结构1:数据结构和算法分析

问题引出 假设有一道题目:有一组N个数而要确定其中第k个最大者,我们称之为选择问题,那么这个程序如何编写?最直观地,至少有两种思路: 1.将N个数读入一个数组中,再通过某种简单的算法,比如冒泡排序法,以递减顺序将数组排序,则第k个位置上的元素就是我们需要的元素 2.稍微好一些的做法,将k个元素读入数组并以递减顺序排序,接着将接下来的元素再逐个读入,当新元素被读到时,如果它小于数组中的第k个元素则忽略之,否则将其放到数组中正确的位置上,同时将数组中的一个元素挤出数组,当算法终止时,位于第k个位置上

数据结构与算法:算法分析

目录 实验研究 常用函数 渐近分析  一.实验研究(Experimental studies) 1.运行时间测量 时钟时间 time.time() CPU时间 time.clock() 基准时间 timeit.timeit() 在执行算法的时候,我们可以通过改变输入规模的大小和记录花费的时间来研究运行时间. 在python中使用time模块的time函数来记录算法的运行时间: from time import time start_time=time() run algorithm end_ti

数据结构基本概念及算法和算法分析 -- 引自《新编数据结构习题与解析》(李春葆等著)

本文引自<新编数据结构习题与解析>(李春葆等著)第1章. 1. 数据结构的基本概念 1.1 数据 数据是对客观事物的符号表示,在计算机科学中是指所有能输入到计算机中并被计算机程序处理的符号的总称.例如,整数.实数和字符串都是数据. 1.2 数据元素 数据元素也称为节点,是表示数据的基本单元,在计算机程序中通常作为一个整体进行考虑和处理. 1.3 数据项 数据项是数据的最小单位.数据元素可以由若干个数据项组成.例如,学生记录就是一个数据元素,它由学号.姓名.性别等数据项组成. 1.4 数据对象