CH1-绪论

目录

• 算法时间复杂度的计算
  • 一.冒泡排序简介(从小到大排序）

算法时间复杂度的计算

• 我们一般只关心随着问题规模n趋于无穷时，函数中对函数结果影响最大的项.

  ​ 比如说:T(n)=3n+3，当n非常大的时候，常数3和n的系数3对函数结果的影响就很小了，所以一般我们会保留最高次项并忽略该项的系数.

  ​ 又比如：

  T(n)=n+1 忽略常数项 T(n)~n

  T(n)=n+n^2 忽略低阶项 T(n)~n^2

  T(n)=3n 忽略最高阶的系数 T(n)~n

  也就是最高次项简化后的式子被称为这个程序算法的时间复杂度,记做O(f(n)).

  

  f(n)就是简化后的式子，比如说T(n)=3n+3,简化后T(n)-f(n)=n,那我们记为O(n)

x=90; y=100;
while(y>0)
    if(x>100)
    	{x=x-10; y--;} //第一条路径的时间复杂度为o(y)
    else x++;          //第二条路径的时间复杂度为o(10y+1)

• 对于条件判断语句，总的时间复杂度等于其中 时间复杂度最大的路径 的时间复杂度。
• 故本题时间复杂度为：o(n)

for (i=0; i<n; i++)			//循环次数为n 
    for (j=0; j<m; j++)		//循环次数为m
        a[i][j]=0;  	   //循环体时间复杂度为o(1)

• 对于多个循环，假设循环体的时间复杂度为 O(n)，各个循环的循环次数分别是a, b, c…，则这个循环的时间复杂度为 O(n×a×b×c…)。分析的时候应该由里向外分析这些循环。
• 故本题时间复杂度为：o(n*n)

s=0;
for (i=0; i<n; i++)			//循环次数为n 
    for (j=0; j<m; j++)		//循环次数为m
        s+=B[i][j];			//循环体时间复杂度为o(1)
sum=s;

• 对于顺序执行的语句或者算法，总的时间复杂度等于其中最大的时间复杂度。
• 故本题时间复杂度为：o(n*n)

i=1
    while(i<=n)		//循环次数为log~3~n+1
        i=i*3;		//循环体时间复杂度为o(1)

• 故本题时间复杂度为： o(logn)

一.冒泡排序简介(从小到大排序）

​ 对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。

​ 针对所有的元素重复以上的步骤，除了最后一个，即需要进行length-1次。

​ 第一次是对n个数进行n-1次比较，进行到最后第n个的一个是最大的；

​ 第二次是对n-1个数进行n-2次比较，进行到最后第n-1个的一个是最大的；

​ ......

​ 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较

二.代码案例

package day1;
public class demo_sort {
    public static void main(String[] args) {
        //冒泡排序算法
        int[] numbers=new int[]{1,5,8,2,3,9,4};
        //需进行length-1次冒泡
        for(int i=0;i<numbers.length-1;i++)
        {
            for(int j=0;j<numbers.length-1-i;j++)
            {
                if(numbers[j]>numbers[j+1])
                {
                    int temp=numbers[j];
                    numbers[j]=numbers[j+1];
                    numbers[j+1]=temp;
                }
            }
        }
        System.out.println("从小到大排序后的结果是:");
        for(int i=0;i<numbers.length;i++)
            System.out.print(numbers[i]+" ");
    }
}