数据结构

第一章 算法

1.1 算法的时间复杂度

1. 时间复杂度的定义：
   （1）时间复杂度表示为O(f(n))，随问题规模n的逐渐增大，算法时间的增长率和f(n)相同
   （2）O(1)：常数阶
   （3）O(n)：线性阶
   （4）O((n^2))：平方介
   （5）O((log_2n))：对数阶

   while(count < n){
       //每次循环，count都会离n进一步，需要循环对数次
       count = count*2;
   }
   

2. 推到O阶的方法
   （1）用常数1取代运行时的所有加法
   （2）修改后的运行次数函数中，只保留最高阶
   （3）如果最高阶存在且不是1，则去除这个项相乘的常数。
   上面三部得到的结果就是O的阶
   （4）eg：如下例子的复杂度
   当i=0时，内循环执行了n次；当n=1时，执行了n-1次，所以总次数为n+(n-1)+(n-2)+...+1 = (frac{1}{2}n^2+frac{1}{2}n) 。 因此时间复杂度为O((n^2))

   for(int i=0;i<n;i++){
       for(j=i;j<n;j++){
           /* 事件复杂度为O(1)的程序步骤  */
       }
   }
   

（5）又一个例子
操作总次数=1+1+(frac{n(n+1)}{2}),所以时间复杂度为O((n^2))

```c
n++;   /* 执行次数为1 */
fun(n);    /* 执行次数为1 */
for(int i=0;i<n;i++){   /* 执行次数为如上面的例子 */
    for(int j=i;j<n;j++){
        /*时间复杂度为O(1)的操作*/
    }
}
```

1.2 常用事件复杂度的比较

1. 时间复杂度公式
   (O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(n!) < O(n^n))

第七章 图

7.1 概念

1. 连通图：如果图中任意两点都有路径，则该图是连通图
2. 若一个有向图恰有一个顶点的入度为0，其与定点入度为1，则是一颗有向树

7.2 图的物理存储结构

因为图的节点度数相差很大，按照度数最大的顶点设计节点结构会造成存储单元浪费；如果按照每个顶点自己的度数设计不同结构，又会带来操作的不便

一、邻接矩阵

1. 邻接矩阵存储使用2个数组存储图的信息：1个以为数组存储顶点，一个二维数组存储边的信息
   （1）二维数组中的对角线为0，以为不存在顶点到自身的边
   （2）要知道某个点的出度，就是顶点vi在第i行的元素之和，入度就是该顶点所在列的元素之和
   （3）顶点vi的所有邻接点就是吧矩阵中第i行元素扫描一遍
             
   （4）对于有权值的网，二维数组中的元素不再是0,1表示是否存在边，而是把元素值表示为权值。不存在的边，权值记录为(infty)；对角线上的权值为0.
   
2. 邻接矩阵定义图

#include <stdio.h>
typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 100
#define IUNFINITY 65535
typedef struct {
    VertexType vexs[MAXVEX];        /* 顶点表*/
    EdgeType arc[MAXVEX][MAXVEX];   /* 邻接矩阵 */
    int vnum,edgenum;               /*定点的个数和边的个数*/
}MGraphy;

void createGraphy(MGraphy *g){
    printf("input vetex num and edge num
");
    scanf("%d,%d",&g->vnum,&g->edgenum);

    for (int i = 0; i < g->vnum ; i++) {                      // 输入顶点字符
        printf("input %d vetex:",(i+1));
        setbuf(stdin, NULL);
        scanf("%c",&g->vexs[i]);
    }

    for(int i=0;i<g->vnum;i++){                               // 初始化数组元素 Infonity
        for(int j=0;j<g->vnum;j++){
            g->arc[i][j] = IUNFINITY;
        }
    }

    printf("input a,b,c represent corner mark and weight
");
    for(int i=0;i<g->edgenum;i++){
        int a,b,c=0;
        printf("%d edge:",(i+1));
        setbuf(stdin,NULL);
        scanf("%d,%d,%d",&a,&b,&c);
        g->arc[a][b] = c;
        g->arc[b][a] = c;    // 无向图增加这个
    }


 /*   for(int i=0;i<g->vnum;i++){   // 初始化数组wei Infonity
        for(int j=0;j<g->vnum;j++) {
            printf("arr[%d][%d]=%d,,,",i,j,g->arc[i][j]);
        }
    }*/
}
int main() {
    MGraphy g ;
    createGraphy(&g);
}

二. 邻接表

1. 邻接矩阵对于顶点多而边数少的稀疏图造成存储空间的大量浪费。正如线性表的预先分配可能造成存储空间浪费，因此引入链式存储结构。同样可以考虑用链表存储边或弧。
2. 邻接表：数组 + 链表
   （1）用的数组存储每个节点
   （2）数组中的每个节点的所有邻接点组成一个链表(因为邻接点的个数不确定)。这个邻接表就是顶点的出度表。
3. 邻接表关心了出度，但是查找入度就需要遍历整个图
4. 代码

#include <stdio.h>
typedef char VertexType;
typedef int EdgeType;
#define MAXVEX 100
#define IUNFINITY 65535

typedef struct EdgeNode{     /*  边表结点 */
    int adjvex;                         /*  邻接点域，该顶点对应的下标  */
    EdgeType weight;              /*  定点的权重  */
    EdgeNode *next;               /*  链，指向下一个邻接点  */
}EdgeNode;

typedef struct VertexNode{           /*  顶点表结点  */
    VertexType data;                        /*  节点名字  */
    EdgeNode *firstedge;                  /*  边表头节点  */
}VertexNode,AdjList[MAXVEX];

typedef struct{
    AdjList adjList;                            /*  顶点表是一个结构体数组，数组中的元素是Vertex节点  */
    int vnum,enumber;                         /*  图中当前顶点和边数  */
}GraphyAdjList;

/*  建立邻接表结构  */
void createGraphy(GraphyAdjList *g){
    EdgeNode *e;
    printf("输入顶点数和边数:
");
    setbuf(stdin,NULL);
    scanf("%d,%d",&g->vnum,g->enumber);
    for (int i = 0; i < g->vnum; i++) {
        printf("请输入第%d个节点名",(i+1));
        setbuf(stdin,NULL);
        scanf("%c",&g->adjList[i].data);
    }
 }

int main() {
    MGraphy g ;
    createGraphy(&g);
}