第一章绪论
1.1 前言
algorithm+data=programs
（算法 +数据结构=程序）
1.1.1 数据结构
问题的数学模型，反映数据及其之间的关系。（存储结构和逻辑结构）
1.1.2 算法
处理问题的策略（是对数据运算的描述，是程序的逻辑抽象）
1.1.3 程序
为计算机处理问题而编制的一组指令集
1.1.4 求解问题的主要步骤
数学模型（逻辑结构）➡️存储结构➡️算法➡️编程并测试结果
1.1.5 程序设计的实质
选择好的数据结构和算法
问题一：N个数的选择问题。
假设有N个数，要求找出N个数中第k大的那个数。
算法一：将N个数读入一个数组，冒泡排序法递减排序，最后在已排序的数组中第k个数即为所求。（要求：内存空间足够容纳这N个数）
算法二：将N个数的前k个数读入一个数组，递减排序，再将剩下的数逐个读入，将其与数组中的第k个数比较，若大于则插入数组适当位置，数组最后一个数被挤出。
结论：都不是很好的算法。。。。
1.1.6 数据结构课程的内容体系
| 过程\方面 | 数据表示 | 数据处理 |
|---|---|---|
| 抽象 | 逻辑结构 | 基本运算 |
| 实现 | 存储结构 | 算法 |
评价 ：不同数据结构的比较和算法性能分析
小结：数据结构课程的研究内容
- 数据的逻辑结构
- 数据的存储结构/物理结构
- 数据的运算
1.2 基本概念与术语
- 数据与数据结构
- 数据类型
- 抽象数据类型
1.2.1 数据与数据结构
1.2.1.1 数据（data）
- 所有能被输入到计算机中，且能被计算机处理的符号的总称。（如：实数、整数、字符（串）、图形和声音等）
1.2.1.2 数据元素（data element）
- 是数据（集合）中的一个 “个体”
- 是数据结构中讨论的基本单位
- 也叫结点、顶点、记录
1.2.1.3 数据项（data item）
- 是数据结构中讨论的最小单位
- 数据元素是由若干个数据项组成
- 【组合项与简单项】
1.2.1.4 数据对象（data object）
- 是性质相同的数据元素的集合
【每一行是一个数据元素】
【每一列是对应的数据项】
【数据对象中的元素不会是孤立的，而是彼此相关的，这种彼此之间的关系称为 “结构”（线性表、图、树）】
1.2.1.5 数据结构（data structure）
- 是相互之间存在的一种或多种关系的数据元素的集合。
1.2.1.5.1逻辑结构
逻辑结构可用二元组形式定义为：
Data_Stracture =（D,R）
D是数据元素的有限集合，R是D上关系的有限集合。
1.2.1.5.2存储结构
是逻辑结构在计算机中的表示（即是逻辑结构在存储器中的映象）
例如：学生成绩表基于数组的顺序存储结构可描述如下：
- 学生成绩记录的类描述
public class class01{
public String studentNum;//学号
public String studentName;//学生姓名
public float mathScore;//数学分析
public float physicalscore;//普通物理
public float algebraScore;//高等代数
public String getStudentNum(){
return studentNum;
}
public void setstudentNum(String studentNum){
this.studentNum=studentNum;
}
...
}
- 基于数组的顺序存储的类描述
public class class02 {
private ResultsRecord[] listElem;//存放当前学生成绩的存储空间
private int cluLen;//当前学生成绩表的长度
...
}
1.2.5.2.2抽象数据类型（abstract data type，ADT）
- 是指一数据值的集合和定义在这个集合上的一组操作。
Abstract Data Type ={Objects} U {Operations}
> 例如：复数的ADT:
数据对象(Objects):(real,imag)
数据操作(Operation):
getReal():取当前复数的实部值；
getImag():取当前复数的虚部值；
setReal(real):修改当前复数的实部值；
setImag(imag):修改当前复数的虚部值；
add(z):与另一个负数的加法运算；
minus(z):与另一个负数的减法运算；
- 例1.3用Java接口来描述复数的抽象数据类型。
（假设复数的操作只包含一下操作。。）
//复数抽象数据类型的接口表示
public interface IComplex {
public double getReal();//取实部
public void setReal(double real);//修改实部
public double getImage();//取虚部
public void setImage(double image);///修改虚部
public void add(IComplex Z);//两个实数求和
}
- 例1.4编写实现【例1.3】中复数抽象数据类型的Java类代码
public class Complex implements IComplex{
private double real;//实部
private double image;//虚部
//构造一个实数
public Complex(double real,double image){
this.real=real;
this.imag=imag;
}
//取实部
public double getReal(){
return real;
}
//修改实部
public void setReal(double real){
this.real=real;
}
//取虚部
public double getImag(){
return imag;
}
//修改虚部
public void setImag(double imag){
this.imag=imag;
}
//两个实数的求和
public void add(IComplex Z){
if(Z!=null){
real += Z.getReal();
imag += Z.getImag();
}
}
}
1.3 算法与算法分析
1.3.1 算法的基本概念
1.3.1.1算法的5种性质
1.有穷性：有限步骤内结束，且每个步骤在有穷的时间内完成
2.确定性：1⃣️每条语句都是确定的，不会产生二义性2⃣️整个算法输出的结果在特定的输入情况下是确定的
3.有效性：算法中的每个步骤都可以有效执行
4.输入
5.输出
1.3.1.2算法设计的目标
1.正确性 2.可读性 3.健壮性（容错性）4.高效性（时间与空间）
1.3.2 算法的描述
- 例1：给出求整型数组a中最大值的算法
public static int maxEle(int[] a) {
int n = a.length;
int max = a[0];
for(int i=1;i<n;i++)
if(max<a[i])
max=a[i];
return max;
}
- 例2:（就地逆置）给出整型数组a中数据元素实现就地逆置的算法
public static void reverse(int[] a) {
int n = a.length;
int temp;
for(int i=0,j=n-1;i<j;i++,j--){
temp=a[i];
a[i]=a[j];
a[j]=temp;
}
}
1.3.3 算法分析
算法分析：算法复杂度的评判
1.3.3.1 时间复杂度T(n)
- 一个特定 算法的“运行工作量” 的大小，只依赖于 问题的规模（通常用整数n表示）。
- 它是问题规模的函数
- 定义：T(n)=O(f(n))
当且仅当存在正常数c和N，对所有的n(n>=N)满足0<=T(n)<=c*f(n)
1.3.3.2 时间复杂度T(n)的估算
- 算法=控制结构+原操作（固有数据类型的操作）
- 算法的执行时间=∑原操作(i)的执行次数*原操作(i)的执行时间
算法的实行时间与原操作执行次数之和成正比
例1:变量计量
//语句频度
x=0;y=0;s=0; //1
for(k=1;k<=n;++k){ //n+1
++x;s+=x;} //n
for(i=1;i<=n;++i) //n+1
for(j=i;j<=n;++j){//n(n+1)
++y;s+=y;} //n^2
//T(n)=2n^2+4n+3=O(n^2)
T(n)=2n2+4n+3=O(n2)
例2:两个矩阵相乘
public static squareMult(int[][]a,int[][]b,int[][]c,int n) {
for(int i=0;j<n;j++) //n+1
for(int j=0;j<n;j++){ //n(n+1)
c[i][j]=0; //n^2
for(int k=0;k<n;k++) //n^2(n+1)
c[i][j]+=a[i][k]*b[k][j];//n^3
}
}
T(n)=2n3+3n2+1=O(n3)
例3:
public static myOut(){
for(i=1;i<=n;i=10*i)
printf("%4d",i);
}
解：设关键操作语句的语句频度为f(n)，则有10f(n)<=n，所以f(n)<=log10n
故：T(n)=O(log10n)
1.3.3.2.1 最好、最坏、平均时间复杂度
- 例4:在数组中查找值为x的数据元素
public static int rSearch(int[]a,int x){
int n=a.length;
for(int i=0;i<n&&!x.equals(a[i]);i++);
if(i==n)
return -1;
else
return i;
}
最好时间复杂度：O(1)
最坏时间复杂度：O(n)
平均时间复杂度：O(n)
- 例5:冒泡排序法
public static void bubbleSort(int[]a,int n) {
int temp,flag=1;
for(int i=1;i<n&&flag;i++){
flag=0;
for(int j=0;j<n-i;j++){
if(a[j]>a[j+1]){
flag=1;
temp=a[j];
a[j]=a[j+1];
a[j+1]=tmep;
}
}
}
}
最好时间复杂度：O(n)：所有都是有序的，只需要扫描一遍
最坏时间复杂度：O(n2)：完全逆序
1.3.3.3 时间复杂度的排序
按增长率由小至大的顺序排列有：
1.3.3.3.1 多项式时间算法的时间复杂度
O(1) <O(logn) < O(n) < O(nlogn) < O(n2) < O(n3)
常量阶 对数阶 线性阶 线性对数阶 平方阶 立方阶
1.3.3.3.2 指数时间算法的时间复杂度
O(2n)<O(n!)<O(nn)
1.3.3.4 空间复杂度S(n)
S(n)=O(f(n))
1.3.3.4.1 算法优化（动态规划法）
- 问题描述：给定一个整数序列A1，A2，… An（可能有负数），求A1～An的一个子序列Ai～Aj，使得Ai～Aj的和最大。
- 例如：整数序列-2，11，-4，13，-5，2，-5，-3，12，-9的最大子序列的和为21（从A2～A9）；整数序列4，-3，5，-2，1，2，6，-2的最大子序列的和为11（从A1～A7）。
//动态规划法
public static int maxSub_4(int[]sequence){
int max =0;
int n = sequence.length;
int sum =0;
for(int i=0;i<n;i++){
sum +=sequence[i];
if(sum>max)
max=sum;
else if(sum<0)
sum=0;
}
return max;
}
//时间复杂度：O(n)
//只需要扫描一遍
扫一扫
250
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
