头像

三行四列行列式

暴力出奇迹




离线:1天前


最近来访(120)
用户头像
A越努力越幸运
用户头像
骏杰
用户头像
星烨下de少年
用户头像
Yaoking
用户头像
天元之弈
用户头像
子美
用户头像
F_H_
用户头像
一万小时定律
用户头像
瞳星结
用户头像
人生如戏ba
用户头像
drrrrr
用户头像
Cold_heartless
用户头像
垫底抽風
用户头像
这个人很懒
用户头像
yxc
用户头像
我不吃
用户头像
Fatin
用户头像
hbin_frooog
用户头像
xYang_a0a1
用户头像
唐锵锵


题目描述

栈内只存放左括号,每次有右括号出现,就出栈来判断

  1. 三种情况结束匹配:
    1.括号左右不匹配
    2.右括号想匹配,但是栈空
    3.扫描完字符串,栈内还有左括号
    王道写法

样例

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

#define MaxSize 100000
typedef struct {
    int top;
    char data[MaxSize];
}SqStack;

void InitStack(SqStack &s){
    s.top=-1;
}

bool EmptyStack(SqStack s){
    if(s.top== -1 ) return true;
    else return false;

}

bool Push(SqStack &s,char &e){
    if(s.top == MaxSize - 1) return false;
    s.data[++s.top]=e;
    return true;

}

bool Pop(SqStack &s,char &e){
    if(EmptyStack(s)) return false;
    e=s.data[s.top--];
    return true;

}

bool Match(string s){
    SqStack stk;
    InitStack(stk);
    for(int i=0;i<s.size();i++){
       if(s[i]=='<'||s[i]=='{'||s[i]=='('||s[i]=='['){
           Push(stk,s[i]);
       } else{
           //栈空直接结束
           if(EmptyStack(stk)) return false;
          char topElem;
          Pop(stk,topElem);
          if(s[i]=='>'&&topElem!='<') return false;
          if(s[i]=='}'&&topElem!='{') return false;
          if(s[i]==')'&&topElem!='(') return false;
          if(s[i]==']'&&topElem!='[') return false;

       }

    }
        return EmptyStack(stk);
}

int main(){
    string s;
    cin>>s;
    if(Match(s)) {
        cout<<"yes";
        return 0;
    }
    cout<<"no";
    return 0;
}










题目描述

栈内只存放左括号,每次有右括号出现,就出栈来判断

  1. 三种情况结束匹配:
    1.括号左右不匹配
    2.右括号想匹配,但是栈空
    3.扫描完字符串,栈内还有左括号
    王道写法

样例

#include <iostream>
#include <cstring>
#include <algorithm>

using namespace std;

#define MaxSize 100000
typedef struct {
    int top;
    char data[MaxSize];
}SqStack;

void InitStack(SqStack &s){
    s.top=-1;
}

bool EmptyStack(SqStack s){
    if(s.top== -1 ) return true;
    else return false;

}

bool Push(SqStack &s,char &e){
    if(s.top == MaxSize - 1) return false;
    s.data[++s.top]=e;
    return true;

}

bool Pop(SqStack &s,char &e){
    if(EmptyStack(s)) return false;
    e=s.data[s.top--];
    return true;

}

bool Match(string s){
    SqStack stk;
    InitStack(stk);
    for(int i=0;i<s.size();i++){
       if(s[i]=='<'||s[i]=='{'||s[i]=='('||s[i]=='['){
           Push(stk,s[i]);
       } else{
           //栈空直接结束
           if(EmptyStack(stk)) return false;
          char topElem;
          Pop(stk,topElem);
          if(s[i]=='>'&&topElem!='<') return false;
          if(s[i]=='}'&&topElem!='{') return false;
          if(s[i]==')'&&topElem!='(') return false;
          if(s[i]==']'&&topElem!='[') return false;

       }

    }
        return EmptyStack(stk);
}

int main(){
    string s;
    cin>>s;
    if(Match(s)) {
        cout<<"yes";
        return 0;
    }
    cout<<"no";
    return 0;
}










#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

#define MaxSize 100

typedef struct LinkNode{
    int data;
    struct LinkNode *next;
}LinkNode;

typedef struct{
    LinkNode *front,*rear;

}LinkQueue;

//初始化链队列
void InitQueue(LinkQueue &q){
    q.front=q.rear=(LinkNode *)malloc(sizeof(LinkNode));
    q.front->next=NULL;

}


bool QueueEmpty(LinkQueue q){
    if(q.rear==q.front) return true;
    else return false;
}

//进链队列,只操作rear
bool EnQueue(LinkQueue &q,int e){
    LinkNode *s=(LinkNode *)malloc(sizeof(LinkNode));
    s->data=e;
    s->next=q.rear->next;
    q.rear->next=s;
    q.rear=s;
    return true;
}

//出链队列,front指针保持不动、且如果只有一个节点,就前移rear
bool DeQueue(LinkQueue &q,int &e){
      if(QueueEmpty(q)) return false;
      LinkNode *p=q.front->next;
      q.front->next=p->next;    
      //只有一个节点,让队列空(q.rear=q.front)
      if(q.rear==p) q.rear=q.front;
      free(p);
      return true;
}

void Print(LinkQueue q){
    LinkNode *p=q.front->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    cout<<endl;

}


int main(){
    LinkQueue q;
    InitQueue(q);

    int x;
    cin>>x;
    while(x!=999){
        EnQueue(q,x);
        cin>>x;
    }

    DeQueue(q,x);

    Print(q);
    return 0;
}



循环队列的三要素

  • 1.判断队空:q.front==q.rear
    2.判断队满:(q.rear+1)%MaxSize==q.front
    3.判断队列的元素个数: (q.rear+Maxsize-q.front)%MaxSize
#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

#define MaxSize 100

typedef struct {
    int front,rear; //头指针,尾指针
    int data[MaxSize];

}SqQueue;

//循环队列的初始化,让头指针和尾指针都指向0
void InitSqQueue(SqQueue &q){
    q.front=q.rear=0;

}

//判断队空
bool EmptySqQueue(SqQueue &q){
    if(q.front == q.rear) return true;
    else return false;

}

//判断队满
bool FullSqQueue(SqQueue &q){
    if((q.rear+1)%MaxSize==q.front) return true;
    else return false;

}

//进队
bool EnQueue(SqQueue &q,int e){
    if(FullSqQueue(q)) return false;
    q.data[q.rear]=e;
    q.rear=(q.rear+1)%MaxSize;
    return true;

}

//出队
bool DeQueue(SqQueue &q,int &e){
    if(EmptySqQueue(q)) return false;
    e=q.data[q.front];
    q.front=(q.front+1)%MaxSize;
    return true;


}

void Print(SqQueue q){
    for(int i=q.front;i<q.rear;i++)
    cout<<q.data[i]<<" ";
    cout<<endl;

}

int main(){
    SqQueue q;
    InitSqQueue(q);
    int x;
    cin>>x;
    while(x!=999){
        EnQueue(q,x);
        cin>>x;
    }
   // Print(q);

    DeQueue(q,x);
    Print(q);

    return 0;

}



#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

#define MaxSize 100
//链栈,linkStack
typedef struct linkStack{
    int data;
    struct linkStack *next;
}*LiStack,LinkNode;

//初始化链栈
bool InitLiStack(LiStack &s){
    s=(LinkNode *)malloc(sizeof(LinkNode));
    if(s==NULL) return false;
    s->next=NULL;
    return true;
}

//判断链栈空
bool EmptyLiStack(LiStack s){
    if(s->next==NULL) return true;
    else return false;
}

//进栈:相当于头插法
bool Push(LiStack &s,int e){
    LinkNode *p=(LinkNode *)malloc(sizeof(LinkNode));
    if(p == NULL ) return false;
    p->data=e;
    p->next=s->next;
    s->next=p;
    return true;
}

//出栈:在头结点后出栈
bool Pop(LiStack &s,int &e){
    LinkNode *p=s->next;
    if(EmptyLiStack(s)) return false;
    e=p->data;
    s->next=p->next;
    free(p);
    return true;
}

//销毁链栈
bool DestoryLiStack(LiStack &s){
    while(!EmptyLiStack(s)){
        int x;
        Pop(s,x);
    }
    return true;

}

//打印链栈
void Print(LiStack &s){
    LinkNode *p=s->next;
    while(p){
        cout<<p->data<<" ";
        p=p->next;
    }
    puts(" ");

}


int main(){
    LiStack s;
    InitLiStack(s);
    int x;
    cin>>x;
    //进栈
    while(x!=999){
        Push(s,x);
        cin>>x;
    }
     //Print(s);


    //出栈
   //Pop(s,x);
    //Print(s);

    //销毁链栈
    DestoryLiStack(s);
    if(EmptyLiStack(s)) cout<<"栈空"<<endl;

    return 0;
}



#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

#define MaxSize 100
//顺序栈
typedef struct {
    int data[MaxSize];
    int top; //栈顶指针
}SqStack;

//初始化顺序栈
void InitStack(SqStack &s){
    s.top=-1;
}

//判断栈空
bool StackEmpty(SqStack s){
    if(s.top==-1) return true;
    else return false;
}

//进栈
bool Push(SqStack &s,int e){
    if(s.top==MaxSize-1) return false;
    s.data[++s.top]=e;
    return true;
}

//出栈
bool Pop(SqStack &s,int &e){
    if(s.top==-1) return false;
    e=s.data[--s.top];
    return true;
}

//取得栈顶元素
bool GetTop(SqStack s,int &e){
    if(s.top == -1) return false;
    e=s.data[s.top]; 
    return true;
}

void Print(SqStack s){
    for(int j=s.top;j>=0;j--)
    cout<<s.data[j]<<" ";
    puts(" ");

}
int main(){
    SqStack s;
    InitStack(s);
    //进栈
    int x;
    cin>>x;
    while(x!=999){
        Push(s,x);
        cin>>x;
    }
    Print(s);

    //出栈
    int e;
    Pop(s,e);
   Print(s);



    return 0;
}




单链表

#include<iostream>
#include<algorithm>
#include<cstring>

using namespace std;

//单链表 
typedef struct LNode{
    int data;
    struct LNode *next;

}LNode,*LinkList;

//按位查找
LNode * GetElem(LinkList L,int i){
    if(i<0) return NULL;
    LNode *p=L;
    int j=0;
    while(p!=NULL&&j<i){
        p=p->next;
        j++;
    }
    if(p==NULL) return NULL;
    return p;
}

//按值查找
LNode *LocatetElem(LinkList L,int e){
    LNode *p=L;
    int j=0;
    while(p!=NULL&&p->data!=e){
        p=p->next;
        return p;
    }

}
//统计长度
int Length(LinkList L){
    LNode *p=L;
    int j=0;
    while(p->next){
        p=p->next;
        j++;
    }
    return j;
}

//在p后面插入e
bool InsertNextNode(LNode *p,int e){
    if(p==NULL) return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return true;
}

//在第i位插入e
bool ListInsert(LinkList &L,int i,int e){
    if(i<1) return false;
    LNode *p=L;
    int j=0;
    while(p!=NULL&&j<i-1){
        p=p->next;
        j++;
    }
    if(!p) return false;
    InsertNextNode(p,e);
    return true;
}

//在p前插入e
bool InsertPriorNode(LNode *p,int e){
    if(!p) return false;
    LNode *s=(LNode *)malloc(sizeof(LNode));
    s->data=p->data;
    s->next=p->next;
    p->next=s;
    p->data=e;
    return true;

}

//在p前插入s
bool InsertPriorNode(LNode *p,LNode *s){
    if(!p||!s) return false;
    s->next=p->next;
    p->next=s;
    swap(s->data,p->data);
    return true;
}

//删除第i位的节点
bool ListDelete(LinkList &L,int i,int &e){
    if(i<1) return false;
    LNode *p=GetElem(L,i-1);
    //如果没找到第i-1位或者要删除的第i位是空
    if(!p||!p->next) return false;
    LNode *q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return false;

}

//删除指定节点
bool DeleteNode(LNode *p){
  if(!p) return false;
  LNode *q=p->next;
  p->data=q->data;
  p->next=q->next;
  free(q);
  return true;

}

//初始化链表
bool InitList(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));
    if(!L) return false;
    L->next=NULL;
    return false;

}

//头插法
LinkList List_HeadInsert(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));
    L->next=NULL;
    LNode *s;
    int x;  
    cin>>x;
    while(x!=999)
    {
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=L->next;
        L->next=s;
        cin>>x;
    }
    return L;
}

//尾插法
LinkList List_TailInsert(LinkList &L){
    L=(LNode *)malloc(sizeof(LNode));
    L->next=NULL;
    LNode *s,*r=L;
    int x;
    cin>>x;
    while(x!=999){
        s=(LNode *)malloc(sizeof(LNode));
        s->data=x;
        s->next=r->next;
        r->next=s;
        r=s;
        cin>>x;
    }
    r->next=NULL;
    return L;

}

//打印链表
void print(LinkList L){
    LNode *s=L->next;
    while(s!=NULL){
        cout<<s->data<<" ";
        s=s->next;
    }
    puts(" ");
}

int main()
{
    int e;
    LinkList L;
    // 头插法建立单链表
    // List_HeadInsert(L);
    // print(L);

    //尾插法建立单链表
    List_TailInsert(L);
    print(L);

    //获得第2个元素
    cout<<GetElem(L,2)->data<<endl;

    //按值查找
    cout<<LocatetElem(L,3)->data<<endl;

    //查看长度
    cout<<Length(L)<<endl;

    //在第2位后插入5
    InsertNextNode(GetElem(L,1),5);
    print(L);

    //在第2位插入44
   ListInsert(L,2,44);
   print(L);

   //在第2位前插入711
   InsertPriorNode(GetElem(L,2),711);
   print(L);


   //删除第1位的节点
    ListDelete(L,1,e);
    print(L);

   //删除第2位的节点
   DeleteNode(GetElem(L,2));
   print(L);




    return 0;
}