数据结构与算法

数据结构：

如何存储数据 ：变量、数组.....

程序 = 数据结构 + 算法

指针：char *p：用于间接访问已有的数据的地址

数组：cahr a[1024]：开辟出一块空间用来放自己的数据

指针数组：

char *arg[10]:就是相当于指针，只不过是定义了多个指针。用来操作数据，如果数据为局部，使用后销毁，则指针就成了野指针

二维数组：char buff[10][1024]:用来保存多个数据

数据库也是数据结构

数据结构：组织存储数据---------->内存

数据与数据之间的关系;

数据的逻辑结构：数据元素之间的关系

集合：平等关系

线性结构：一对一的关系：（表（数组，链表），队列，栈....）

由当前数据向前找只能找到一个，向后也只能找到一个

树形结构：一对多的关系：二叉树

由当前数据向后找能找到至少两个、向前只有一个

图形结构：多对多的关系：网状结构

数据的物理结构：数据的逻辑结构在计算机内存中的存储关系

顺序存储：采用一段连续的内存空间保存元素

链式存储：

提高效率：

索引存储：通过关键字构建索引表，通过索引表找到数据的存储位置

散列存储（哈希存储）:

数组和链表区别：

数组：

空间连续

访问数据方便(O(1))

插入和删除需要移动大量数据：(0(N))

预分配内存空间

容易产生内存碎片

内存碎片：内内存碎片，外内存碎片

内内存碎片：1.按照指定字节对齐 2.结构体成员分布

链表：

空间不连续

访问数据需要遍历(O(n))

插入和删除只需要移动指针：(O(1))

不需要预分配

利用内存碎片

线性结构：

顺序表--------->数组

链式表--------->链表

链表：

单向链表：

有头链表：第一个节点不保存数据

无头链表：从第一个节点开始数据域就保存数据

高内聚：一个模块只干一件事

面向对象的编程思想：

用什么做什么

练习：

link.h文件

#ifndef _LINK_H
#define _LINK_H

typedef int DataType;

/*链表的节点类型*/
typedef struct node
{
    DataType data;
    struct node *pnext;
}Link_node_t;


typedef struct link
{
    struct node *phead;
    int clen;
}Link_t;

extern Link_t *pnode_create();
extern int push_link_head(Link_t *plink,DataType data);
extern void *ergodic_linked(Link_t *plink);
extern int push_link_end(Link_t *plink,DataType data);

extern int pop_link_head(Link_t *plink);
extern int pop_link_end(Link_t *plink);
extern Link_node_t * find_link(Link_t *plink,int a);
extern void alter_link(Link_t *plink,int a,int b);
extern void choose_link(Link_t *plink,int a);
extern void destory_link(Link_t *plink);
extern int link_lenth(Link_t *plink);
extern Link_node_t *find_mid_link(Link_t *plink);
extern Link_node_t *find_assign_link(Link_t *plink,int k);
extern void del_assign_link(Link_t *plink,int a);

#endif

单向链表头插：

Link_t *pnode_create()
{
    Link_t *plink = malloc(sizeof(Link_t));
    if(plink == NULL)
    {
        perror("fail malloc");
        return NULL;
    }

    plink->phead = NULL;
    plink->clen = 0;

    return plink;
}

int push_link_head(Link_t *plink,DataType data)
{
    Link_node_t * pnode = malloc(sizeof(Link_node_t));
    if(NULL == pnode)
    {
        perror("fail malloc");
        return -1;
    }
    pnode->data = data;
    pnode->pnext = NULL;

    pnode->pnext = plink->phead;
    plink->phead = pnode;

    plink->clen ++;

    return 0;
}

尾插：

int push_link_end(Link_t *plink,DataType data)
{
    Link_node_t *p = plink->phead;
    Link_node_t *pnode = malloc(sizeof(Link_node_t));
    if(NULL == pnode)
    {
        perror("fail malloc");
        return -1;
    }

    if(p == NULL)
    {
        push_link_head(plink,data);
    }
    else
    {
        while(p->pnext)
        {
            p = p->pnext;
        }
        pnode->pnext = NULL;
        pnode->data = data;
        p->pnext = pnode;
    }
    plink->clen++;
    return 0;
}

头删：

int pop_link_head(Link_t *plink)
{
    Link_node_t *p = plink->phead;
    if(p ==NULL)
    {
        return -1;
    }
    else
    {
        plink->phead = p->pnext;
        free(p);
    }
    plink->clen--;
    return 0;
}

尾删：

int pop_link_end(Link_t *plink)
{
    Link_node_t *p = plink->phead;
    if(p == NULL)
    {
        return -1;
    }else if(p->pnext ==NULL)
    {
        pop_link_head(plink);
    }
    else
    {
        while(p->pnext->pnext !=NULL)
        {
            p = p->pnext;
        }
        free(p->pnext);
        p->pnext = NULL;
    }
    plink->clen--;
    return 0;
}