数据结构与算法学习|REVIEW &1

数据结构与算法学习|REVIEW &1

---

Day 1

Part 1 Learned

数据结构——（以下仅为联想框架）
1.顺序表与链表（逻辑结构/物理结构）
2.栈 stack
3.队列 queue
4.标准库STL（1）—神仙库
stack queue vector list
set map

Part 2 Check

1-1 (https://onlinejudge.u-aizu.ac.jp/problems/ALDS1_1_D)

Maximum Profit

Attention：
（1）先判断最小的在哪里
（2）再在后面找最大的

#include<iostream> 
#include<limits.h> 
#include<time.h>

using namespace std;
const int N=2e5; //2*10的5次方 
int p[N];     //定义数组 

int main(){
	
   int n;
   cin>>n;
   	for(int i=0;i<n;i++){
   	  	 cin>>p[i];
		 }              //输入           
   int minval=p[0];     //第一个作最小 
   int maxval=INT_MIN;   //整型最小，在time.h头文件里面 
   
   	for(int i=1;i<n;i++){
   	   maxval=max(maxval,p[i]-minval);  //max和min直接在iostream里面 
   	   minval=min(minval,p[i]);       //遍历每一取最小 
	}
	cout<<maxval<<endl;
  return 0;
} 

1-2 (https://onlinejudge.u-aizu.ac.jp/courses/lesson/1/ALDS1/3/ALDS1_3_C)

Doubly Linked List

Attention：
（1）typedef的用法区分（代码区）
（2）环形链表的结构体写法风格——过程要理解

#include<iostream> 
#include<cstdio>
#include<cstring>
#include<cstdlib>
//环形链表？ 
using namespace std;
struct Node{     //如果想用typedef? 
	int key;
	Node *prev;
	Node *next; 
};              //结构体创建一个节点包含双向指针和数据 
Node *head;
//（前面加typedef）后面是Node,*LinkList=>直接 Node *LinkList;区别 
// typedef struct{} Node;
// typedef struct{} *LinkList;
// Node *p <=> LinkList p    
//定义别的变量的属性与变量的区别
 

// typedef int *point_int;
// point_int p; <=> int *p;
Node *listSearch(int key){   //节点遍历 
	Node *cur=head->next;
	//LinkList cur ;
	while(cur!=head&&cur->key!=key){ //判断不是回到头了？然后值又不符合标准 
		cur= cur->next;
	}
	return cur;
}

void init(){       //初始化节点 
	head=new Node;    //类比动态数组？但是还是有点不太清楚 
	head->prev=head;   //都指向头 
	head->next=head;    
}
void printlist(){               //打印链表 
	Node *cur =head->next;
	int isf=0;
	while(1){
		if(cur==head)break;
		if(isf++ >0)printf(" ");  //控制空格输出 
		printf("%d",cur->key);
		cur=cur->next;   //node的指针cur 
	}
	printf("\n");
}
void insert(int key){         //插入一个具体的数 
	Node *x=new Node;
	x->key=key;
	x->next=head->next;
	head->next->prev=x;    //把原来节点的路径复制到x; 
	head->next=x; 
	x->prev=head;          //更改别人的路径 
}
void deleteNode(Node *t){     //删除节点 
	if(t==head)return;
	t->prev->next=t->next;
	t->next->prev=t->prev;  
    free(t);       //释放节点空间 
}
void deleteFirst(){            //删除第一个节点 
	deleteNode(head->next);
}
void deleteLast(){            //删除最后一个节点 
	deleteNode(head->prev);
}
void deletekey(int key){
	deleteNode(listSearch(key));
}
int main(){
	int key,n,i;
	char com[20];   //指令对应 
	scanf("%d",&n);
	init();
	for(i=0;i<n;i++){
		scanf("%s%d",com,&key);
		if(com[0]=='i'){insert(key);}
		else if(com[0]=='d'){
			if(strlen(com)>6){
				if(com[6]=='F')deleteFirst();
				else if(com[6]=='L')deleteLast();
			}
		else{
			deletekey(key);
		}
		}
	}
	printlist();
	return 0;
}

1-3 (https://onlinejudge.u-aizu.ac.jp/courses/lesson/1/ALDS1/3/ALDS1_3_A)

逆波兰数-stack

Attention：
（1）stack的STL函数库的调用
（2）注意多位数字，char不太行得通，走string，但是也要注意string转换int型。-> "sstream"函数

#include<iostream>
#include<stack>
#include<sstream>
using namespace std;
bool isDegital(string str) {
    for (int i = 0;i < str.size();i++) {
        if (str.at(i) == '-' && str.size() > 1)  // 有可能出现负数
            continue;
        if (str.at(i) > '9' || str.at(i) < '0')
            return false;
    }                   //判断一个string是否为数字的模块函数 
    return true;
}
int main(){
	stack<int> s;
	string c;
	int a,b;
	int p;
	while(cin>>c){	
	//c =getchar();
	if(isDegital(c)){  //为数字 
		stringstream ss;
		ss<<c;
		int temp;
		ss>>temp;      //输入输出流转化 
		s.push(temp);   //法二 int result = atoi（c.c_c()); 
	}
	if(c=="+"){
	  a=s.top();
	  s.pop();
	  b=s.top();
	  s.pop();
	  p=a+b;
	  s.push(p);	  
	}
	if(c=="-"){
	  a=s.top();
	  s.pop();   //删除栈顶 
	  b=s.top();  
	  s.pop();
	  p=b-a;
	  s.push(p);
	}
	if(c=="*"){
	  a=s.top();
	  s.pop();   //删除栈顶 
	  b=s.top();
	  s.pop();
	  p=b*a;
	  s.push(p);
	}
	if(cin.get()=='\n') break; 
	}
	cout<<s.top()<<endl;
	return 0;
}

1-4(https://onlinejudge.u-aizu.ac.jp/courses/lesson/1/ALDS1/3/ALDS1_3_B)

单处理机，时间片轮转法——queue

（感觉有点意思的一道题）

Attention：
（1）单片机的处理过程。
（2）队列FIFO，指针的指向过程，注意最后带序号输出。

时间轮转法理解part：

//单处理机，时间片轮转法 
#include<iostream>
using namespace std;
struct Point{      //任务结构点 
	string name;  //用stl的时候带name没想出来 
	int time;
};
const int maxn=100000+10; //队伍的上界 
Point a[maxn];
int head;   //头指针 
int tail;   //尾指针 

void enqueue(Point x){   //进队列 
	a[tail]=x;
	tail=(tail+1)%maxn;
}
Point dequeue(){     //出队列 （返回是point）
	Point x=a[head];
	head=(head+1)%maxn;
	return x;
}
int main(){
	//freopen("in.txt","r",stdin); //重定向 
	int N,T;   //输入 
	cin>>N>>T;
	for(int i=0;i<N;i++){
		cin>>a[i].name>>a[i].time;
	}
	//计算与输出 
	head=0;  //头指针指向第一个元素 
	tail=N;    //尾指针指向最后一个元素+1的位置 
	Point temp;   //临时变量，工作台上 
	int c;     //工作台工作时间 
	int sum=0;
	while(head!=tail){
		temp=dequeue();   //取队头元素 
		c=min(T,temp.time); //根据时间片预测，要么是时间片时间，要么是任务时间 
		temp.time-=c;
		sum+=c;            //计算总时间 
		if(temp.time>0){      //任务尚未结束，则继续插入队列 
			enqueue(temp);
		}
		else
		{ cout<<temp.name<<" "<<sum<<endl;   //先做完先打印 
		}
	}
	return 0;
} 

Part 3 else

1.struct的基本结构

struct （名字）{
  变量类型  变量名；
  ...
}

2.typedef的用法辨析

struct Node{     //如果想用typedef? 
	int key;
	Node *prev;
	Node *next; 
};              //结构体创建一个节点包含双向指针和数据 
Node *head;
//（前面加typedef）后面是Node,*LinkList=>直接 Node *LinkList;区别 
// typedef struct{} Node;
// typedef struct{} *LinkList;
// Node *p <=> LinkList p    
//定义别的变量的属性与变量的区别
 

// typedef int *point_int;
// point_int p; <=> int *p;

3.书籍参考《大话数据结构》

4.算法的时间复杂度

我们主要关心的是最坏的情况，因此，在多层嵌套中，要以最内层的语句作为判断的指标。
eg.两层for的嵌套影响