2.4学习周结

栈是限定仅在表尾进行插入和删除操作的线性表。允许去插入和删除的一端叫做栈顶,另一端称为栈底,不含任何元素的栈称为空栈,是后进先出的线性表。

栈的主要操作

  1. 进栈(Push):将元素插入到栈顶。
  2. 出栈(Pop):将栈顶元素删除并返回。
  3. 获取栈顶元素(Top):返回栈顶元素的值,但不对栈做任何修改。
  4. 判空(isEmpty):判断栈是否为空栈。
  5. 获取栈的大小(getSize):返回栈中元素的个数。

栈的顺序存储结构

栈的顺序存储结构可描述为: 

#define MAXSIZE 50  //定义栈中元素的最大个数
typedef struct
{
    int data[MAXSIZE];
    int top;        //用于栈顶指针
}SqStack;

初始化

void InitStack(SqStack *s)
{
    s->top=-1;    //栈顶指针初始化为-1,表示栈为空
}

判栈空

int StackEmpty(SqStack *s)
{
    if(s->top==-1)
        return 0;   //栈空
    else return -1; 
}

进栈

int Push(SqStack *s, ElemType e)
{
    //满栈
    if(s->top==MAXSIZE-1)
        return -1;
    s->top++;   //栈顶指针加1
    s->data[s->top]=e;    //将新插入元素赋值给栈顶空间
    return 0;
}

出栈

int Pop(SqStack *s, ElemType *e)
{
    if(s->top==-1)
        return -1;  //栈空
    *e=s->data[s->top];   //将要删除的栈顶元素赋值给e
    s->top--;   //栈顶指针减1
    return 0;
}

读栈顶元素

int GetTop(SqStack *s, ElemType *e)
{
    if(s->top==-1)   //栈空
        return -1;
    *e=s->data[s->top];   //记录栈顶元素
    return 0;
}

共享栈

利用栈底位置相对不变的特征,可让两个顺序栈共享一个一维数组空间,将两个栈的栈底分别设置在共享空间的两端,两个栈顶向共享空间的中间延伸。

共享栈的数据结构可以描述为:

#define MAXSIZE 50
typedef struct 
{
    int data[MAXSIZE];
    int top1;  // 第一个栈的栈顶指针
    int top2;  // 第二个栈的栈顶指针
}SharedStack;

共享栈的判断条件

栈空条件:1号栈【top1==-1】;1号栈【top2==MAXSIZE】

栈满条件:top2-top1=1

栈的链式存储结构

链栈

采用链式存储的栈称为链栈,通常采用单链表实现。链栈可以动态地增加和删除元素,不受容量限制,不存在栈满上溢的情况。

栈的链式存储

//构造结点
typedef struct StackNode
{
    int data;
    struct StackNode *next;
}LinkStackPrt;
//构造链栈
typedef struct LinkStack
{
    LinkStackPrt *top;
    int count;
}LinkStack;

队列

队列是只允许在一端进行插入操作,而在另一端进行删除操作的线性表队列是一种先进先出的线性表。允许插入的一端称为队尾(Rear),允许删除的一端称为队头(Front)。

队列的主要操作

  1. 入队(enqueue):将元素插入到队列的尾部。
  2. 出队(dequeue):从队列的头部删除一个元素。
  3. 队列是否为空(isEmpty):判断队列是否为空。
  4. 队列大小(size):返回队列中元素的个数。
  5. 获取队头元素(front):返回队列的头部元素,但不删除。
  6. 清空队列(clear):清空队列中的所有元素。

队列的顺序存储结构

队列的顺序存储结构可描述为: 

#define MIXSIZE 50
typedef struct 
{
    int data[MIXSIZE];    // 队列的数据存储数组
    int front;            // 队列的头部指针
    int rear;             // 队列的尾部指针
} Queue;
#include 
#define MIXSIZE 50
 
//队列的顺序存储类
typedef struct 
{
    int data[MIXSIZE];    // 队列的数据存储数组
    int front;            // 队列的头部指针
    int rear;             // 队列的尾部指针
} Queue;
 
//初始化队列的指针
void initQueue(Queue *q) 
{
    q->front=q->rear=0;
}
 
// 判断队列是否已满
int isFull(Queue *q) 
{
    if((q->rear+1)%MIXSIZE==q->front)
        return 1;//满
    else return 0;
}
 
// 判断队列是否为空
int isEmpty(Queue *q) 
{
    if(return q->front==q->rear)
        return 1;//空
    else return 0;
}
 
//求队列当前长度
int QueueLength(Queue *q)
{
    return (q.rear-q.front+MAXSIZE)%MAXSIZE;
}
 
 
// 入队操作
void enqueue(Queue *q, int value) 
{
    if(isFull(q)) 
    {
        printf("Queue is full.\n");
        return;
    }
 
    q->data[q->rear]=value;
    q->rear=(q->rear+1)%MIXSIZE;
}
 
// 出队操作
int dequeue(Queue *q) 
{
    if(isEmpty(q)) 
    {
        printf("Queue is empty.\n");
        return -1;
    }
    
    int value=q->data[q->front];
    q->front=(q->front+1)%MIXSIZE;
    return value;
}

队列的链式存储结构

链队列

队列的链式存储结构即为链队列,是一个同时带有队头指针和队尾指针的单链表,只能尾进头出。

1)链队列由结点构成,每个结点包含一个元素和一个指向下一个节点的指针。

2)链队列有两个指针:队首指针和队尾指针。初始时,队首指针和队尾指针都指向空结点。

3)队首指针指向链队列中的第一个结点,队尾指针指向链队列中的最后一个结点。

4)当队列为空时,队首指针和队尾指针都指向空结点。

5)当队列不为空时,队首指针指向队列中的第一个结点,队尾指针指向队列中的最后一个结点。

6)在链队列中插入一个元素时,需要创建一个新结点,并将其插入到队尾节点的后面。

7)在链队列中删除一个元素时,需要删除队首结点,并将队首指针指向下一个节点。

队列的链式存储

// 定义链表节点结构体
typedef struct Node 
{
    int data;           // 数据域
    struct Node* next;  // 指针域
} Node;
 
// 定义链队列结构体
typedef struct 
{
    Node* front;  // 队头指针
    Node* rear;   // 队尾指针
} Queue;

0-1背包问题

0-1背包问题是一个经典的组合优化问题,其问题描述为:有一组物品,每个物品有重量和价值两个属性。现在有一个背包,它能承受的最大重量为W。要求在不超过背包承重的情况下,选择一些物品装入背包,使得装入的物品总价值最大。

思路

该问题的特点是每个物品只有选或不选两种情况,即0-1选择,不能选择部分物品装入。

解决该问题的常用方法是使用动态规划。

二维数组

定义一个二维数组dp[ ][ ],其中dp[i][j]表示在前i个物品中选择总重量不超过j的情况下的最大总价值。

动态规划的状态转移方程为:

1)若第i个物品的重量大于j,即wi > j,则dp[i][j] = dp[i-1][j],即当前物品不选;

2)若第i个物品的重量小于等于j,即wi <= j,dp[i][j] = dp[i-1][j](不选)或 dp[i][j] = dp[i-1][j-wi]+vi(不选),则 dp[i][j] = max ( dp[i-1][j] , dp[i-1][j-wi]+vi ),即当前物品选或不选,选择价值最大的情况。

最终的结果为dp[N][W],即在前N个物品中选择总重量不超过W的情况下的最大总价值。

一维数组

定义一个二维数组dp[ ],其中dp[j]表示在选择总重量不超过j的情况下的最大总价值。

动态规划的状态转移方程为:

1)若第i个物品的重量大于j,即wi > j,则dp[j] = dp[j],即当前物品不选;

2)若第i个物品的重量小于等于j,即wi <= j,dp[j] = dp[j](不选)或 dp[j] = dp[j-wi]+vi(不选),则 dp[j] = max ( dp[j] , dp[j-wi]+vi ),即当前物品选或不选,选择价值最大的情况。

最终的结果为dp[W],即在选择总重量不超过W的情况下的最大总价值。

 题目描述

辰辰是个天资聪颖的孩子,他的梦想是成为世界上最伟大的医师。为此,他想拜附近最有威望的医师为师。医师为了判断他的资质,给他出了一个难题。医师把他带到一个到处都是草药的山洞里对他说:“孩子,这个山洞里有一些不同的草药,采每一株都需要一些时间,每一株也有它自身的价值。我会给你一段时间,在这段时间里,你可以采到一些草药。如果你是一个聪明的孩子,你应该可以让采到的草药的总价值最大。”

如果你是辰辰,你能完成这个任务吗?

输入格式

第一行有 2 个整数 T(1≤T≤1000)和 (1≤M≤100),用一个空格隔开,T 代表总共能够用来采药的时间,M 代表山洞里的草药的数目。

接下来的 M 行每行包括两个在 1 到 100 之间(包括 1 和 100)的整数,分别表示采摘某株草药的时间和这株草药的价值。

输出格式

输出在规定的时间内可以采到的草药的最大总价值。

输入输出样例

输入 #1复制

70 3
71 100
69 1
1 2

输出 #1复制

3

说明/提示

【数据范围】

  • 对于 30% 的数据,M≤10;
  • 对于全部的数据,M≤100。
#include
int max[100010],time[1010],w[1010];
int main()
{
	int t,m,i,j;
	scanf("%d %d",&t,&m);
	for(i=1;i<=m;i++)
		scanf("%d %d",&time[i],&w[i]);
	for(i=1;i<=m;i++)
        for(j=t;j>=0;j--)//倒序哦,不然会重复 
            if(j>=time[i])//可以选择
                max[j]=max[j]>(max[j-time[i]]+w[i])?max[j]:(max[j-time[i]]+w[i]);
	printf("%d\n",max[t]);
}

你可能感兴趣的:(学习,数据结构)