精华内容
参与话题
问答
  • 经典算法---冒泡排序

    万次阅读 多人点赞 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;
    
    }
    

     

     

     

     

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

     

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

    展开全文
  • Java经典算法讲解

    万人学习 2015-05-01 04:13:33
    在面试中,算法题目是必须的,通过算法能够看出一个程序员的编程思维,考察对复杂问题的设计与分析能力,对问题的严谨性都能够体现出来。一个算法的好坏,直接影响一个方法调用的性能,进而影响软件的整体性能。...
  • 深度学习视频教程,包括经典算法与具体案例实战,该系列教程旨在帮助同学们掌握深度学习基础知识点,对复杂的神经网络模型进行通俗解读,逐步迈向深度学习两大核心模型-卷积与递归神经网络。使用当下主流深度学习...
  • 白话经典算法系列之六 快速排序 快速搞定

    万次阅读 多人点赞 2011-08-13 17:19:58
    快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高,因此经常被采用,再加上快速排序思想----分治法也确实实用,因此很多软件公司的笔试面试,包括像腾讯,微软等知名IT公司都喜欢考这个,还有大大小的...
     快速排序由于排序效率在同为O(N*logN)的几种排序方法中效率较高,因此经常被采用,再加上快速排序思想----分治法也确实实用,因此很多软件公司的笔试面试,包括像腾讯,微软等知名IT公司都喜欢考这个,还有大大小的程序方面的考试如软考,考研中也常常出现快速排序的身影。

    总的说来,要直接默写出快速排序还是有一定难度的,因为本人就自己的理解对快速排序作了下白话解释,希望对大家理解有帮助,达到快速排序,快速搞定

     

    快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略,通常称其为分治法(Divide-and-ConquerMethod)。

    该方法的基本思想是:

    1.先从数列中取出一个数作为基准数。

    2.分区过程,将比这个数大的数全放到它的右边,小于或等于它的数全放到它的左边。

    3.再对左右区间重复第二步,直到各区间只有一个数。

     

    虽然快速排序称为分治法,但分治法这三个字显然无法很好的概括快速排序的全部步骤。因此我的对快速排序作了进一步的说明:挖坑填数+分治法

    先来看实例吧,定义下面再给出(最好能用自己的话来总结定义,这样对实现代码会有帮助)。

     

    以一个数组作为示例,取区间第一个数为基准数。

    0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    72

    6

    57

    88

    60

    42

    83

    73

    48

    85

    初始时,i = 0;  j = 9;   X = a[i] = 72

    由于已经将a[0]中的数保存到X中,可以理解成在数组a[0]上挖了个坑,可以将其它数据填充到这来。

    从j开始向前找一个比X小或等于X的数。当j=8,符合条件,将a[8]挖出再填到上一个坑a[0]中。a[0]=a[8]; i++;  这样一个坑a[0]就被搞定了,但又形成了一个新坑a[8],这怎么办了?简单,再找数字来填a[8]这个坑。这次从i开始向后找一个大于X的数,当i=3,符合条件,将a[3]挖出再填到上一个坑中a[8]=a[3]; j--;

     

    数组变为:

    0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    48

    6

    57

    88

    60

    42

    83

    73

    88

    85

     i = 3;   j = 7;   X=72

    再重复上面的步骤,先从后向前找,再从前向后找

    从j开始向前找,当j=5,符合条件,将a[5]挖出填到上一个坑中,a[3] = a[5]; i++;

    从i开始向后找,当i=5时,由于i==j退出。

    此时,i = j = 5,而a[5]刚好又是上次挖的坑,因此将X填入a[5]。

     

    数组变为:

    0

    1

    2

    3

    4

    5

    6

    7

    8

    9

    48

    6

    57

    42

    60

    72

    83

    73

    88

    85

    可以看出a[5]前面的数字都小于它,a[5]后面的数字都大于它。因此再对a[0…4]和a[6…9]这二个子区间重复上述步骤就可以了。

     

     

    对挖坑填数进行总结

    1.i =L; j = R; 将基准数挖出形成第一个坑a[i]。

    2.j--由后向前找比它小的数,找到后挖出此数填前一个坑a[i]中。

    3.i++由前向后找比它大的数,找到后也挖出此数填到前一个坑a[j]中。

    4.再重复执行2,3二步,直到i==j,将基准数填入a[i]中。

    照着这个总结很容易实现挖坑填数的代码:

    int AdjustArray(int s[], int l, int r) //返回调整后基准数的位置
    {
    	int i = l, j = r;
    	int x = s[l]; //s[l]即s[i]就是第一个坑
    	while (i < j)
    	{
    		// 从右向左找小于x的数来填s[i]
    		while(i < j && s[j] >= x) 
    			j--;  
    		if(i < j) 
    		{
    			s[i] = s[j]; //将s[j]填到s[i]中,s[j]就形成了一个新的坑
    			i++;
    		}
    
    		// 从左向右找大于或等于x的数来填s[j]
    		while(i < j && s[i] < x)
    			i++;  
    		if(i < j) 
    		{
    			s[j] = s[i]; //将s[i]填到s[j]中,s[i]就形成了一个新的坑
    			j--;
    		}
    	}
    	//退出时,i等于j。将x填到这个坑中。
    	s[i] = x;
    
    	return i;
    }
    

    再写分治法的代码:

    void quick_sort1(int s[], int l, int r)
    {
    	if (l < r)
        {
    		int i = AdjustArray(s, l, r);//先成挖坑填数法调整s[]
    		quick_sort1(s, l, i - 1); // 递归调用 
    		quick_sort1(s, i + 1, r);
    	}
    }

    这样的代码显然不够简洁,对其组合整理下:

    //快速排序
    void quick_sort(int s[], int l, int r)
    {
        if (l < r)
        {
    		//Swap(s[l], s[(l + r) / 2]); //将中间的这个数和第一个数交换 参见注1
            int i = l, j = r, x = s[l];
            while (i < j)
            {
                while(i < j && s[j] >= x) // 从右向左找第一个小于x的数
    				j--;  
                if(i < j) 
    				s[i++] = s[j];
    			
                while(i < j && s[i] < x) // 从左向右找第一个大于等于x的数
    				i++;  
                if(i < j) 
    				s[j--] = s[i];
            }
            s[i] = x;
            quick_sort(s, l, i - 1); // 递归调用 
            quick_sort(s, i + 1, r);
        }
    }

    快速排序还有很多改进版本,如随机选择基准数,区间内数据较少时直接用另的方法排序以减小递归深度。有兴趣的筒子可以再深入的研究下。

     

    注1,有的书上是以中间的数作为基准数的,要实现这个方便非常方便,直接将中间的数和第一个数进行交换就可以了。

     

     转载请标明出处,原文地址:http://blog.csdn.net/morewindows/article/details/6684558

    展开全文
  • 首先,本博客为原创作品,欢迎指导,随意转载,如果可以请转载时说明出处,附上本文链接,谢谢 动态规划的重要性就不多说,直接进入正题 首先,我们看一下官方定义: 定义: 动态规划算法是通过拆分问题,定义问题状态和状态...

    首先,本博客为原创作品,欢迎指导,随意转载,如果可以请转载时说明出处,附上本文链接(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,无后效性 说的花里胡哨的,其实一般遇到求最优解问题一般适合使用动态规划

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

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

    展开全文
  • 经典递归解决汉诺塔!

    万次阅读 多人点赞 2012-12-19 22:20:07
    算法:当只有一个盘子的时候,只需要从将A塔上的一个盘子移到C塔上。 当A塔上有两个盘子是,先将A塔上的1号盘子(编号从上到下)移动到B塔上,再将A塔上的2号盘子移动的C塔上,最后将B塔上的小盘子移动到C塔上。...

    算法:当只有一个盘子的时候,只需要从将A塔上的一个盘子移到C塔上。

                当A塔上有两个盘子是,先将A塔上的1号盘子(编号从上到下)移动到B塔上,再将A塔上的2号盘子移动的C塔上,最后将B塔上的小盘子移动到C塔上。

                当A塔上有3个盘子时,先将A塔上编号1至2的盘子(共2个)移动到B塔上(需借助C塔),然后将A塔上的3号最大的盘子移动到C塔,最后将B塔上的两个盘子借助A塔移动到C塔上。

               当A塔上有n个盘子是,先将A塔上编号1至n-1的盘子(共n-1个)移动到B塔上(借助C塔),然后将A塔上最大的n号盘子移动到C塔上,最后将B塔上的n-1个盘子借助A塔移动到C塔上。

              综上所述,除了只有一个盘子时不需要借助其他塔外,其余情况均一样(只是事件的复杂程度不一样)。

             

    #include <stdio.h>
    //第一个塔为初始塔,中间的塔为借用塔,最后一个塔为目标塔
    int i=1;//记录步数
    void move(int n,char from,char to) //将编号为n的盘子由from移动到to
    {
        printf("第%d步:将%d号盘子%c---->%c\n",i++,n,from,to);
    }
    void hanoi(int n,char from,char depend_on,char to)//将n个盘子由初始塔移动到目标塔(利用借用塔)
    {
        if (n==1)
        move(1,from,to);//只有一个盘子是直接将初塔上的盘子移动到目的地
    	else
    	{
          hanoi(n-1,from,to,depend_on);//先将初始塔的前n-1个盘子借助目的塔移动到借用塔上
    	  move(n,from,to);              //将剩下的一个盘子移动到目的塔上
    	  hanoi(n-1,depend_on,from,to);//最后将借用塔上的n-1个盘子移动到目的塔上
    	}
    }
    void main()
    {
    	 printf("请输入盘子的个数:\n");
    	 int n;
    	 scanf("%d",&n);
    	 char x='A',y='B',z='C';
    	 printf("盘子移动情况如下:\n");
    	 hanoi(n,x,y,z);
    }


    展开全文
  • Matlab 实现经典功率谱分析和估计

    万次阅读 多人点赞 2019-07-07 11:24:29
    Matlab 实现经典功率谱分析和估计 文章目录Matlab 实现经典功率谱分析和估计功率谱Matlab 使用1 直接法2 间接法3 改进直接法:`Bartlett法`4 `Welch法`附上谋篇论文,分析EEG信号功率谱代码致谢 功率谱 功率谱是...
  • 10部经典的官场小说

    万次阅读 2019-06-09 11:39:53
    这几年迷上了官场小说,看了很多,个人觉得其中比较好的十部,如下: 1,官道之色戒 青州市委办公室的科员王思宇因为一次意外的机会,结实了华西省电视台的台长方如海,并且因为成功解决信访办打人事件,在一些...
  • 数据结构与算法中的经典算法

    万次阅读 多人点赞 2018-07-19 21:47:12
    数据结构与算法之经典算法 常见数据结构与算法整理总结(上) 常见数据结构与算法整理总结(下) 二、针对性参考 1) 排序 数据结构与算法之经典排序 2)二叉树 数据结构与算法之二叉树+遍历+哈夫曼树 ...
  • 数字信号处理经典书籍

    千次阅读 2015-11-02 15:03:15
    数字信号处理-(第三版) (美)莱昂斯,张建华 9787121243677 电子工... 分享到 查看大图 数字信号处理-(第三版) (美)莱昂斯,张建华 ...¥ 99.00(节省了 
  • 绘制如下图形: 源代码: import turtle as t t.pencolor("blue") #笔触为蓝色 #绘制外部大三角形 t.fd(200) t.seth(120) t.fd(200) t.seth(-120) t.fd(200) #绘制内部小三角形 ...t.fd(100...
  • 算法竞赛入门经典完整版.pdf

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

    万次阅读 多人点赞 2014-12-21 00:07:43
    无意中发现了一个巨牛的人工智能教程,忍不住分享一下给大家。教程不仅是零基础,通俗易懂,而且非常风趣幽默,像看小说一样!觉得太牛了,所以分享给大家。点这里可以跳转到教程。 一、Java从入门到精通 ...
  • 经典算法(5)杨辉三角

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

    万次阅读 2008-12-09 10:22:00
    一、普通版: 编辑跟某武侠作者约稿,要写一篇既打破世俗伦理,又包含江湖门派间多年怨情仇,同时情节还要扣人心悬,大有血雨腥风呼之欲来这样的微型武侠小说。 第二天交工,全文只有十个字:“师太,你就从...
  • 因排版过于粗糙 ... 前言:复杂类型说明 要了解指针,多多少少会出现一些比较复杂的类型,所以我先介绍一下如何完全理解一个复杂类型,要理解复杂类型其实很简单,一个类型里会出现很多运算符,他们也像普通的表达式一样,...
  • 10大经典排序算法动画解析-收藏

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

    万次阅读 多人点赞 2018-09-04 18:47:59
    学习c语言基础,怎么能少了菜鸟教程上的100道例题呢,这里整理一下每道题的链接,希望大家能享受学习的乐趣 1,有1,2,3,4个数字,能组成多少个互不相同且无重复数字的三位数?都是多少? 2,企业发放的奖金根据...
  • 文章目录1.序2.动态规划的基本概念[^1]3.动态规划算法的基本思想[^2]4....这篇文章主要介绍动态规划算法的基本思想、使用动态规划算法求解问题的基本步骤、动态规划算法的两个基本要素以及一些经典的动态规划问题。...
  • 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 " ...
  • 51套经典企业网站源码(一)

    千次下载 热门讨论 2014-08-24 10:57:42
    内容较大,权限不够,故将内容分为六个部分,需要的请自行下载。 教程版权归原作者所有,本人只是负责...0051测试完整无错的经典万能企业站程序 0052某电气工程有限公司源码 0053优乐博特自动化工程有限公司网站源码
  • 经典网页特效500例打包下载

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

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

    千次下载 热门讨论 2014-08-24 11:07:44
    内容较大,权限不够,故将内容分为六个部分,需要的请自行下载。 教程版权归原作者所有,本人只是负责...0051测试完整无错的经典万能企业站程序 0052某电气工程有限公司源码 0053优乐博特自动化工程有限公司网站源码
  • 题目:一球从100米高度自由落下,每次落地后反跳回原高度的一半;再落下,求它在 第10次落地时,共经过多少米?第10次反弹多高? ... ... * 题目:一球从100米高度自由落下,每次落地后反跳回原高度的一半;...
  • WPF经典教程之WPF命令

    千次下载 热门讨论 2014-10-05 01:16:30
    WPF中的命令路由与事件路由是两个很让...WPF经典教程之WPF控件模型 http://download.csdn.net/detail/cleopard/8002999 WPF经典教程之WPF控件内容模型 http://download.csdn.net/detail/cleopard/8003009 等。。。。
  • 小猪的数据结构辅助教程——2.6 经典例子:魔术师发牌问题和拉丁方阵问题标签(空格分隔): 数据结构本节引言: 本节继续带来的是循环链表的两个经典例子,分别是魔术师发牌问题和拉丁方阵问题! 1.魔术师发牌问题...
  • c++经典代码大全

    千次下载 热门讨论 2015-04-09 21:20:32
    c++经典代码大全,别人向我推荐的,初学者可以看看。。

空空如也

1 2 3 4 5 ... 20
收藏数 301,778
精华内容 120,711
关键字:

经典