Acm3-栈、队列、及移位运算符

最新推荐文章于 2022-10-14 09:39:12 发布
原创 最新推荐文章于 2022-10-14 09:39:12 发布 · 435 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。

本文深入探讨了栈和队列这两种基本的数据结构，包括它们的特点、应用场景及实现方式，并介绍了C/C++中的具体实现代码。此外，还讲解了移位运算符的基本概念及其在二进制数中的应用。

微笑重点：栈、队列、及移位运算符

栈和队列

1.栈：

特点:FILO；

用处：常用与括号匹配；火车进站出站的顺序排列，发生的可能性；

<1>顺序栈：        

#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<cstdlib>
#define INI 1000
#define INC 1000
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2
using namespace std;
struct Stack
{
    int* top;
    int* base;
    int Size;
}s;
int Init(Stack& S)
{
	S.base=(int *)malloc(INI*sizeof(int));
	if(!S.base) exit(OVERFLOW);
	S.top=S.base;
	S.Size=INI; 
	return OK;
}
int Push(Stack& S,int e)
{
	if(S.top-S.base>=S.Size)
	{
		S.base=(int *)realloc(S.base,(INC+S.Size)*sizeof(int));
		if(!S.base) exit(OVERFLOW);
		S.top=S.base+S.Size;
		S.Size=S.Size+INC;
	}
	*(S.top++)=e;
	return OK;
}
int Pop(Stack& S,int& e)
{
	if(S.top==S.base)
	return ERROR;
	e=*--S.top;
	return OK; 
}
int Gettop(Stack S,int &e)
{
	if(S.top==S.base) return ERROR;
	e=*--S.top;
	return OK;
}
int display(Stack S)
{
	while(S.base<S.top)
	{
	  cout<<*(--S.top)<<" ";	
	}
	cout<<endl;
	return OK;
}
int isEmpty(Stack S)
{
	if(S.top==S.base) return TRUE;
	return ERROR;
}
int Length(Stack S)
{
	return S.top-S.base;
}
int Clear(Stack& S)
{
	if(S.base)
	S.top=S.base; 
	return OK;
}
int Destory(Stack& S)
{
     if(S.base)	
     {
     	free(S.base);
     	S.base=S.top=NULL;
	S.Size=0; 
     }
	 return OK;
} 
 int main(){
	Stack S; 
	int N,e; 
	cout<<"1.构造一个空顺序栈"<<endl; 
	cout<<"2.链栈的入栈 "<<endl; 
	cout<<"3.链栈的出栈"<<endl; 
	cout<<"4.取栈顶元素"<<endl; 
	cout<<"5.判断是否为空栈"<<endl;
	cout<<"6.栈的长度"<<endl;
	cout<<"7.清除栈"<<endl;
	cout<<"8.销毁栈"<<endl; 
	cout<<"9.打印"<<endl; 
	while(1){
		cout<<"输入操作数，输入负数结束"<<endl; 
		cin>>N;
		if(N==1)
		{
			if(Init(S)==OK)cout<<"构造空栈成功 "<<endl;	
		}
		else if(N==2)
		{
		   int cnt1=0,cnt=0;	
		   cout<<"输入入栈元素(0结束)"<<endl; 
		   while(true)
		   {
			cin>>e;
			if(e==0) break;
			cnt1++;
			if(Push(S,e)==OK)cnt++; 
		   }
		   if(cnt1==cnt) cout<<"入栈成功"<<endl; 
		}
		else if(N==3)
		{

			if(Pop(S,e)==OK) 
			cout<<"栈顶元素："<<e<<"  出栈成功"<<endl;
		}
		else if(N==4)
		{
			if(Gettop(S,e))
			cout<<"栈顶元素是"<<e<<endl;
			else
			cout<<"栈已空"<<endl;	
		}
		else if(N==5)
		{
			if(isEmpty(S))
			cout<<"栈为空"<<endl;
			else
			cout<<"栈不为空"<<endl; 
		}
		else if(N==6)
		{
			cout<<"该栈的长度是:"<<Length(S)<<endl;
		}
		else if(N==7)
		{
			if(Clear(S))
			cout<<"成功清除"<<endl;
		}
		else if(N==8)
		{
			if(Destory(S))
			cout<<"成功销毁"<<endl; 
		}
		else if(N==9)
		{
			 display(S);
		}	
		else if(N<=-1)
		{
			exit(0);
		}
		else
		{
			cout<<"请输入正确的序号"<<endl;
		}
	
		
	}	
	return 0;
}
<2>链栈
#include<iostream>
#include<cstring>
#include<string>
#include<cstdlib> 
using namespace std;
#define INI 1000
#define INC 1000
#define NULL 0
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2 
struct Stack
{
	int data;
	Stack* next;
};
int Init(Stack*& S)
{
	S=NULL;
	return OK;
}
int Push(Stack*& S,int e)
{
	Stack* p=(Stack*)malloc(sizeof(Stack));
	if(!p) exit(OVERFLOW);
	p->data=e;
	p->next=S;
	S=p;
	return OK;
}
int Pop(Stack*& S,int& e)
{
	Stack* p=(Stack*)malloc(sizeof(Stack));
	
	p=S;
	if(p==NULL) return ERROR;
	e=p->data;
	S=S->next;
	free(p);
	return OK; 
}
int Gettop(Stack* S,int &e)
{
	e=S->data; 
	return OK;
}
int display(Stack* S)
{
	while(S!=NULL)
	{
		cout<<S->data<<" ";
		S=S->next;
	}
	return OK;
}
int isEmpty(Stack* S)
{
	if(S==NULL) return TRUE;
	return ERROR;
}
int Length(Stack* S)
{
	int n=0;
	while(S!=NULL)
	{
		S=S->next;
		++n; 
	}
	return n;
}
int Clear(Stack*& S)
{
	if(S!=NULL)
	 {
	 	S=NULL;
	 }
	return OK;
}
int Destory(Stack*& S)
{
     while(S!=NULL)	
     {
     	free(S);
     	S=S->next;
      }
	 return OK;
} 
 int main(){
	Stack* S;
	int N,e; 
	cout<<"1.构造一个空顺序栈"<<endl; 
	cout<<"2.链栈的入栈 "<<endl; 
	cout<<"3.链栈的出栈"<<endl; 
	cout<<"4.取栈顶元素"<<endl; 
	cout<<"5.判断是否为空栈"<<endl;
	cout<<"6.栈的长度"<<endl;
	cout<<"7.清除栈"<<endl;
	cout<<"8.销毁栈"<<endl; 
	cout<<"9.打印"<<endl; 
	while(1){
		cout<<"输入操作数，输入负数结束"<<endl; 
		cin>>N;
		if(N==1)
		{
			if(Init(S)==OK)cout<<"构造空栈成功 "<<endl;	
		}
		else if(N==2)
		{
		   int cnt1=0,cnt=0;	
		   cout<<"输入入栈元素(0结束)"<<endl; 
		   while(true)
		   {
			cin>>e;
			if(e==0) break;
			cnt1++;
			if(Push(S,e)==OK)cnt++; 
		   }
		   if(cnt1==cnt) cout<<"入栈成功"<<endl; 
		}
		else if(N==3)
		{

			if(Pop(S,e)==OK) 
			cout<<"栈顶元素："<<e<<"  出栈成功"<<endl;
			else
			cout<<"栈已空"<<endl; 
		}
		else if(N==4)
		{
			if(Gettop(S,e))
			cout<<"栈顶元素是"<<e<<endl;
			else
			cout<<"栈已空"<<endl;	
		}
		else if(N==5)
		{
			if(isEmpty(S))
			cout<<"栈为空"<<endl;
			else
			cout<<"栈不为空"<<endl; 
		}
		else if(N==6)
		{
			cout<<"该栈的长度是:"<<Length(S)<<endl;
		}
		else if(N==7)
		{
			if(Clear(S))
			cout<<"成功清除"<<endl;
		}
		else if(N==8)
		{
			if(Destory(S))
			cout<<"成功销毁"<<endl; 
		}
		else if(N==9)
		{
			 display(S);
		}	
		else if(N<=-1)
		{
			exit(0);
		}
		else
		{
			cout<<"请输入正确的序号"<<endl;
		}
	}	
	return 0;
}


2.队列：

特点：FIFO；(表前删除，表后添加)

形式：

1).方法一:顺序队列

#include<iostream>
#include<cstring>
#include<algorithm>
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2
#define maxSize 10
using namespace std;
struct Queue
{
    int *elem;
    int rear;
    int front;
};
int Init(Queue& Q)
{
	Q.elem=(int*)malloc(maxSize*sizeof(int));
	if(!Q.elem) exit(OVERFLOW);
	Q.rear=Q.front=0;
	return OK;
}
int EnQueue(Queue& Q,int e)
{
    if((Q.rear+1)%maxSize==Q.front) 
	return ERROR;
    Q.elem[Q.rear]=e;
    Q.rear=(Q.rear+1)%maxSize;
	return OK;	
} 
int DeQueue(Queue& Q,int& e)
{
    if(Q.rear==Q.front) return ERROR;
    e=Q.elem[Q.front];
    Q.front=(Q.front+1)%maxSize;
    return OK;
} 
int isEmpty(Queue Q)
{
	cout<<"Q.rear:"<<Q.rear<<" Q.front:"<<Q.front<<endl;
	return !Q.rear-Q.front;
}
int Leng(Queue Q)
{
	int len=(maxSize+Q.rear-Q.front)%maxSize;
	return len;	
} 
int Traverse(Queue Q)
{
	if(!Q.elem||Q.front==Q.rear)
	return ERROR;
	while(Q.front!=Q.rear) 
	{
	    cout<<Q.elem[Q.front]<<" ";
	    Q.front=(Q.front+1)%maxSize;
	} 
	cout<<endl;
	return OK;
} 
int Clear(Queue& Q)
{
	if(Q.front)
	{
		Q.rear=Q.front;
	}
	return OK;
}
int Destory(Queue& Q)
{
	if(Q.elem)
	{
		free(Q.elem);
	}
	return OK;
}
int main()
{
	Queue Q;
	int e,n;
	Init(Q);
	cout<<"1.入队"<<endl;
	cout<<"2.出队"<<endl;
	cout<<"3.队长度"<<endl;
	cout<<"4.队是否为空"<<endl;
	cout<<"5.队的清除"<<endl;
	cout<<"6.队的销毁"<<endl;
	cout<<"7.队的遍历"<<endl; 
	while(true)
	{
	  cout<<"输入你的选项:"<<endl;
	  cin>>n;
	  switch(n)
	  {
	  case 1:
	  	{
	  	 int cnt=0,cnt1=0;
	  	 cout<<"输入正整数（0结束）:"<<endl; 
	  	 while(true)
	  	 {
	  	 cin>>e;
	  	 if(!e) break;
		 cnt++;	
	  	 if(EnQueue(Q,e))
	  	 cnt1++;
	     }
	     cout<<"入队成功!"<<endl;
		} break;
	  case 2:
	  	{
	  	  if(DeQueue(Q,e))
			cout<<"出队元素为:"<<e<<endl; 
		  else
		    cout<<"队为空！"<<endl; 
		}break;
	  case 3:
	  	{
	  	  cout<<"队长度为:"<<Leng(Q)<<endl;	
		} break;
	  case 4:
	  	{
	  	  if(isEmpty(Q))
			cout<<"队列为空！"<<endl;
		  else
		    cout<<"队列不为空！"<<endl;	
		} break;
	  case 5:
	  	{
	  		if(Clear(Q))
			  cout<<"队清除成功！"<<endl;
			else
			  cout<<"抱歉，没有成功！"<<endl; 
		}  break;
	  case 6:
	  	{
	  	   if(Destory(Q))	
	  	   cout<<"销毁成功！"<<endl;
		   else
		   cout<<"操作失败！"<<endl; 
		}
	  break;
	  case 7:
	  	{
	  	    if(!Traverse(Q))
			  {
			  cout<<"队列为空！"<<endl;	
			  }	
		}
	  break;
	  default:
	  break;	
	  }	
	}
}

2).方法二：链队列

#include<iostream>
#include<cstring>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
#define OK 1
#define ERROR 0
#define TRUE 1
#define OVERFLOW -2
using namespace std;
typedef struct node
{
   int data;
   struct node* next;	
}node,*link;
struct Queue
{
	node* rear;
	node* front;
};
int Init(Queue& Q)
{
	Q.rear=Q.front=(link)malloc(sizeof(node));
	if(!Q.front) exit(OVERFLOW);
	Q.front->next=NULL;
	return OK;
}
int EnQueue(Queue& Q,int e)
{
        link p=(link)malloc(sizeof(node));
	if(!p) exit(OVERFLOW);
	p->data=e;
	p->next=NULL;
	Q.rear->next=p;
	Q.rear=p;
	return OK;	
} 
int DeQueue(Queue& Q,int& e)
{
    if(Q.rear==Q.front) return ERROR;
    link p=(link)malloc(sizeof(node));
    p=Q.front->next;
    e=p->data;
    Q.front->next=p->next;
    if(p==Q.rear) Q.rear=Q.front;
    free(p);
    return OK;
} 
int isEmpty(Queue Q)
{
	return Q.rear-Q.front;
}
int Leng(Queue Q)
{
        int n=0;
	while(Q.front!=Q.rear)
	{
	  Q.front=Q.front->next;
	  ++n; 
	} 
	return n;	
} 
int Traverse(Queue Q)
{
	while(Q.front!=Q.rear) 
	{
		cout<<Q.front->next->data<<" ";
		Q.front=Q.front->next; 
	} 
	cout<<endl;
	return OK;
} 
int Clear(Queue& Q)
{
	if(Q.front)
	{
		Q.rear=Q.front;
	}
	return OK;
}
int Destory(Queue& Q)
{
	while(Q.front)
	{
		Q.rear=Q.front->next;
		free(Q.front);
		Q.front=Q.rear;
	}
	return OK;
}
int main()
{
	Queue Q;
	int e,n;
	Init(Q);
	cout<<"1.入队"<<endl;
	cout<<"2.出队"<<endl;
	cout<<"3.队长度"<<endl;
	cout<<"4.队是否为空"<<endl;
	cout<<"5.队的清除"<<endl;
	cout<<"6.队的销毁"<<endl;
	cout<<"7.队的遍历"<<endl; 
	while(true)
	{
	  cout<<"输入你的选项:"<<endl;
	  cin>>n;
	  switch(n)
	  {
	  case 1:
	  	{
	  	 int cnt=0,cnt1=0;
	  	 cout<<"输入正整数（0结束）:"<<endl; 
	  	 while(true)
	  	 {
	  	 cin>>e;
	  	 if(!e) break;
		 cnt++;	
	  	 if(EnQueue(Q,e))
	  	 cnt1++;
	     }
	     cout<<"入队成功!"<<endl;
		} break;
	  case 2:
	  	{
	  	  if(DeQueue(Q,e))
			cout<<"出队元素为:"<<e<<endl; 
		  else
		    cout<<"队为空！"<<endl; 
		}break;
	  case 3:
	  	{
	  	  cout<<"队长度为:"<<Leng(Q)<<endl;	
		} break;
	  case 4:
	  	{
	  	  if(isEmpty(Q))
			cout<<"队列为空！"<<endl;
		  else
		    cout<<"队列不为空！"<<endl;	
		} break;
	  case 5:
	  	{
	  		if(Clear(Q))
			  cout<<"队清除成功！"<<endl;
			else
			  cout<<"抱歉，没有成功！"<<endl; 
		}  break;
	  case 6:
	  	{
	  	   if(Destory(Q))	
	  	   cout<<"销毁成功！"<<endl;
		   else
		   cout<<"操作失败！"<<endl; 
		}
	  break;
	  case 7:
	  	{
	  	    if(!Traverse(Q))
			  {
			  cout<<"队列为空！"<<endl;	
			  }	
		}
	  break;
	  default:
	  break;	
	  }	
	}
}


3).方法三:STL库

#include<queue>

using namespacestd;

queue<int>Q;

入列：Q.push(入列元素);

出列：Q.pop();

栈and队列在STL使用：

1、栈

加上“stack”的头文件，常用的函数有：

stack<int>p; 

p.push（）；p.pop（）；p.top（）；p.size（）；p.empty（）；

2、队列

加上<queue>的头文件，常用的函数有：

queue<int>q;

p.push（）；p.pop（）；q.front（）；q.back（）；p.size（）；p.empty（）；

队列中有个特殊的地方，优先队列priority_queue;

priority_queue<int>q;

自定义优先级：

struct  cmp

{

   operator bool ()(int x, int y)

   {

       return　x > y; // x小的优先级高

     //也可以写成其他方式，如： return p[x] > p[y];表示p[i]小的优先级高

}

};

priority_queue<int,vector<int>, cmp>q;//定义方法

结构体的优先级定义：

structnode

{

   int x, y;

   friend bool operator < (node a, node b)

   {

       return a.x > b.x; //结构体中，x小的优先级高

   }

};

priority_queue<node>q;//定义方法

3.移位运算符

可分为两种：

1).与符号无关

形如：<<<(向左运算符)和>>>(向右运算符);

2).与符号有关

形如：<<(向左运算符)和>>(向右运算符);

a.<<向左运算符

8<<1(符号为正)：表示二进制的数向左移动1位；

      8的二进制是：00001000向左移动1位->变为00010000(想象一下动态的小链条向左移动，最后在最右边补0);

-8<<1(符号为负):我们易得-8的二进制是:10001000->向左移动1位->10010000(符号位不变，在最右边补0);

b.>>向右运算符

 8>>1(符号为正)：表示二进制的数向右移动1位；

      8的二进制是：00001000向右移动1位->变为00000100(想象一下动态的小链条向右移动，最后在最左边补0);

-8>>1(符号为负):我们易得-8的二进制是:10001000->向右移动1位->11000100(符号位不变，在最左边补1);     

ACM比赛经验、刷题记录及模板库总结（更新中）
lordofadventure的博客
03-08 2210
文章目录前言第一部分 经验分享及感受第二部分 刷题记录一、基础算法&程序语言二、综合题（现场题）三、动态规划四、图论五、字符串算法六、数据结构七、数学八、网络流九、博弈十、随机算法十一、其他第三部分 专项题库第四部分 模板库附录A 题目索引附录B 常用平台参考文献 前言 本文所提及的部分题目代码，可以在https://github.com/volactina/ACM上找到 第一部分 经验分...
【算法题】机试指南-基础篇
专注大前端
05-09 1261
STL定义了强大的、基于模板的、可复用的组件，实现了许多通用的数据结构及处理这些数据结构的算法。其中包含三个关键组件——容器（container，流行的模板数据结构）、迭代器（iterator）和算法（algorithm）。容器是用来管理某一类对象的集合。C++ 提供了各种不同类型的容器，比如 deque、list、vector、map 等。评判结果就是提交代码后系统返回的结果，这个不仅仅只是一个结果，还可以是一个debug的提示。迭代器 用于遍历对象集合的元素。这些集合可能是容器，也可能是容器的子集。
acm3
weixin_45714652的博客
03-22 311
初学动态规划 知识部分 (1) 最优化原理：如果问题的最优解所包含的子问题的解也是最优的，就称该问题具有最优子结构，即满足最优化原理。 (2) 无后效性：即某阶段状态一旦确定，就不受这个状态以后决策的影响。也就是说，某状态以后的过程不会影响以前的状态，只与当前状态有关。 初始状态→│决策１│→│决策２│→…→│决策ｎ│→结束状态 图1 动态规划决策过...
栈来实现队列，不借用第三变量交换数据，数值移位运算
指尖岁月，“码”的人生
10-06 1089
一、用两个栈来实现队列的功能       一开始我的思路是：当存取时向一个栈中进行Push操作，当取时将存入数据的栈进行Pop操作，然后放入第二个栈中，将最后一个取出，然后再放回原来的栈。      这是考官说要我改进我的思想，因为我的操作浪费时间，来回的在两个栈进行数据操作：这是你就很好想到改进，呢就是当将压栈数据放到第二个栈之后，没必要在放回去，直接取第二个栈就可以了，存还是存第一个栈内。
通过队列循环换位
qq_41947857的博客
06-05 456
function Queue() { this.dataStore = []; this.enqueue = enqueue; this.dequeue = dequeue; this.front = front; this.back = back; this.toString = toString; this.empty = empty;...
【C语言】利用队列的思维理解移位运算符和移位函数
m0_72963799的博客
10-14 6110
在c语言中，尤其是单片机的C51中，移位运算操作很常见。实现移位操作的方法有两种：一是利用移位运算符，二是利用移位函数。移位运算符，是系统内置的运算操作，编译编译不用包含相关头文件；而移位函数编译要包含intrins.h头文件。移位运算符操作，移除位后舍弃，循环移位函数移出位后不舍弃，而是从另一端补位进来。
acm入门——栈与队列
qq_43546060的博客
07-29 244
参考：关于栈与队列 例题一： 愚人节的礼物 代码： #include<iostream> #include<cstring> #include<stack> using namespace std; stack<int> s; //定义一个int类型的栈 int main() { char a[1001]; int i=0; whi...
数据结构核心方法与数论基础 PPT 框架设计（共 15 页） 第 1 页：封面 标题：数据结构核心方法与数论基础 副标题：栈、队列、线性查找监视哨及同余定理 设计：左侧主标题 + 右侧简约图标（栈 / 队列 / 放大镜 / 数学符号） 底部：主讲人 / 日期 第 2 页：目录 栈与队列：基础概念与特性 表达式求值：栈的典型应用 线性查找：监视哨方法优化 同余定理：定义、性质与应用 总结与 Q&A 模块一：栈与队列（3 页） 第 3 页：1.1 栈 ——“先进后出” 的线性结构 核心定义：仅允许在一端（栈顶）进行插入（入栈）和删除（出栈）的线性表 关键特性：LIFO（Last In First Out，后进先出） 存储结构： 顺序栈（数组实现，需注意栈满 / 栈空判断） 链栈（链表实现，无栈满限制） 操作示例（流程图）： 入栈：1→2→3（栈内：[1,2,3]，栈顶 = 3） 出栈：3→2（栈内：[1]，栈顶 = 1） 第 4 页：1.2 队列 ——“先进先出” 的线性结构 核心定义：仅允许在一端（队尾）插入、另一端（队头）删除的线性表 关键特性：FIFO（First In First Out，先进先出） 存储结构（重点解决 “假溢出”）： 循环队列（数组实现，队头 / 队尾指针循环移动，判断条件：(rear+1)% maxsize == front） 链队列（链表实现，队头指针指向头节点，队尾指针指向尾节点） 操作示例（流程图）： 入队：1→2→3（队内：[1,2,3]，队头 = 1，队尾 = 3） 出队：1→2（队内：[3]，队头 = 3，队尾 = 3） 第 5 页：1.3 栈与队列的对比与应用场景 维度 栈（Stack） 队列（Queue） 操作特性 栈顶唯一出入口 队头出、队尾入 核心逻辑 后进先出 先进先出 典型应用 表达式求值、函数调用栈、撤销操作 任务调度（如打印机队列）、消息队列、BFS 算法 模块二：表达式求值（栈的应用，2 页） 第 6 页：2.1 表达式的三种形式与转换 三种表达式类型： 中缀表达式（日常形式）：a + b * c - d（运算符在操作数中间，需考虑优先级） 后缀表达式（逆波兰式）：a b c * + d -（运算符在操作数后，无需括号） 前缀表达式（波兰式）：- + a * b c d（运算符在操作数前） 中缀转后缀核心规则（用栈暂存运算符）： 遇操作数直接输出； 遇运算符：若栈空 / 栈顶为 “(”，直接入栈；若优先级高于栈顶，入栈；否则出栈并输出，重复至满足条件； 遇 “(” 入栈，遇 “)” 出栈并输出，直至 “(”（“(” 不输出）。 第 7 页：2.2 后缀表达式求值（栈的核心应用） 求值步骤（用栈暂存操作数）： 从左到右扫描后缀表达式； 遇操作数，压入栈； 遇运算符，弹出栈顶两个操作数（先弹右操作数，后弹左操作数），计算后将结果压栈； 扫描结束，栈内唯一元素即为结果。 实例演示： 中缀表达式：3 + 4 * 2 - 5 → 后缀表达式：3 4 2 * + 5 - 求值过程： ① 3 入栈 → [3]；② 4 入栈 → [3,4]；③ 2 入栈 → [3,4,2]； ④ 遇 “”：42=8，栈变为 [3,8]；⑤ 遇 “+”：3+8=11，栈变为 [11]； ⑥ 5 入栈 → [11,5]；⑦ 遇 “-”：11-5=6，栈最终为 [6]（结果 = 6）。 模块三：线性查找之监视哨方法（3 页） 第 8 页：3.1 线性查找的基本概念 定义：从数组起始位置开始，依次将每个元素与目标值对比，直至找到或遍历结束（适用于无序 / 有序数组） 普通线性查找的问题： 每次循环需判断两个条件：“是否遍历结束（i < n）” 和 “当前元素是否等于目标值（a [i] == key）”，效率较低。 第 9 页：3.2 监视哨方法的优化逻辑 核心思想：在数组末尾（a [n]）放置 “监视哨”（即目标值 key），避免循环中 “i < n” 的判断（遍历到监视哨时必终止），减少比较次数。 算法步骤（以数组 a [0..n-1] 为例，n 为元素个数）： 令 a [n] = key（设置监视哨）； 初始化 i = 0； 循环：若 a [i] != key，则 i++（无需判断 i 是否越界，因 a [n]=key 必终止）； 结果：若 i < n，说明找到（索引为 i）；若 i = n，说明未找到。 第 10 页：3.3 代码示例与优势 普通线性查找 vs 监视哨方法（伪代码）： 普通线性查找 监视哨方法 i = 0 a[n] = key; i = 0 while i < n and a[i] != key while a[i] != key i++ i++ if i < n: 找到 if i < n: 找到 优势：减少 50% 的循环判断次数（尤其适用于 n 较大的数组），代码更简洁。 适用场景：静态数组（可修改末尾元素）、查找频率高的场景。 模块四：同余定理（3 页） 第 11 页：4.1 同余定理的定义 核心定义：若两个整数 a、b 除以正整数 m 的余数相等，则称 a 与 b 对模 m 同余，记为：a ≡ b (mod m) 例：7 ÷ 3 余 1，10 ÷ 3 余 1 → 7 ≡ 10 (mod 3) 等价条件：a - b 能被 m 整除（即 m | (a - b)） 第 12 页：4.2 同余定理的基本性质 传递性：若 a≡b (mod m) 且 b≡c (mod m)，则 a≡c (mod m) 可加性：若 a≡b (mod m) 且 c≡d (mod m)，则 a+c≡b+d (mod m) 可乘性：若 a≡b (mod m) 且 c≡d (mod m)，则 a×c≡b×d (mod m) 示例验证： 已知 3≡8 (mod 5)，2≡7 (mod 5) 可加性：3+2=5，8+7=15 → 5≡15 (mod 5)（均余 0） 可乘性：3×2=6，8×7=56 → 6≡56 (mod 5)（均余 1） 第 13 页：4.3 同余定理的实际应用 密码学：凯撒密码（字母移位加密，如 A→D，即 a→a+3 mod 26） 日期计算：判断某天是星期几（例：已知 2024.1.1 是周一，计算 2024.1.10：(1 + 10-1) mod 7 = 3 → 周三） 哈希表设计：哈希函数（如 key mod 表长，将关键字映射到哈希地址，减少冲突） 第 14 页：总结 栈与队列：栈（LIFO）用于 “回溯” 场景，队列（FIFO）用于 “排队” 场景； 表达式求值：栈是核心工具，通过 “中缀转后缀 + 后缀求值” 解决优先级问题； 监视哨方法：线性查找的优化，用末尾哨兵减少循环判断； 同余定理：数论基础，支撑密码、日期、哈希等实际场景。 第 15 页：Q&A 标题：提问与交流 设计：中间 “Q&A” 大字 + 底部 “感谢聆听”将上述做成ppt
最新发布
10-22
- **原理**：扫描中缀表达式，遇到运算符或界限符时，按照特定逻辑压入运算符栈，并进行相应运算。 - **步骤**：详细解释中缀转后缀的步骤和栈的操作过程。 ### 幻灯片13：栈的应用 - 代码实现 ```python # 中缀转...
《STL》— STL 知识点总结
69小石头的博客
08-04 1947
C++:STL标准入门汇总 http://www.cnblogs.com/shiyangxt/archive/2008/09/11/1289493.html stl 在 acm中的应用总结 http://www.cnblogs.com/shanyr/p/5745807.html C++输入与输出—cout和cin的用法 http://blog.youkuaiyun.com/zhanghaotian2011/a...
开源算法合集：涵盖递归、动态规划与图算法
诸如“change-bit-status.cpp”可能涉及设置、清除、翻转特定位的操作，使用按位或（|）、与（&）、异或（^）和移位运算符（, >>）。这些技术常用于状态压缩、集合表示（用整数二进制位代表元素存在性）、快速幂、...
ACM训练总结（栈与队列）
weixin_45664948的博客
04-05 251
又过了一个星期，距离回学校又近了一步。 这周学习了两种数据结构，栈和队列。 栈是一种只能在一端插入或者删除的线性表。 1．进栈（PUSH）算法 ①若TOP≥n时，则给出溢出信息，作出错处理（进栈前首先检查栈是否已满，满则溢出；不满则作②）； ②置TOP=TOP+1（栈指针加1，指向进栈地址）； ③S(TOP)=X，结束（X为新进栈的元素）； 2．退栈（POP）算法 ①若TOP≤0...
位运算
weixin_30823683的博客
01-29 229
运算方法有六种： & 与运算 | 或运算 ^ 异或运算 ~ 非运算(求补) >> 右移运算 << 左移运算 运用这些基本的运算，我们可以解决acm所需的各种运算,给Bit赋1，赋0，给他的值取反，还有好多段操作。如下： 功能 | 示例 | 位运算----------------------+---------------------------+...
循环队列，可变长队列（缓冲）及优化
wedy542700927的专栏
08-17 4454
写在前面写这篇博客的灵感来自于自己在项目上用到的循环队列，顺便讲讲libevent中evbuffer和muduo（木铎）中buffer。循环队列循环队列是很常见的数据结构，在大学计算机课程上也会遇到，被应用到很多场景，比如管道的实现（固定的容量64K）、MapReduce中数据溢写入磁盘（默认100M，超过80M溢写）、网络库中常见的IO buffer等等。 循环队列需要两个索引head和tail
[字符串] 一个巧妙的字符串循环移位法
童凌的技术博客
07-16 5750
给定一个长度为m的串，将其循环移位，向右移动n位，输出循环移位后的字符串： 例: m=7,n=3; 移动前：”1234567” 移动后：”5671234”一个巧妙的办法： 将给定的串分割成两个串，长度分别为m-n和n，分别将其翻转，翻转后将其连接成一个串，再次翻转，就得到了最终移动后的串！“1234567” “1234”,”567” “4321”,”765” “4321765” “
顺序表应用3：元素位置互换之移位算法
xxxchic
10-02 1449
顺序表应用3：元素位置互换之移位算法 Time Limit: 1000MS Memory limit: 570K 题目描述 一个长度为len(1数据元素的类型为整型，将该表分成两半，前一半有m个元素，后一半有len-m个元素（1 注意：先将顺序表元素调整为符合要求的内容后，再做输出，输出过程只能用一个循环语句实现，不能分成两个部分。 输入  第一
数组循环移位算法
我的梦
12-12 7226
题记：不要多想，好好敲代码，看书，就这样，加油。 昨天在看博客的时候，发现一个有意思的算法，但是原博客代码不全，自己就在它的基础上，按自己的理解把循环左移、循环右移的算法写出来了 优点是动态建立数字，较好 原博客：http://blog.youkuaiyun.com/ns_code/article/details/8846643 该种算法可能对循环队列缓冲移位有一定的帮助，特和大家分享： 循环左移算
python的移位操作
python学习者的博客
09-30 3188
因为要将js的一个签名算法移植到python上，遇到一些麻烦。 int无限宽度，不会溢出 算法中需要用到了32位int的溢出来参与运算，但是python的int是不会溢出的，达到界限后会自己转为long，所以很麻烦。 #使用-342686650: ret = 123456789 << 20 print(ret) 得到结果129453825982464 print(bin(ret)) 这个二进制是11101011011110011010001010100000000000000000000 明显已
数据结构与算法（六）—— 队列及其实现和应用
小羽毛的博客
12-30 2866
注：本篇内容参考了《Java常用算法手册》、《大话数据结构》和《Java编程（第四版）》三本书籍，并参考了在线工具网站中对于队列相关Java类的一些说明。 文中涉及的java以Java 1.8为准。 本人水平有限，文中如有错误或其它不妥之处，欢迎大家指正！ 目录 1. 队列 1.1 队列定义 1.2队列的特点 1.3队列的分类 1.4. 队列的操作 1.4.1 入队列 ...
ACM竞赛必备：栈队列算法与数据结构解析
"本文主要介绍了在ACM竞赛中常用的算法和数据结构，特别是栈和队列，以及如何构建一支强大的竞赛队伍。同时提到了一些重要的参考书籍和常见题型，并简单介绍了枚举法。" 在ACM竞赛中，数据结构和算法是至关重要的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值