数据结构相关

链表插入元素

#include <stdio.h>
#include<stdlib.h>
typedef  struct  Link{
  int elem;
  struct Link* next;
}link;

link *sLink();

link*inter(int* p,int  elem,int add);

 void  put(link *p);

 int main(){
   printf("开始：\n");
   link* p=sLink();
   put(p);
   printf("插入后：\n");
   p=inter(p,5,4);
   put(p);
    return 0;
 }

 link*  sLink(){
     link*p=(link*)malloc(sizeof(link));
     link*temp=p;
      for(int i=1;i<5;i++){
        link*a=(link*)malloc(sizeof(link));
        a->elem=i;
        a->next=NULL;
        temp->next=a;
        temp=temp->next;
      }
      return p;
 }

 link*inter(int*p,int elem,int add){
     link*temp=p;
     for(int i=1;i<add;i++){
        if(temp==NULL){
            printf("输入错误");
            return p;
        }
        temp=temp->next;
     }
     link*b=(link*)malloc(sizeof(link));
     b->elem=elem;
     b->next=temp->next;
     temp->next=b;
     return p;
 }

 void  put(link*p){
 link*temp=p;
 while(temp->next){
        temp=temp->next;
    printf("%d",temp->elem);

 }
 printf("\n");
 }


 


       
  
栈和队列基本操作

入栈
int push(SqStack *S, Elem *e){
    if(S->top==MAXSIZE-1){   
        printf("栈满，无法入栈\n");
        return 0;   
    }else{    
        S->top++;   
        S->data[S->top]=e;   
        return 1;
    }
}

出栈
int pop(SqStack *S, Elem *e){
    if(S->top==-1){   
        printf("栈空，无法出栈\n");
        return 0;
    }else{   
        *e = S->data[S->top];  
        S->top--;   
        return 1;
    }
}

入队
int InsertQueue(SqQueue *q, Elem e) {
    if ((q->rear + 1) % MAXSIZE == q->front)
    {
        return 0;
    }
    q->base[q->rear] = e;
    q->rear = (q->rear + 1) % MAXSIZE;
    return 1;
}
 出队
int DeleteQueue(SqQueue *q, Elem *e) {
    if (q->front == q->rear)
    {
        return 0;
    }
    *e = q->base[q->front];
    q->front = (q->front + 1) % MAXSIZE;
    return 1;
}
用链表进行多项式加法

void  add(term*f1,term*f2){
   b=f1;
   p=f1->next;
   q=f2->next;
   while(f2->next!=NULL){
          p=f1->next;
          int flag=0;
          while(f1->next!=NULL){
              if(f1->next==f2->next){
                flag=1;
                s=p;
              }
              p=p->next;
          }
          if(flag==1){
            s->coef+=f2->next->coef;//相加
          }
          else{
            a=(term*)malloc(length);
            a->coef=f2->next->coef;
            a->expn=f2->next->expn;
            a->next=b->next;//插入
            b->next=a;
          }
          q=q->next;
   }
}
括号匹配

int push(st * s,char  x){
  if(s->top==MAXSIZE-1)
    return 0;
  s->data[s->top++]=x;
  return 1;

}
int pop(st*s,char *x){
    if(s->top==0)
        return 0;
   *x=s->data[s->top];
   return 1;
}
int get(st*  s,char  x){
   while(s->top!=0){
      pop(s,&x);
      if(x=='['||x=='('||x=='{')
          return 1;
   }
   return 0;
}
int match(char  a,char b){
   if((a=='('&&b==')')||(a=='['&&b==']')||(a=='{'&&b=='}'))
    return 1;
   else
    return 0;
int  isempty(st* s){
   if(s->top==0)
    return 1;
   else
    return 0;
}
int  ismatch(st* s){
    char  str[100];
    int i;
    scanf("%s",str);
    char  a,ch;
    for(i=0;str[i]!=0;i++){
        switch(str[i]){
         case '(':  case '{':  case '[':
            push(s,str[i]);
            break;
         case ')':  case '}': case ']':
            if(isempty(s)!=0)
            {
                printf("匹配失败");
                return 0;
            }
            get(s,ch);
            if(match(s,str[i])){
                pop(s,&a);
            }

        }
    }
    if(isempty==1){
        printf("匹配成功\n");
        return 1;
    }
    else{
            printf("匹配失败\n");
    return 0;
   }
}

删除链表中指定元素

迭代
也可以用迭代的方法删除链表中所有节点值等于特定值的节点。

用 temp 表示当前节点。如果 temp 的下一个节点不为空且下一个节点的节点值等于给定的 val，则需要删除下一个节点。删除下一个节点可以通过以下做法实现：

temp.next=temp.next.next

如果 temp 的下一个节点的节点值不等于给定的 val，则保留下一个节点，将 temp 移动到下一个节点即可。

当 temp 的下一个节点为空时，链表遍历结束，此时所有节点值等于 val 的节点都被删除。

具体实现方面，由于链表的头节点 head 有可能需要被删除，因此创建哑节点 dummyHead，令 dummyHead->next=head，然后遍历链表进行删除操作。最终返回 dummyHead.next 即为删除操作后的头节点。

用快慢指针测试链表中是否有环

bool hasCycle(struct ListNode *head) {

  if(head==NULL||head->next==NULL)

      return false;

      struct ListNode*slow=head;

      struct ListNode*fast=head->next;

      while(slow!=fast){

          if(fast==NULL||fast->next==NULL){

              return false;

          }

          slow=slow->next;

          fast=fast->next->next;

      } 

     return true;

}