2021-8-8 数据结构和算法应用 -＞ 1、初探数据结构

目录

1.1.2关于空间使用

1.1.3关于算法效率

1.1.4抽象型数据结构

1.2算法

---

1.1.2关于空间使用

递归

#include <iostream>
#include <stdio.h>
using namespace std;


//递归函数 打印数字
void printN(int N)
{
	if (N)
	{
		printN(N - 1);
		printf("%d\n", N);
	}
	return;
}

int main()
{
	int a;
	cin >> a;
	printN(a);
	system("pause");

}

1.1.3关于算法效率

解决问题方法的效率，与算法的巧妙程度是有关系的

#include <iostream>
#include <ctime>
#include<cmath>
using namespace std;

//解决问题方法的效率，与算法的巧妙程度是有关系的


clock_t start, stop;
//clock_t是clock（）函数 返回的变量类型
double duration;
//记录被测函数运行时间 以秒为单位
#define MAXN 100000
double f1(int n, double a[], double x) 
{
	int i;
	double p = a[0];
	for (i = 1; i <= n; i++)
	{
		p += (a[i] * pow(x, i));
		return p;
	}

}
double f2(int n, double a[], double x) 
{
	int i;
	double p = a[n];
	for (i = n; i > 0; i--)
	{
		p = a[i - 1] +x * p;
		return p;
	}

}





void test01()
{
	int i;
	double a[MAXN];
	for (i = 0; i < MAXN; i++)
	{
		a[i] = (double)i;
	}
		//不在测试范围内的准备工作写在clock（）调用之前
		start = clock(); //开始计时
		f1(MAXN - 1, a, 1.1);	//把被测函数加入
		stop = clock(); //停止计时
		duration = ((double)(stop - start)) / CLK_TCK;//计算时间
		printf("ticks1 = %f\n", (double)(stop - start));
		printf("duration1 = %6.2e\n", duration);


	
}

void test02()
{
	int i;
	double a[MAXN];
	for (i = 0; i < MAXN; i++)
	{
		a[i] = (double)i;
	}
	//不在测试范围内的准备工作写在clock（）调用之前
	start = clock(); //开始计时
	f2(MAXN - 1, a, 1.1);	//把被测函数加入
	stop = clock(); //停止计时
	duration = ((double)(stop - start)) / CLK_TCK;//计算时间
	printf("ticks1 = %f\n", (double)(stop - start));
	printf("duration1 = %6.2e\n", duration);



}

int main()
{
	test01();
	test02();

	//不在测试范围内的准备工作写在clock（）调用之前
	start = clock(); //开始计时
	myFunction();	//把被测函数加入
	stop = clock(); //停止计时
	duration = ((double)(stop - start)) / CLK_TCK;//计算时间
	system("pause");

	//其他不在测试范围内的处理写在后面，例如输出duration的值
	return 0;
}

1.1.4抽象型数据结构

抽象数据类型
数据类型
1、数据对象集
2、数据集合相关联的操作集

抽象：描述数据类型的方法不依赖于具体实现
1、与存放数据的机器无关
2、与数据存储的物理结构无关
3、与实现操作的算法和编程语言无关

只描述数据对象集和相关操作集“是什么”，并不涉及“如何做到”的问题

---

1.2算法

一个有限指令集
1、接受一些输入（有些情况下不需要输入）
2、产生输出
3、一定在有限步骤之后停止
4、每一条指令必须
   *有充分的目标，不可以有歧义
   *计算机能处理的范围之内
   *描述应不依赖于任何一种计算机与语言以及具体的实现手段

衡量算法的标准：

1、空间复杂度
根据算法写成的程序在执行时占用存储单元的长度

2、时间复杂度
根据算法写成的程序在执行时耗费时间的长度

分析一般算法的效率的时候，我们经常关注下面两个复杂度
1、最坏情况复杂度
2、平均复杂度

最坏情况复杂度 小于等于 平均情况复杂

复杂度的渐进表示法

T(n) = O(f(n))表示的是复杂度的上界
T(n) = Ω(f(n))表示的是复杂度的下界
T(n) = Θ(f(n))表示的是复杂度的上界等于下界等于T(n)

复杂度分析小窍门

若两端算法分别有复杂度T1(n) = O(f1(n))和T2(n) = O(f2(n))，则
    T1(n) + T2(n) = max(O(f1(n)),O(f2(n)))
    T1(n) * T2(n) = O(f1(n) * f2(n))

若T(n)是关于n的k阶多项式，那么T(n) = Θ(n的k次方)

一个for循环的时间复杂度等于循环次数乘以循环体代码的复杂度

if-else结构的复杂度取决于if的条件判断复杂度和两个分支部分的复杂度，总体复杂度取三者中的最大。

---

1.3.1算法应用实例

#include <iostream>
using namespace std;
//求整数序列最大和
//算法1
int MaxSubseqSum1(int A[], int N)
{
	int Thissum, Maxsum = 0;
	for (int i = 0; i < N; i++)
	{
		for (int j = i; j < N; j++) {
			Thissum = 0;
			for (int k = i; k <= j; k++)
			{
				Thissum += A[k];
				if (Thissum > Maxsum)
					Maxsum = Thissum;
			}
		}
	}
}//T(N) = O(N的三次方)

//算法二
int MaxSubseqSum2(int A[], int N)
{
	int Thissum, Maxsum = 0;
	for (int i = 0; i < N; i++)
	{
		Thissum = 0;
		for (int j = i; j < N; j++) {
			for (int k = i; k <= j; k++)
			{
				Thissum += A[k];
				if (Thissum > Maxsum)
					Maxsum = Thissum;
			}
		}
		return Maxsum;
	}
}//T(N) = O(N的二次方)

//算法三：分而治之

//算法四：在线处理
int MaxSubseqSum4(int A[], int N)
{
	int Thissum, Maxsum = 0;
	for (int i = 0; i < N; i++)
	{
		Thissum += A[i];
		if (Thissum > Maxsum)
		{
			Maxsum = Thissum;
		}
		else
		{
			Thissum = 0;
		}
	}
	return Maxsum;
}//T(N) = O(N)

int main()
{

	system("pause");
}