【数据结构】第一讲 基本概念&&最大子列和问题

1.1什么是数据结构

例1：有一堆书，一个书架，如何去存储？

很不科学，因为没有说书架的样式—也即存储空间的规模，数据的规模。

• 1.新书怎么插入
• 2.怎么找到一本书

方法一：随便放

1. 放起来简单，查起来就难，必然是个平衡的问题。

方法二：

1. 按字母序放，然后查找时候二分查找。
2. 然而，插入一本书，比如A开头，那么其他书都得全部后移。

方法三：

1. 把书架划分成几块区域，每块区域指定摆放某种类别的图书；在每种类别内，按照书名的拼音字母顺序排放

• 1.如何找某本指定的书？在二分查找之前，先定一个类别，然后在这个类别下进行二分查找。
• 2.如何插入一本书？先定类别，二分查找找到该插入的位置，再插入，移空位，插入。

另外引出的问题：空间如何分配？(藏书量不同，给多了有闲置，给少了，进新书需要加柜子)类别分多细比较好呢？(类别太多也不好分)

总结：解决问题方法的效率，跟数据的组织方式有关

例2：顺序打印1-n(n是一个输入的数字)

对比两个函数的效率：

for(int i=0;i<n;++i)
{
	cout<<i<<endl;
}

递归调用函数:(好像还没用到临时变量，更省空间)

void printN(int n)
{
if(n)
{
	printN(n-1);
	cout<<n<<endl;
}
return;
}

每次一个递归调用函数，都需要把目前函数的进行状态存储起来，再进入递归函数。
n=10000000直接罢工！因为递归吃掉了所有可利用空间还不够用！
空间复杂度正比于问题规模。

解决问题方法的效率，跟空间的利用效率有关。

例3：对比两个函数计算多项式函数的时间

f(x)=a0+a1*x+a2*x^2+...+an*x^n

单步计算每一项求和：(实际上浪费了很多计算，计算了比如计算了x^n-1，但没有用这个值去计算x^n，而是重新计算)

本质：因为pow，执行了（1+2+3+…+n）次乘法

double f(int n,double a[],double x)
{
	int i;
	double p=a[0];
	for(i=0;i<=n;i++)
	{
		p+=(a[i]*pow(x,i));
	}
	return p;
}

括号优先级运算:(执行了n次乘法)

double f(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;
}

如果函数跑的太快，定义一个

#define MAXX 1e7
//for循环执行这个函数

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

例四：矩阵抽象数据类型定义

• 类型名称：矩阵(Matrix)
• 数据对象集：一个MN的矩阵(I=1,…,M，j=1…N)由MN个三元组<a,i,j>组成，a为值，i是行号，j是列号。(抽象在于没有提示到底是用一个二维数组，还是一维数组，还是十字链表 )
• 操作集：’
• • Matrix Create(int M,int N):范围M*N的空矩阵。
• • int GetMaxrow(Matrix A):获得矩阵A的总行数。
    实际需要什么的时候，直接使用一个define
#define ElementType float/int/...
    这样就避免了对int实现了一遍，但下一次要double类型的。

到底什么是数据结构

数据对象在计算机中的存储方式

• 数据的逻辑结构（1:1(线性结构)，1:n(树形结构)，m:n(图形结构)）
• 数据的物理结构 在内存里到底是什么放法，数组(连起来)还是链表(东一个，西一个)。

1.2什么是算法

算法(Algorithm)

• 一个有限的指令集
• 有输入
• 有输出
• 有限步骤后终止
• 每一条指令必须有充分，明确的目标，计算机能够处理，不依赖于任何语言

例1：选择排序算法的伪码描述

void SelectSort(int List[],int N)
{//将N个整数List[0]...List[N-1]进行非递减排序
	for(i=0;i<N;i++)
	{
		MinPosition=ScanForMin(List,i,N-1);
		//从List[i]到List[N-1]找最小元，将其位置赋值给MinPosition
		Swap(List[i],List[MinPosition]);
		//将未排序部分的最小元素换到有序部分的最后位置
	}	
}

即便代码写成这样，但依旧很抽象：

• List到底是数组还是链表（虽然看上去很像数组）
• Swap用函数还是宏去实现。

分析复杂度

一般关心最坏情况下复杂度，而不是平均，因为平均不好计算。
机器运行加减法的速度比乘除法快很多，加减法忽略不计。

二分法查找代码

int f(int List[],int X,int N)
{
	int Middle=0;
	int left_hand=0;
	int right_hand=N-1;
	while(left_hand<=right_hand)
	{   
	    middle=(left_hand+right_hand)/2;
		if(List[Middle]>X)
		{
			right_hand=Middle-1;
		}
		else if(List[Middle]<X)
		{
			left_hand=Middle+1;
		}
	    else if(List[Middle]==X)
		    return Middle;
	}
	return -1;
}

//最好的时间复杂度T(1)，最坏的时间复杂度T(n)=(log2N)，空间复杂度为O(n)

⭐1.3应用实例：最大子列和

给定N个整数的序列{A1,A2…An}，求函数

的最大值

算法一：蛮力(计算全部结果)

原始版$O(n^3)$

很笨的计算方法，很多重复计算的结果，$O(n^3)$

int MaxSubseqSum1(int A[],int N)
{
	int ThisSum,MaxSum=0;
	int i,j,k;
	for(i=0;i<N;++i)//i是子列左端位置
	{
		for(j=i;j<N;++j)//j是子列右端位置
		{
			ThisSum=0;//ThisSum是A[i]到A[j]的子列和
			for(k=i;k<=j;++k)//对子列求和
			{
				ThisSum+=A[k];
			}
			if(ThisSum>MaxSum)//判断是不是最大
				MaxSum=ThisSum;
		}
	}
}

改进版$O(n^2)$

实际上没必要从头开始加那么多，当j增加一个的时候，让thissum加上A[j]这一个元素即可。
参考：

int MaxSubseqSum2(int A[],int N)
{
	int ThisSum,MaxSum=0;
	int i,j,k;
	for(i=0;i<N;++i)//i是子列左端位置
	{
		ThisSum=0;//ThisSum是A[i]到A[j]的子列和
		for(j=i;j<N;++j)//j是子列右端位置
		{
			ThisSum+=A[j];
			//对相同的i不同的j，只要在j-1次循环的基础上累加1项即可。
			if(ThisSum>MaxSum)//判断是不是最大
				MaxSum=ThisSum;
		}
	}
}

算法三：分治算法$O(nlo{g}_2^n)$

一分为二，递归得到两边的子问题，以及跨越边界的子列和。
比较小问题和跨边界问题，看哪个值大。
$T(N)=2T(N/2)+cNT(1)=O(1)$

最大子列和问题（C语言、分治算法）

int MaxSubseqSum3(int data[], int left, int right)
{
    int mid;
    int leftMaxSum, rightMaxSum;//左右小问题的最大长度
    int leftBoardSum, rightBoardSum;//左右循环求含边界的和
    int leftMaxBoardSum, rightMaxBoardSum;//记录左右含边界的最大的和
   /* 退出条件 */
    if (left == right) 
        return data[left];

	/* “分的过程” */
    mid = (left + right) / 2; //找到中分点
    
    /* 递归求两边的最大值 */
    leftMaxSum = DivideConquer(data, left, mid);  // 左边最大值
    rightMaxSum = DivideConquer(data, mid + 1, right);  // 右边最大值
    
	 /* 跨越边界的最大值 := leftMaxBoardSum + rightMaxBoardSum  */
     leftMaxBoardSum = data[mid];
     leftBoardSum = 0;
     for (int i = mid; i >= left; i--) {/* 从中线向左扫描 */
        leftBoardSum += data[i];
        if (leftBoardSum > leftMaxBoardSum)
            leftMaxBoardSum = leftBoardSum;
     }   //左边界扫描

    rightMaxBoardSum = data[mid + 1];
    rightBoardSum = 0;
    for(int i = mid + 1; i <= right; i++) {/* 从中线向右扫描 */
        rightBoardSum += data[i];
        if(rightBoardSum > rightMaxBoardSum)
            rightMaxBoardSum = rightBoardSum;
    }  //右边界扫描 
    // 治的过程，最大值为左边的最大值、右边最大值，跨越边界最大值之中的最大值 
    return MaxofThreeNum(leftMaxSum, rightMaxSum, leftMaxBoardSum + rightMaxBoardSum);//返回三个数中的最大数
}

算法四：在线处理$O(N)$

在线是指对每输入一个数据，就进行"即时"处理。

int MaxSubSeqSum4(int A[],int N)
{
	int ThisSum,MaxSum;
	int i;
	ThisSum=MaxSum=0;
	for(i=0;i<N;++i)
	{
		ThisSum+=A[i];//向右累加
		if(ThisSum>MaxSum)//发现更大的子列和则更新
			MaxSum=ThisSum;
		else if(ThisSum<0)//如果当前子列和为负
			ThisSum=0;//则不能使后面的部分和增大，抛弃之
	}
	return MaxSum;
}

题目链接：7-1 最大子列和问题 (20 分)

题目：

<输入格式:
输入第1行给出正整数K (≤100000)；第2行给出K个整数，其间以空格分隔。

输出格式:
在一行中输出最大子列和。如果序列中所有整数皆为负数，则输出0。

输入样例:
6
-2 11 -4 13 -5 -2
输出样例:
20

代码

#include <iostream>
using namespace std;
int MaxSubSeqSum4(int A[],int N)
{
	int ThisSum,MaxSum;
	int i;
	ThisSum=MaxSum=0;
	for(i=0;i<N;++i)
	{
		ThisSum+=A[i];//向右累加
		if(ThisSum>MaxSum)//发现更大的子列和则更新
			MaxSum=ThisSum;
		else if(ThisSum<0)//如果当前子列和为负
			ThisSum=0;//则不能使后面的部分和增大，抛弃之
	}
	return MaxSum;
}
int main()
{
    int n;
    cin>>n;
    int* a=new int[n];
    for(int i=0;i<n;++i)
    {
            cin>>a[i];
    }
    cout<<MaxSubSeqSum4(a,n);
}

穿插分治思想：二分归并排序

二分归并排序算法MergeSort思想：
将别排序数组分成相等的两个子数组，然后用同样的算法对两个数组分别排序，最后将两个数组归并成一个数组。
对小数组$L[1...2]$进行排序时，按照算法进行进一步划分，划分结果是$L[1]$和$L[2]$。各含有一个元素，不需要排序，这时算法将停止递归调用并开始归并。

MergeSort()伪码描述

算法1.5 $MergeSort(A,p,r)$

输入：数组$A[p..r]$,1<=p<=r<=n
输出：从A[p]到A[r]按照递增顺序排好的数组A

void MergeSort(A,p,r)
{
	if(p<r)
		q=(p+r)/2;
	MergeSort(A,p,q);
	MergeSort(A,q+1,r);
	Merge(A,p,q,r);	//关键实现在于Merge()函数
}

其中的$Merge(A,p,q,r)$函数是将两个排好序的数组$A[p..q]$和$A[q+1...r]$合并成一个大数组

基本思想：将两个小数组分别复制到B与C中，A变成空数组，用来存放排好序的大数组。接着算法比较B与C的首元素，如果哪个元素较小，就把它放到A中，比较1次，移走B或者C中1个元素，如果B或者C中的一个变成空数组，那么把另一个数组的剩下所有元素复制到A中。伪码描述如下：

输入：按照递增顺序排好序的数组$A[p..q]$与$A[q+1..r]$
输出：按照递增顺序排好序的数组$A[p..r]$

void Merge(A,p,q,r)
{	
	int i,j,k;
	int x=q-p+1;int y=r-q;
	//将A[p..q]复制到B[1..x]，将A[q+1..r]复制到C[1..y]
	for(i=p;i<=q;++i)
	{
		B[i-p+1]=A[i];
	}
	for(i=q+1;i<=r;++i)
	{
		C[i-q]=A[i];
	}
	i=1,j=1,k=p;
	while(i<=x&&j<=y)
	{
		if(B[i]<=C[j])
		{
			A[k]=B[i];
			++i;
		}
		else
		{
			A[k]=C[j];
			++j;
		}
		++k;
	}
	//if(i>x) then 将C[j..y]复制到A[k..r]//i所在数组复制完而越界
	if(i>x)
	{
		for(i=j;i<=y;++i)//i已经失去作用，拿来做变量
			{A[k]=C[k];++k}
	}
	//else 将B[i..x]复制到A[k..r]//j所在数组复制完而越界
	else
	{
		for(j=i;j<x;++j)
		{A[k]=B[j];++k}
	}
}