精华内容
下载资源
问答
  • 经典算法---冒泡排序

    万次阅读 多人点赞 2014-09-24 15:58:50
    原文链接: 冒泡排序---经典排序算法 | 逍遥游 冒泡排序(BubbleSort)以其“在排序过程中相邻元素不断交换,一些元素慢慢被换到最后,看起来就像是元素在冒泡一样”而得名,是一种简单的基于关键词比较的排序...

    原文链接: 冒泡排序---经典排序算法 | 逍遥游

     

    冒泡排序(BubbleSort)以其“在排序过程中相邻元素不断交换,一些元素慢慢被换到最后,看起来就像是元素在冒泡一样”而得名,是一种简单的基于关键词比较的排序算法。

     

    算法原理

    冒泡排序的原理(以递增序为例)是每次从头开始依次比较相邻的两个元素,如果后面一个元素比前一个要大,说明顺序不对,则将它们交换,本次循环完毕之后再次从头开始扫描,直到某次扫描中没有元素交换,说明每个元素都不比它后面的元素大,至此排序完成。

    由于冒泡排序简洁的特点,它通常被用来对于计算机程序设计入门的学生介绍算法的概念。

     

    时间复杂度

    若文件的初始状态是排好序的的,一趟扫描即可完成排序。所需的关键字比较次数C和记录移动次数 M 均达到最小值(Cmin = n-1、Mmin = 0)

    所以,冒泡排序最好的时间复杂度为O(N)。


      若初始文件是反序的,需要进行N趟排序。每趟排序要进行 C = N-1次关键字的比较(1≤i≤N-1)和总共(Mmax = (N*(N-1))/2)次的移动(移动次数由乱序对的个数决定,即多少对元素顺序不对,如 1 3 4 2 5 中共有(3,2)、(4,2)两个乱序对),在这种情况下,比较和移动次数均达到最大值(Cmax =N*(N-1) + Mmax=(N*(N-1))/2 = O(N^2))。所以,冒泡排序的最坏时间复杂度为O(N^2)

     

    综上,冒泡排序总的平均时间复杂度为O(N^2)。

    算法稳定性

    冒泡排序就是把小的元素往前调或者把大的元素往后调。比较是相邻的两个元素比较,交换也发生在这两个元素之间。如果两个相等的元素相邻,那么根据我们的算法。它们之间没有发生交换;如果两个相等的元素没有相邻,那么即使通过前面的两两交换把两个相邻起来,这时候也不会交换,所以相同元素的前后顺序并没有改变,所以冒泡排序是一种稳定排序算法。

     

    算法改进

    由于冒泡排序算法还是比较慢的,所以有很多人对在此基础上进行了改进,我只简单介绍一下我所知道的。

    第一种是上浮操作与下沉操作相结合。传统的冒泡排序只有上浮操作,如果碰到一些很特殊的数据就会显得笨一点,例如(2、3、4、5、1)这个数列按增序排列,那么按照普通冒泡算法就要扫描5趟,可是我们一眼就看出来直接把 1 挪到第一个就行了,扫描 5 次实在是太笨了,于是我们在每次上浮操作后加上一个下沉操作,这样就更快了。

    第二中改进是减少无效比较的次数。所谓无效比较就是当我们已知结果却还要去比较。如果我们多观察冒泡排序的中间过程,我们就会发现,末尾的一些元素在一定次数的扫描后已经到达最终位置了(因为每次扫描后都至少会有一个新的元素到达最终位置),再比较就会造成无效比较。改进方法是,记录下每次扫描中发生交换的最后一个元素位置,下一次扫描就到这里为止。

    可是,无论怎么改进,冒泡排序的时间复杂度都是O(N^2)。

     

    下面给出冒泡排序的C++参考代码和下载地址。

     

     

    //冒泡排序部分,参数形式与标准库的快排一样
    
    //ps:(point start)所需排序的数据首地址
    
    //pe:(point end)  所需排序的数据第一个无效地址
    
    //cmp:自定义的比较函数
    
    int sort(int *ps,int *pe,bool(*cmp)(int,int))
    
    {
    
    //用以判断某次循环后是否有元素位置发生变化
    
        bool flag=true;
    
     
    
        while(flag)
    
        {
    
            flag=false;//假设没有交换
    
     
    
            //上浮过程
    
            for(int i=1;i<pe-ps;i++)//注意:i从1开始
    
            {
    
                if(cmp(ps[i],ps[i-1]))
    
                {
    
                    swap(ps[i],ps[i-1]);
    
                    flag=true;//有元素发生交换,说明排序可能没有结束
    
                }
    
            }
    
        }
    
        return 0;
    
    }
    

     

     

     

     

    更详细的代码,请点击这里下载。

     

    来源:逍遥游,欢迎分享本文,转载请保留出处!

    展开全文
  • 经典算法(5)杨辉三角

    万次阅读 多人点赞 2019-11-04 17:15:35
    杨辉三角 是经典算法,这篇博客对它的算法思想进行了讲解,并有完整的代码实现。

    写在前面: 我是「扬帆向海」,这个昵称来源于我的名字以及女朋友的名字。我热爱技术、热爱开源、热爱编程。技术是开源的、知识是共享的。

    这博客是对自己学习的一点点总结及记录,如果您对 Java算法 感兴趣,可以关注我的动态,我们一起学习。

    用知识改变命运,让我们的家人过上更好的生活

    相关文章

    点此查看 【算法系列】 博客文章


    一、杨辉三角的介绍

    百度百科对于杨辉三角是这样介绍的:
    在这里插入图片描述

    二、杨辉三角的算法思想

    (此图片来源于网络)

    杨辉三角的两个腰边的数都是 1,从第3行起,除第一个数和最后一个数外,其它位置的数都是上顶上两个数之和。

    三、代码实现

    1.第一种写法

    public class YangHuiTriangle1 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.print("输入要打印的行数:");
            int n = scanner.nextInt();
            // 打印杨辉三角
            getTriangle(n);
        }
    
        /**
         * 打印杨辉三角
         *
         * @param n 要打印的行数
         * @return
         */
        private static int[][] getTriangle(int n) {
            // 创建一个二维数组,此二维数组用来存放杨辉三角中每一行的值
            int[][] array = new int[n][n];
            // 给数组元素赋值
            for (int i = 0; i < array.length; i++) {
                // 每一行的值
                array[i] = new int[i + 1];
                // 给首末元素赋值
                array[i][0] = array[i][i] = 1;
                // 给每行的非首末元素赋值
                if (i > 1) {
                    for (int j = 1; j < array[i].length - 1; j++) {
                        array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
                    }
                }
            }
            // 遍历二维数组
            for (int i = 0; i < array.length; i++) {
                for (int j = 0; j < array[i].length; j++) {
                    System.out.print(array[i][j] + "\t");
                }
                System.out.println();
            }
            return array;
        }
    }
    
    

    代码执行结果:

    输入要打印的行数:10
    1	
    1	1	
    1	2	1	
    1	3	3	1	
    1	4	6	4	1	
    1	5	10	10	5	1	
    1	6	15	20	15	6	1	
    1	7	21	35	35	21	7	1	
    1	8	28	56	70	56	28	8	1	
    1	9	36	84	126	126	84	36	9	1	
    

    2.第二种写法

    public class YangHuiTriangle2 {
        public static void main(String[] args) {
            Scanner scanner = new Scanner(System.in);
            System.out.println("输入要打印的行数:");
            int n = scanner.nextInt();
            // 打印杨辉三角
            int array[][] = getTriangle(n);
            //  打印成等腰三角形
            printTriangle(array);
        }
    
        private static int[][] getTriangle(int n) {
            // 创建一个二维数组,此二维数组用来存放杨辉三角中每一行的值
            int[][] array = new int[n][n];
            // 给数组元素赋值
            for (int i = 0; i < array.length; i++) {
                // 每一行的值
                array[i] = new int[i + 1];
                // 给首末元素赋值
                array[i][0] = array[i][i] = 1;
                // 给每行的非首末元素赋值
                if (i > 1) {
                    for (int j = 1; j < array[i].length - 1; j++) {
                        array[i][j] = array[i - 1][j - 1] + array[i - 1][j];
                    }
                }
            }
            return array;
        }
    
        /**
         * 打印成等腰三角形
         *
         * @param array
         */
        public static void printTriangle(int[][] array) {
            for (int i = 0; i < array.length; i++) {
                // 输出杨辉三角数字前面的空格
                for (int j = 0; j < array.length - 1 - i; j++) {
                    System.out.print("   ");
                }
                for (int j = 0; j <= i; j++) {
                    // 用空格填补空位置
                    System.out.print("   ");
                    // 以十进制整数的形式输出,位宽是3,左对齐
                    System.out.printf("%-3d", array[i][j]);
                }
                System.out.println();
            }
        }
    }
    

    代码执行结果:

    输入要打印的行数:
    10
                                  1  
                               1     1  
                            1     2     1  
                         1     3     3     1  
                      1     4     6     4     1  
                   1     5     10    10    5     1  
                1     6     15    20    15    6     1  
             1     7     21    35    35    21    7     1  
          1     8     28    56    70    56    28    8     1  
       1     9     36    84    126   126   84    36    9     1  
    

    上一篇 经典算法(4)一文搞懂什么是 快速排序
    下一篇 经典算法(6)斐波拉契数列、兔子繁殖、跳台阶算法


    由于水平有限,本博客难免有不足,恳请各位大佬不吝赐教!

    展开全文
  • 此时我们应该放弃,只保存最优解,这样我们每一次都把最优解保存了下来,大大降低了时间复杂度 说很难理解清楚,容易懵懵懂懂的,所以下面结合实例看一下(建议结合实例,纸上谈兵不太好): 经典的数字三角形问题(简单易懂,...

    首先,本博客为原创作品,欢迎指导,随意转载,如果可以请转载时说明出处,附上本文链接(https://blog.csdn.net/ailaojie/article/details/83014821),谢谢
    原文链接
    动态规划的重要性就不多说,直接进入正题

    首先,我们看一下官方定义:
    定义:
    动态规划算法是通过拆分问题,定义问题状态和状态之间的关系,使得问题能够以递推(或者说分治)的方式去解决。
    动态规划算法的基本思想与分治法类似,也是将待求解的问题分解为若干个子问题(阶段),按顺序求解子阶段,前一子问题的解,为后一子问题的求解提供了有用的信息。在求解任一子问题时,列出各种可能的局部解,通过决策保留那些有可能达到最优的局部解,丢弃其他局部解。依次解决各子问题,最后一个子问题就是初始问题的解。
    基本思想与策略编辑:
    由于动态规划解决的问题多数有重叠子问题这个特点,为减少重复计算,对每一个子问题只解一次,将其不同阶段的不同状态保存在一个二维数组中。
    (来自百度百科)
    说实话,没有动态规划的基础很难看懂,但是也能从中看出一些信息,下面我翻译成人话:
    首先是拆分问题,我的理解就是根据问题的可能性把问题划分成一步一步这样就可以通过递推或者递归来实现.
    关键就是这个步骤,动态规划有一类问题就是从后往前推到,有时候我们很容易知道:如果只有一种情况时,最佳的选择应该怎么做.然后根据这个最佳选择往前一步推导,得到前一步的最佳选择
    然后就是定义问题状态和状态之间的关系,我的理解是前面拆分的步骤之间的关系,用一种量化的形式表现出来,类似于高中学的推导公式,因为这种式子很容易用程序写出来,也可以说对程序比较亲和(也就是最后所说的状态转移方程式)
    我们再来看定义的下面的两段,我的理解是比如我们找到最优解,我们应该讲最优解保存下来,为了往前推导时能够使用前一步的最优解,在这个过程中难免有一些相比于最优解差的解,此时我们应该放弃,只保存最优解,这样我们每一次都把最优解保存了下来,大大降低了时间复杂度

    说很难理解清楚,容易懵懵懂懂的,所以下面结合实例看一下(建议结合实例,纸上谈兵不太好):

    经典的数字三角形问题(简单易懂,经典动态规划);

    题目:题目描述
    输入格式
    可以看出每走第n行第m列时有两种后续:向下或者向右下
    由于最后一行可以确定,当做边界条件,所以我们自然而然想到递归求解
    解题思路:解题思路
    c语言答案
    下面简单写一下java代码:

    //java代码纯属自己练习,标准答案参考上面的c语言答案
    class solution{
    	public int getMax(){
    		int MAX = 101;
    		int[][] D = new int[MAX][MAX];   //存储数字三角形
    		int n;              //n表示层数
    		int i = 0; int j = 0;
    		int maxSum = getMaxSum(D,n,i,j);
    		return maxSum;
    	}
    	public int getMaxSum(int[][] D,int n,int i,int j){
    		if(i == n){
    			return D[i][j];
    		}
    		int x = getMaxSum(D,n,i+1,j);
    		int y = getMaxSum(D,n,i+1,j+1);
    		return Math.max(x,y)+D[i][j];
    	}
    }
    

    其实仔细观察,上面的解答过程时间复杂度难以想象的大,那是因为他对有的数字的解进行了多次的重复计算,具体如下图:
    超时原因
    如果不明白上图,可以把每条路径都画出来,观察每个数字有多少条路径经过了他,就会一目了然
    然后我们就可以自然而然的想到,如果我们每次都把结果保存下来,复杂度就会大大降低
    改进方法
    其实答案很简单:改进解法
    其实这是动态规划很精髓的一部分,是减少复杂度的主要原因
    我们都知道,递归一般情况下是可以转化为递推的,不详细解释了,贴上答案:
    递推解法
    其实,仔细观察该解题过程,该过程就是标准的动态规划解题过程,如果把该过程画出来(找到每一步的最优解,其他的舍弃)对动态规划会有更深刻的解法
    还有就是,递推的另一个好处是可以进行空间优化,如图:
    空间优化
    下面总结一下动态规划的解题一般思路:
    首先递归应该是我们解决动态规划问题最常用的方法,帅,速度不算太慢
    那么递归到动规的一般转化方法为:
    如果该递归函数有n个参数,那么就定义一个n维数组,数组下标是递归函数参数的取值范围(也就是数组每一维的大小).数组元素的值就是递归函数的返回值(初始化为一个标志值,表明还未被填充),这样就可以从边界值开始逐步的填充数组,相当于计算递归函数的逆过程(这和前面所说的推导过程应该是相同的).
    原文链接:https://blog.csdn.net/ailaojie/article/details/83014821

    动规解题的一般思路(标准官方,不过经过前边讲解应该就能理解了):

    1. 将原问题分解为子问题(开头已经介绍了怎么分解) (注意:1,子问题与原问题形式相同或类似,只是问题规模变小了,从而变简单了; 2,子问题一旦求出就要保存下来,保证每个子问题只求解一遍)
    2. 确定状态(状态:在动规解题中,我们将和子问题相关的各个变量的一组取值,称之为一个"状态",一个状态对应一个或多个子问题所谓的在某个状态的值,这个就是状态所对应的子问题的解,所有状态的集合称为"状态空间".我的理解就是状态就是某个问题某组变量,状态空间就是该问题的所有组变量) 另外:整个问题的时间复杂度就是状态数目乘以每个状态所需要的时间
    3. 确定一些初始状态(边界条件)的值 (这个视情况而定,千万别以为就是最简单的那个子问题解,上面只是例子,真正实践动规千变万化)
    4. 确定状态转移方程 (这一步和第三步是最关键的 记住"人人为我"递推,由已知推未知)

    适合使用动规求解的问题:
    1,问题具有最优子结构
    2,无后效性 说的花里胡哨的,其实一般遇到求最优解问题一般适合使用动态规划

    部分参考资料出自:北大信科郭炜老师

    感觉自己洋洋洒洒写了几个小时,对动态规划有了一定的理解,也希望对你们有所帮助,动态规划千变万化,这仅仅是一个理解过程,我们还是应该多练习,共勉吧.转载的话,如果方便请加上转载地址,谢谢.

    展开全文
  • 三个数比较大小 — C语言经典题目

    万次阅读 多人点赞 2017-03-29 20:57:40
    这道题是每一位初学C的小伙伴们的必经之路,其经典性简直如同Hello World!下面写一下几种不同的解法。 1.if语句 2.三目运算(?) 3.调用函数 4.指针

    这道题是每一位初学C的小伙伴们的必经之路,其经典性简直如同Hello World!

    下面写一下几种不同的解法。


    • 使用if语句
    #include<stdio.h>
    
    int main()
    {
    	int a, b, c, max;//逗号,(大/中/普通)括号,右端需有空白字符
    	
    	scanf("%d%d%d", &a, &b, &c);
    	
    	if( a>b)    max = a;//为了代码可视性高,操作符需被空白字符包围
    	else        max = b;
    	if( c>max)  max = c;
    	
    	printf("max=%d", max);
    	
    	return 0;
    }
    

    • 使用三目运算符

    ?:条件运算符,使用方法是<表达式1> ?<表达式2> :<表达式3>,意思是满足表达式1就执行表达式2,否则执行表达式3。

    #include<stdio.h>
    
    int main()
    {
    	int a, b, c, max;
    	
    	scanf("%d%d%d", &a, &b, &c);
    	
    	max = a>b ? a:b;
    	max = c>max ? c:max;
    	
    	printf("max=%d", max);
    	
    	return 0;
    }
    
    • a>b ? (max = a) : (max = b); c>max ? (max = c) : max ;

    • max = ( (a>b ? a:b) > c) ? (a>b ? a:b) : c;

    以上三种方法均可以比较出三个数的最大值,区别在于例子中的方法是使用的赋值语句,而替代方法1是运用的标准条件运算,后面的替代方法2则是以赋值语句为主的两重(条件运算的)嵌套。

    补充:替代方法2不能写成max = ( (a>b?a:b) > c ) ? ():c;
    因为在三目运算符?的前置条件中(a>b?a:b)的运算结果是没有分配储存地址的,只是开辟了临时地址(理解成缓存也行,程序结束便清空),这就导致后面的()根本无法从前面取得值,所以得再写一次表达式。


    • 使用max函数 + if语句
    #include<stdio.h>
    
    int main()
    {
    	int a, b, c, max;
    	int Max( int x, int y, int z);//声明自定义函数Max
    	
    	scanf("%d%d%d", &a, &b, &c);
    	
    	max = Max( a,b,c);
    	
    	printf("max=%d", max);
    	return 0;
    }
    
    int Max(int x, int y, int z)
    {
    	int max;//不同的函数中可以使用同名(局部)变量
    	
    	if( x>y)    max = x;
    	else        max = y;
    	if( z>max)  max = z;
    	
    	return max;
    }
    
    • 使用max函数 + 三目运算符
    #include<stdio.h>
    
    int main()
    {
    	int a, b, c;
    	int Max( int x, int y);
    	
    	scanf("%d%d%d", &a, &b, &c);
    	printf("max=%d", Max(Max(a,b),c) );//调用两重Max函数嵌套
    	
    	return 0;
    }
    
    int Max(int x, int y)
    {
    	return x>y?x:y;
    }
    

    其中printf语句里的两重函数嵌套不能写成Max( (a,b) ,c),因为这个(a,b)并不符合自定义Max函数的传参要求。

    自定义Max函数int Max(int x, int y)的形参为整型变量int x, int y,所以在调用Max函数时,需要传入符合定义要求的int型参数,那么显然这个(a,b)并不是int型参数,它是一个不属于任何类型的不完整表达式,其没有实际意义。

    不过,两重Max函数嵌套写成Max( Max(a,b) ,c)是符合要求的,因为Max(a,b)的函数返回值符合int x的传参要求,究其原因是其内部return语句中返回的x>y?x:y是一个int型值。


    • 使用指针
    #include<stdio.h>
    
    int main()
    {
    	int a, b, c;
    	int Max( int x, int y);
    	int (*p)(int, int) = &Max;//对指针p赋初值为Max的地址,&可省略
    	
    	scanf("%d%d%d", &a, &b, &c);
    	printf("max=%d", p(p(a,b) ,c) );
    	
    	return 0;
    }
    
    int Max(int x, int y)
    {
    	return x>y?x:y;
    }
    

    这个有关于数字比较之类的问题,在C语言中是非常经典的一块,于是写了几种方法来开拓一下自己思路。也希望可以通过对这个题目的不同解法,来为之后像回溯和指针之类的知识稍微做一下铺垫,嘿,大家一起来感受一下。

    总之,我觉得吧,像这种O(1)的小小代码片儿,要是闲的没事儿或闲情所致,那还是可以追求一下更多的不同解答方法啦。^ _ ^

    展开全文
  • c++经典代码大全

    千次下载 热门讨论 2015-04-09 21:20:32
    c++经典代码大全,别人向我推荐的,初学者可以看看。。
  • C#入门经典第五版(中文版).

    千次下载 热门讨论 2012-05-07 12:18:16
    C#入门经典 好书不用多说,中文影印完整版
  • 198个经典C#WinForm实例源码 超赞的完整版

    千次下载 热门讨论 2013-07-14 18:27:44
    "198个经典C#WinForm实例源码"包括: 1-窗体技巧 2-控件操作 3-图像操作 4-报表打印 5-系统操作 6-文件处理 7-网络操作 8-数据库操作 9-加密解密 10-硬件读写 11-游戏设计 "超赞的198个经典C#WinForm实例源码.zip " ...
  • C语言经典例题(菜鸟教程100例)

    万次阅读 多人点赞 2018-09-04 18:47:59
    学习c语言基础,怎么能少了菜鸟教程上的100道例题呢,这里整理一下每道题的链接,希望大家能享受学习的乐趣 1, 有1,2,3,4个数字,能组成多少个互不相同且无重复数字的三位数...菜鸟教程-C语言经典100示例(后50)
  • c++经典代码大全 清晰版

    千次下载 热门讨论 2011-12-06 13:28:30
    c++经典代码大全 适合C++新手看的经典代码!!!
  • 文章目录15套免费的NLP课程及经典教材分享!1、自然语言处理圣经---《自然语言处理综论》2、视频课程《深度学习与自然语言处理-2018》3、Natural Language Processing (NLP)4、吴恩达经典课程 - Machine Learning —...
  • java、八大经典书籍,你看过几本?

    万次阅读 多人点赞 2014-12-21 00:07:43
    八、Java 7入门经典 《Java 7入门经典》是关于Java语言讲解最为细致、全面的入门书籍,介绍了使用最新的Java JDK 7开发程序所需要的所有基础知识。书中包含大量的示例,清晰地解释了涉及的关键概念,演示了Java开发...
  • AGI:走向通用人工智能的【哲学】之现实世界的虚拟与真实——带你回看1998年的经典影片《The Truman Show》感悟“什么是真实” 导读:今天写的这篇文章,完全是来自于昨天和几位好友一块聚餐,谈到了很多的AI与哲学...
  • 2019CAD设置经典模式模板&详细步骤

    万次阅读 多人点赞 2019-05-16 20:53:44
    2019CAD设置经典模式步骤 第一步:下载经典模式模板 链接:https://pan.baidu.com/s/1Wyt0SQxqOG1nETg55rHq-w 提取码:lpxq 第二步:安装 1 2打开AutoCAD2016,找到工具里面的自定义-界面-传输 4点击左上角传输,...
  • 经典网页特效500例打包下载

    千次下载 热门讨论 2012-10-14 07:33:25
    经典网页特效500例!绝对500例! 经不经典你说了算! 一起一直自己用,现在贡献出来! QQ式的导航 经典实用的触发型导航菜单 菜单变换与拖动 三级下拉菜单(通用版) 鼠标触及带边框菜单 HTML输出下拉内容 判断输入...
  • 10大经典排序算法动画解析-收藏

    万次阅读 多人点赞 2018-12-13 14:13:07
    人工智能,零基础入门!... 排序算法是《数据结构与算法》中最基本的算法之一。 排序算法可以分为内部排序和外部排序。 内部排序是数据记录在内存中进行排序。...而外部排序是因排序的数据很大,一次不能容纳全部的排序...
  • 菜鸟教程-C语言经典100示例(前50)

    万次阅读 多人点赞 2018-03-18 14:05:58
    这两天正在看基础的算法,在做的时候肯定不能避免的接触了菜鸟上的经典100例,但是使用的时候发现并不是那么的方便,因为它只是给了序号,如果查找某一问题的话很不方便,所以做了这篇博客,希望给自己和其他人带来...
  • vc界面编程经典实例

    千次下载 热门讨论 2013-03-28 10:45:23
    常用的vc界面编程经典实例,包含上百个实例的整理文档。常用的vc界面编程经典实例,包含上百个实例的整理文档。常用的vc界面编程经典实例,包含上百个实例的整理文档。常用的vc界面编程经典实例,包含上百个实例的...
  • 算法竞赛入门经典完整版.pdf

    千次下载 热门讨论 2012-12-18 15:17:31
    《算法竞赛入门经典》是一本算法竞赛的入门教材,把C/C++语言、算法和解题有机地结合在了一起,淡化理论,注重学习方法和实践技巧。全书内容分为11章,包括程序设计入门、循环结构程序设计、数组和字符串、函数和...
  • c++经典代码大全.pdf

    千次下载 热门讨论 2012-05-06 11:42:47
    c++经典代码大全,是一本不容错过的好书,讲的都是经典的代码。
  • 十三个经典算法研究PDF文档[带目录+标签]

    千次下载 热门讨论 2011-07-08 14:53:48
    本文件是十三个经典算法研究+红黑树系列的,带目录+标签的PDF文档。在此之前,网上绝无仅有。希望,对你有帮助。博客地址为:http://blog.csdn.net/v_JULY_v。
  • Java经典项目集锦

    千次下载 热门讨论 2015-05-17 16:36:03
    Java经典项目集锦
  • Visual C++游戏开发经典案例详解.pdf

    千次下载 热门讨论 2012-03-01 08:45:15
    Visual C++游戏开发经典案例详解.pdf
  • 07-if与循环-案例超经典-C语言

    万次阅读 多人点赞 2020-11-01 09:33:00
    本讲将通过几个经典例子来讲解选择与循环嵌套。选择与选择嵌套if 与 if嵌套判断变量a是否在3~10之间。int a = 4; if(a>3){ if(a&l...
  • 100个C语言经典小程序和C语言编写的小游戏

    万次阅读 多人点赞 2019-01-29 22:17:17
    100个C语言经典小程序和C语言编写的小游戏
  • 运算放大器11种经典电路

    万次阅读 多人点赞 2018-12-28 16:56:51
    运算放大器11种经典电路
  • 秒杀多线程第六篇 经典线程同步 事件Event

    万次阅读 多人点赞 2012-04-11 09:06:57
    阅读本篇之前推荐阅读以下姊妹篇:《秒杀多线程第四篇 一个经典的多线程同步问题》《秒杀多线程第五篇 经典线程同步关键段CS》 上一篇中使用关键段来解决经典的多线程同步互斥问题,由于关键段的“线程所有权”特性...
  • 25个经典网站源代码

    千次下载 热门讨论 2013-06-09 14:29:02
    25个经典网站源代码 有简约的有时尚的方便大家参考、模仿。
  • 一个经典例子让你彻彻底底理解java回调机制

    万次阅读 多人点赞 2013-03-21 23:43:28
    现在知道了,所谓回调:就是A类中调用B类中的某个方法C,然后B类中反过来调用A类中的方法D,D这个方法就叫回调方法,这样子说你是不是有点晕晕的,其实我刚开始也是这样不理解,看了人家说比较经典的回调方式: ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 351,469
精华内容 140,587
关键字:

经典