数据结构和算法题目集

6-2顺序表操作集

List结构定义

typedef int Position;
typedef struct LNode *List;
struct LNode {
    ElementType Data[MAXSIZE];
    Position Last; /* 保存线性表中最后一个元素的位置 */
};

四个所写函数

/* 你的代码将被嵌在这里 */
List MakeEmpty()//创建并返回一个空的线性表；
{
   List p;
   p=(List)malloc(sizeof(struct LNode));
   p->Last=-1;// 我写的p->Last=NULL;这样就能保证加一个数字，就能从0开始
   return p;

}
Position Find( List L, ElementType X )//返回线性表中X的位置。若找不到则返回ERROR；
{
    Position i=0;
    for(i=0;i<=L->Last;i++)
    {
        if(L->Data[i]==X)
            return i;
    }

       return ERROR;
}
//将X插入在位置P并返回true。若空间已满，则打印“FULL”并返回false；如果参数P指向非法位置，则打印“ILLEGAL POSITION”并返回false；
bool Insert( List L, ElementType X, Position P )
{
    Position k;
  if(L->Last==MAXSIZE-1)//这是数组，所以应判断L->Last==MAXSIZE-1，而不是L->Last==MAXSIZE
  {
      printf("FULL");
      return false;
  }
 else if(P<0||P>L->Last+1)//可以在末尾插入，所以L->last+1可以，但如果大于了l->last+1 就不可以了
  {
      printf("ILLEGAL POSITION");
      return false;//这步我忘了
  }
   else
   {


      for(k=L->Last;k>=P;k--)//这里对我来说易错
      {
          L->Data[k+1]=L->Data[k];
      }
      L->Data[P]=X;
      L->Last++;//这步我没写
      return true;

  }
}
bool Delete( List L, Position P )//将位置P的元素删除并返回true。若参数P指向非法位置，则打印“POSITION P EMPTY”（其中P是参数值）并返回false。
{
    Position k;
    if(P<0||P>L->Last)//在这个时候就超范围了
    {
        printf("POSITION %d EMPTY",P);
        return false;
    }
    else
    {
        for(k=P;kLast;k++)//注意没有等号
        {
            L->Data[k]=L->Data[k+1];
        }
        L->Last--;
        return true;
    }
}

6-5链式表操作集

 链式定义

#define ERROR NULL
typedef int ElementType;
typedef struct LNode *PtrToLNode;
struct LNode {
    ElementType Data;
    PtrToLNode Next;
};
typedef PtrToLNode Position;
typedef PtrToLNode List;

三个函数的定义

/* 你的代码将被嵌在这里 */
Position Find( List L, ElementType X )
//返回线性表中首次出现X的位置。若找不到则返回ERROR；
{

  while(L)
  {
    if(L->Data==X)
    {

      return L;

    }
    L=L->Next;
  }

  return ERROR;

}
List Insert( List L, ElementType X, Position P )
//将X插入在位置P指向的结点之前，返回链表的表头。如果参数P指向非法位置，则打印“Wrong Position for Insertion”，返回ERROR；
{

    if(L==NULL)
    {

        L=(List)malloc(sizeof(PtrToLNode));
        L->Data=X;
        L->Next=NULL;
        return L;
    }
    List  t=(List)malloc(sizeof(PtrToLNode)), K=L;

    t->Data=X;
    if(L==P)
    {


        t->Next=L;
        return t;
    }
    while(K->Next!=P)
    {

        K=K->Next;
        if(K==NULL)
        {

            printf("Wrong Position for Insertion\n");
            return ERROR;
        }
    }
    K->Next=t;
    t->Next=P;
    return L;

}
List Delete( List L, Position P )
//将位置P的元素删除并返回链表的表头。若参数P指向非法位置，则打印“Wrong Position for Deletion”并返回ERROR。
{
    List K=L,t;
    if(K==P)
    {
        L=L->Next;
        return L;

    }
    while(K->Next!=P)
    {

        K=K->Next;
        if(K==NULL)
        {

            printf("Wrong Position for Deletion\n");
            return ERROR;
        }
    }
    t=P->Next;
    K->Next=t;
    free(P);
    return L;

}

6-7在一个数组中实现两个堆栈

其中Tag是堆栈编号，取1或2；MaxSize堆栈数组的规模；Stack结构定义如下：

typedef int Position;
struct SNode {
    ElementType *Data;
    Position Top1, Top2;
    int MaxSize;
};
typedef struct SNode *Stack;

注意：如果堆栈已满，Push函数必须输出“Stack Full”并且返回false；如果某堆栈是空的，则Pop函数必须输出“Stack Tag Empty”（其中Tag是该堆栈的编号），并且返回ERROR。false 即0，true即1

Stack CreateStack( int MaxSize )
{
    Stack s=(Stack)malloc(sizeof(struct SNode));
    s->MaxSize=MaxSize;//这步易遗忘
    s->Data=(ElementType*)malloc(MaxSize*sizeof(ElementType));//注意Data是指针，应分配内存
    s->Top1=-1;//注意top是往两边移
    s->Top2=MaxSize;
     return s;
}
bool Push( Stack S, ElementType X, int Tag )
{
      if(S->Top2-S->Top1==1)
      {
        printf("Stack Full\n");
        return 0;
      }
      if(Tag==1)
      {
        S->Data[++(S->Top1)]=X;//注意写法，top就是位置啊
        return 1;
      }
      else
      {
       S->Data[--(S->Top2)]=X;
        return 1;
      }
}
ElementType Pop( Stack S, int Tag )
{
   if(S->Top1==-1&&Tag==1)
   {
     printf("Stack %d Empty\n",Tag);
     return ERROR;
   }
   
   if(S->Top2==S->MaxSize&&Tag==2)
   {
     printf("Stack %d Empty\n",Tag);
     return ERROR;
   }
   return Tag==1?S->Data[(S->Top1)--]:S->Data[(S->Top2)++];
}

并查集之好朋友

#include 
#include
using namespace std;
const int maxn=110;

int father[maxn];
void init()
{
    for(int i=1;i>N>>m;
    for(int i=0;i>a>>b;
        Union(a,b);
    }
    int cnt=0;

    set s;//set里放不重复元素
    for(int i=1;i<=N;i++)
    {
        s.insert(findFather(i));//Find(i)才是找父亲，不要用pre[i]
    }
    cout<

树中的最长路

#include 
#include
#include
#include
#include
using namespace std;
const int maxn=100005;
struct node
{
    int to,cap;
};
vector v[maxn];
int dis[maxn],vis[maxn],ans;
int bfs(int x)
{
    memset(dis,0,sizeof(dis));
    memset(vis,0,sizeof(vis));
    queue q;
    q.push(x);
    vis[x]=1;
    int point=0;
    while(!q.empty())
    {
        int f=q.front();
        q.pop();
        if(dis[f]>ans)
        {
            ans=dis[f];
            point=f;
        }
        for(int i=0;i>n;
        for(int i=0;i

CF1066C——Codeforces Round #515 (Div. 3)

https://blog.csdn.net/Dilly__dally/article/details/83064283