DS博客作业02--线性表
0.PTA得分截图
1.本周学习总结
1.1 线性表
· 顺序表结构体
typedef int ElemType;
typedef struct
{
ElemType data[MaxSize]; //存放顺序表元素
int length ; //存放顺序表的长度
} List;
· 创建循序表
void CreateList(SqList& L, int n)//构建顺序表函数 ，n为顺序表长度
{
L = new List;
L->length = n;
for (int i = 0; i < n; i++)
{
cin >> L->data[i];
}
}
· 顺序表插入
bool Insert(List L, ElementType X, Position P)//X表示要插入的元素，P表示插入位置
{
if (L->Last + 1 == MAXSIZE)//顺序表已满
{
printf("FULL");
return false;
}
int i;
if (P<0 || P>(L->Last + 1))
{
return false;//位置非法
}
for (i = L->Last; i >= P; i--)
{
L->Data[i + 1] = L->Data[i];
}
L->Data[P] = X;
L->Last++;//最后一个位置下标++
return true;
}
· 顺序表删除
bool Delete(List L, Position P)//P表示要插入的位置
{
if (P<0 || P>(L->Last + 1))//非法访问
{
return false;
}
int i;
for (i = P; i <= L->Last-1; i++)
{
L->Data[i] = L->Data[i + 1];//从第i个元素开始，之后的元素往前移
}
L->Last--;//最后一个位置的下标--
return true;
}
· 单链表结构体定义
typedef struct LNode //定义单链表结点类型
{
ElemType data;
struct LNode *next;//指向后继结点
} LNode,*LinkList;
· 两种建立链表的方式
(1)尾插法
void CreateList(LinkList& L, int n)
{
LinkList tail, p;
L = new LNode;
tail = L;
L->next=NULL;
for (int i = 0; i < n; i++)
{
p = new LNode;
cin >> p->data;
p->next = NULL;
tail->next = p;
tail = p;
}
}
图解:
(2)头插法
void CreateListF(LinkList& L, int n)
{
LinkList pre;
L = new LNode;
L->next = NULL;
ElemType i;
for ( i = 0; i < n; i++)
{
pre = new LNode;
cin >> pre->data;
pre->next = L->next;
L->next = pre;
}
}
图解：
· 有序单链表插入删除
(1)插入数据
void ListInsert(LinkList& L, ElemType e)
{
LinkList p,pre;
p = new LNode;
p->data = e;
pre = L;
while (pre->next)
{
if (pre->next->data > e)//找到第一个比要插入数据大的数
{
p->next = pre->next;
pre->next = p;
return;
}
else pre = pre->next;
}
p->next = pre->next;//若插入数据最大则插在最后
pre->next = p;
}
(2)删除数据
void ListDelete(LinkList& L, ElemType e)
{
if (L->next == NULL)return;
LinkList p, pre;
pre = L;
while (pre->next)
{
if (pre->next->data == e)//遍历链表找到要删除目标位置
{
p = pre->next;
pre->next = p->next;
delete p; return;
}
else pre = pre->next;
}
cout <<e<< "找不到！"<<endl;//删除要考虑找不到的情况
}
· 合并两个单链表
void MergeList(LinkList& L1, LinkList L2)//合并链表，使合并后的链表非降排列
{
LinkList p = L1->next, q = L2->next, L3, r, node;
r = new LNode;
r->next = NULL;
L3 = r;
while (p && q)//同时遍历
{
if (p->data > q->data)
{
node = q;
q = q->next;//指针下移
node->next = NULL;
r->next = node;
r = node;
}
else if (p->data < q->data)
{
node = p;
p = p->next;//指针后移
node->next = NULL;
r->next = node;
r = node;
}
else
{
node = p;
q = q->next;
p = p->next;//两个指针同时后移
node->next = NULL;
r->next = node;
r = node;
}
}
if (p)r->next = p;
if (q)r->next = q;
L1 = L3;
}
· 循环链表
对于循环链表这种设计，我们在遍历的时候的结束条件就不再是p为空的时候结束了。而是！！p等于头结点！！的时候遍历才完成。
· 双向链表
1.2学习体会
顺序表还好，链表要特别小心p和p->next是否为空，还有其他的next关系，学习链表要从基础的开始，先把链表建好，熟悉头插和尾插，在掌握其他操作如插入，删除，逆序，合并等，此外还可以了解一些C++对于链表常用的库函数，如vector和algorithm里的一些和顺序表操作有关的函数。
2.PTA实验作业
2.1 题目：6-11 链表分割
2.1.1 代码截图
2.1.2 PTA提交列表及说明
2.2题目：6-8 链表倒数第m个数
2.2.1 代码截图
2.2.2 PTA提交列表及说明
2.3题目：7-1 两个有序序列的中位数、
2.3.1 代码截图
2.3.2 PTA提交列表及说明
3.阅读代码
3.1
问题：
代码如下：
法一：
#include<iostream>
#include<algorithm>
using namespace std;
int N,W;
const int maxn=105;
int v[maxn],w[maxn];
int rec(int i,int j)//从第i个下标开始，计算剩余j重量怎么挑选商品
{
int ans;
if(i==N) ans=0;//已经没有商品可以选择，递归出口。
else if(j<w[i]) ans=rec(i+1,j);//如果背包容量装不下下标为i的商品
else ans=max(rec(i+1,j),rec(i+1,j-w[i])+v[i]);/*方程由来：http://blog.sina.com.cn/s/blog_e65dd0270102wd9k.html*/
return ans;
}
int main()
{
cin>>N>>W;
for(int i=0;i<N;i++) cin>>w[i];
for(int i=0;i<N;i++) cin>>v[i];
int res=rec(0,W);
cout<<res<<endl;
return 0;
}
这种算法是对每个商品都进行处理，每一层搜索都有两个分支，时间复杂度为O(2^n)，当n比较大的时候就会花费较多的时间。
对每个商品进行搜索的时候，有时会出现相同的参数，于是第二次调用的时候我们其实已经计算过一次了，等于是白白浪费了时间。
···
法二：
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxN=3405;
const int maxW=405;
int dp[maxN][maxW];
int N,W;
int w[maxW],v[maxN];
int rec(int i,int j){
if(dp[i][j]>=0) return dp[i][j];
int ans;
if(i==N) ans=0;
else if(j<w[i]) ans=rec(i+1,j);
else ans=max(rec(i+1,j),rec(i+1,j-w[i])+v[i]);
return dp[i][j]=ans;
}
int main(){
memset(dp,-1,sizeof(dp));
cin>>N>>W;
for(int i=0;i<N;i++)
{
cin>>w[i];
cin>>v[i];
}
int res=rec(0,W);
cout<<res<<endl;
return 0;
}
dp[][]为记忆数组，用于记录下之前每一次的结果。我们如果把dp[i][j]定义成如下意义：当总重量小于j时，从下标为i的商品开始挑选，得到商品的最大值。于是有下面的递推公式：
法三：
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int maxN=3405;
const int maxW=405;
int dp[maxN][maxW];
int N,W;
int w[maxW],v[maxN];
void solve(){
for(int i=N-1;i>=0;i--){
for(int j=0;j<=W;j++){
if(j<w[i])
dp[i][j]=dp[i+1][j];
else
dp[i][j]=max(dp[i+1][j],dp[i+1][j-w[i]]+v[i]);
}
}
cout<<dp[0][W]<<endl;
}
int main()
{
cin>>N>>W;
for(int i=0;i<N;i++)
{
cin>>w[i];
cin>>v[i];
}
solve();
return 0;
}
