第一讲 基本概念（1:15:26）[陈越]

一、什么是数据结构

1、如何在书架上放书

怎么放？  类别，书名，拼音首字母
怎么取指定的书？ 

2、多项式

使用java实现

public static void main(String[] args) {
    int max = 10000000;
    int n = 3;
    double[] a = {1.2, 3.2, 24.4, 6.5};
    double x = 2;
    long start = System.currentTimeMillis();
    for (int i = 0; i < max; i++) {
        double v = f1(n, a, x);
    }
    long end = System.currentTimeMillis();
    System.out.println(end - start);
    System.out.println("============");
    long start2 = System.currentTimeMillis();
    for (int i = 0; i < max; i++) {
        double v = f2(n, a, x);
    }
    long end2 = System.currentTimeMillis();
    System.out.println(end2 - start2);
}

public static double f1(int n, double[] a, double x) {
    int i;
    double p = a[0];
    for (i = 1; i <= n; i++) {
        p += (a[i] * Math.pow(x, i));
    }
    return p;
}

public static 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;
}

一百万次调用：第二个算法优于第一个算法

二、什么是算法

空间复杂度S(n)：占用存储单元的长度
时间复杂度T(n)：耗费时间的长度

消耗时间：

三、应用实例

  static int Max3(int A, int B, int C) { /* 返回3个整数中的最大值 */
     return A > B ? Math.max(A, C) : Math.max(B, C);
 }

 static int DivideAndConquer(int[] List, int left, int right) { /* 分治法求List[left]到List[right]的最大子列和 */
     int MaxLeftSum, MaxRightSum; /* 存放左右子问题的解 */
     int MaxLeftBorderSum, MaxRightBorderSum; /*存放跨分界线的结果*/

     int LeftBorderSum, RightBorderSum;
     int center, i;

     if (left == right) { /* 递归的终止条件，子列只有1个数字 */
         if (List[left] > 0) {
             return List[left];
         } else {
             return 0;
         }
     }

     /* 下面是"分"的过程 */
     center = (left + right) / 2; /* 找到中分点 */
     /* 递归求得两边子列的最大和 */
     MaxLeftSum = DivideAndConquer(List, left, center);
     MaxRightSum = DivideAndConquer(List, center + 1, right);

     /* 下面求跨分界线的最大子列和 */
     MaxLeftBorderSum = 0;
     LeftBorderSum = 0;
     for (i = center; i >= left; i--) { /* 从中线向左扫描 */
         LeftBorderSum += List[i];
         if (LeftBorderSum > MaxLeftBorderSum) {
             MaxLeftBorderSum = LeftBorderSum;
         }
     } /* 左边扫描结束 */

     MaxRightBorderSum = 0;
     RightBorderSum = 0;
     for (i = center + 1; i <= right; i++) { /* 从中线向右扫描 */
         RightBorderSum += List[i];
         if (RightBorderSum > MaxRightBorderSum) {
             MaxRightBorderSum = RightBorderSum;
         }
     } /* 右边扫描结束 */

     /* 下面返回"治"的结果 */
     return Max3(MaxLeftSum, MaxRightSum, MaxLeftBorderSum + MaxRightBorderSum);
 }

static int maxSubseqSum3(int[] List, int N) { /* 保持与前2种算法相同的函数接口 */
     return DivideAndConquer(List, 0, N - 1);
 }