1栈

1.栈的概念
1.1栈:在表尾插入和删除操作受限的线性表
1.2栈逻辑结构: 线性结构(一对一)
1.3栈的存储结构:顺序存储(顺序栈)、链表存储(链栈)
1.4栈的特点:
先进后出(fisrt in last out FILO表)，后进先出

//创建栈   
Stacklist create_stack()
{
        Stacklist list=(Stacklist)malloc(sizeof(stack_t));
        if(NULL==list)
        return NULL ;

        memset(list->data,0,sizeof(list->data));
        list->top=-1;
        return list;
}

  //入栈                                                                                  
 int push(datatype element,Stacklist list)
{
        //1判断栈满
        //2判断栈创建失败
        if(list==NULL||list->top==MAXSIZE-1)
        {
                return FALSE;
        }
        //3入栈，先加后压
        list->data[++list->top]=element;
        return SUCCESS;
}
//输出
int output(Stacklist list)
{
        //1判空
        //2判断创建失败
        if(list==NULL||list->top==-1)
        {
                return FALSE;
        }
        //3打印
        for(int i=0;i<list->top;i++)
        {
        printf("%.2f\n",list->data[i]);
        }
        putchar(10);
        return SUCCESS;
}
//出栈
int pop(Stacklist list)
{

        //1判空
        //2判断创建失败
        if(list==NULL||list->top==-1)
        {
                return FALSE;

        }
        printf("pop data is %.2f\n",list->data[list->top--]);
        return SUCCESS;
}

2队列

1.队列的概念
1.队列: 在表尾插入，表头删除的操作受限的线性表
2.逻辑结构:线性结构(一对一）
3.存储结构:顺序存储(顺序队列(假溢出)（循环队列)），链式存储(链式队列)
4.队列的特点:先进先出(fisrt in first out FIFO表)，后进后出

Queue create_queue()
{       Queue list=(Queue)malloc(sizeof(queuelist_t));
        if(NULL==list)
        return NULL;
        //初始化
        memset(list->data,0,sizeof(list->data));
        //队头队尾初始化
        list->front=list->rear=0;
        return list;
}
        //队列的插入
int enqueue(datatype element,Queue list)
{
        //判断队列是否创建
        //判断队列是否满
        if(NULL==list||list->rear==MAXSIZE)
        return FALSE;
        //3.插入在队尾部
        list->data[list->rear]=element;
        list->rear=(list->rear+1)%MAXSIZE;
        return SUCCESS;
        }
//队列的输出
int output(Queue list)
{
        //判断队列是否为空
        //判断队列是否创建
        if(NULL==list||list->front==list->rear)
        return FALSE;
        //3.循环打印对头--》队为的元素
        for(int i=list->front;i<list->rear;i=(i+1)%MAXSIZE)
        {
                printf("%d",list->data[i]);

        }
        putchar(10);
        return SUCCESS;
} //队列的删除
int delqueue(Queue list)
{
        //判断队列是否为空
        //判断队列是否创建
        if(NULL==list||list->front==list->rear)
        return FALSE;
        //3.删除在对头
        printf("delqueue data is %d n",list->data[list->front]);
        list->front=(list->front+list->rear)%MAXSIZE;
        return SUCCESS;
}
//计算队列长度
int get_len(Queue list)
{
return (MAXSIZE-list->front+list->rear)%MAXSIZE;
}

3哈希表

1.哈希表的概念
散列表(Hash table，也叫哈希表)，是根据关键码值(Key value)而直接进行访问的数据结构。也就是说，它通过把关键码值映射到表中一个位置来访问记录，以加快查找的速度。这个映射函数叫做散列函数，存放记录的数组叫做散列表。

除留余数法:
取关键字被某个不大于哈希表表长m的数p除后所得余数为哈希地址的方法
H(key)=key MOD p (p<=m)
m: 元素的个数除以3/4
p一般取不大于表长m的最大质数

3.哈希冲突
1.哈希冲突:不同的关键码值通过哈希函数映射在同一片内存
2.线性探测法: di=1，2，3，...，m-1，即从冲突地址向后依次查找空闲地址的处理冲突方法
3.二次探测法: di=1²，-1²，2²，-2²。。.(km/2) 即从冲突地址向前后以整数二次方为增量查找空闲地址的处理中冲突方法
4.伪随机探测法:di为确定的伪随机数序列(如3，5，8...，即将冲突地址加上序列中的伪随机数以查找空地址的处理冲突方法
5.再哈希法:在发生冲突时使用另一个哈希函数计算地址，直到不再发生冲突
6.链地址法:将所有哈希函数值相同的记录存储在同一线性链表中
7.建立公共溢出区:一旦发生冲突，都填入溢出表

//
//
Hashlist create_node()                                                                               
{       //1创建一个新节点
        Hashlist s=(Hashlist)malloc(sizeof(struct Node));                                            
        if(NULL==s)
        return NULL;
        //初始化新节点的数据域
        s->data=0;
        /初始化新节点的指针域                                                                        
        s->next=NULL:
        return s;                                                                                    
}     
//计算最大质数  
int max_prime(int m)                                                                                 
{
        for(int i=m;i>=2;i--)
        {
                int flag=0;                                                                          
                for(int j=2;j<=sqrt(i);j++)                                                          
                {                                                                                    
                        if(i%j==0)
                        {
                                flag=1;
                                break;
                        }
                }
                        if(flag==0)
                        return i;
        }
}
//插入
void insert_hash(int key,Hashlist hash[],int m)
{
        int p=max_prime(m);
        int sub=key%p;
        Hashlist head=hash[sub];//head
        Hashlist s=create_node():
        s->data=key;
        //1.判断链表为空
        if(head==NULL)
        head=s;
        //2.存在多个节点
        s->next=head;
        head=s;
        hash[ sub]=head;
}