数据结构——如何定义与建立

---

(1) 顺序线性表的定义
    #define maxsize  100
 typedef struct{
             int aa[maxsize];
            int size;
       }Sqlist;

 

 

 

(2)栈的定义
#define STACK_INIT_SIZE 100
typdef struct
  {  int *P1;     //p1指向栈底的元素
      int *P2;     //p2指向栈顶的元素的上一个元素，因此在向栈压入元素时候，必须先插入后改变指针
      int stacksize;
  }Sqstack ;

 

 栈的第二种定义：

  const int MAXSIZE = 栈的最大容量；
  typedef struct {
            DataType elem[MAXSIZE];
             int top;
         } SqStack;

 栈的相关操作算法：

---

 

1、int InitStack(Sqstack s)
{
  s.p1=(int*)malloc(STACK_INIT_SIZE *Sizeof(int));
  s.p2=s.p1;
  s.stacksize=STACK_INIT_SIZE;
  return 1;
}

2、int Push(Sqstack &S,int a)
{
 *s.top=a;
  s.top++;
}
3、int Pop(Sqatack &s,int a)
{
 if(s.top=s.bottom) return 0;
   s.top--;
   a=*s.top
}

 

---

 

 (2)队列的定义

 

    第一：循环线性队列

       

循环队列的类型定义：

#define MAXSIZE 50  /*队列的最大长度*/

typedef struct

{

       QueueElementType  element[MAXSIZE];  /* 队列的元素空间*/

       int  front;  /*头指针指示器*/

       int  rear ;  /*尾指针指示器*/rear指向队尾的元素的上一个元素，因此在向队列压入元素时候，必须先插入后改变指针

     }SeqQueue;

1、循环线性队列的操作算法

---

      （1）     初始化操作。

      void InitQueue（SeqQueue * Q）

            {  /* 将*Q初始化为一个空的循环队列 */

               Q->front=Q->rear=0;

           }

 

 

     （2）     入队操作。

          int EnterQueue(SeqQueue *Q, QueueElementType x)

            {  /*将元素x入队*/

               if((Q->rear+1)%MAXSIZE==Q->front)  /*队列已经满了*/   注意：这是循环队列是否满的判断条件，当采用这个判断条件时，就会少用一个元素空间，并且能够与队列是否为空的判断条件不一样

                return(FALSE);

             Q->element[Q->rear]=x;

            Q->rear=(Q->rear+1)%MAXSIZE;  /* 重新设置队尾指针 */

           return(TRUE);  /*操作成功*/

         }

 

   （3）出队操作。

        int DeleteQueue(SeqQueue *Q, QueueElementType * x)

        {                                                                                         /*删除队列的队头元素，用x返回其值*/

            if（Q->front==Q->rear）  /*队列为空*/

                return(FALSE);

            *x=Q->element[Q->front];

            Q->front=(Q->front+1)%MAXSIZE;  /*重新设置队头指针*/

            return(TRUE);  /*操作成功*/

      }

---

   第二：链队列的定义

       #define  TRUE 1

       #define  FALSE 0

      typedef struct Node

          {

            QueueElementType  data;  /*数据域*/

             struct Node       next;  /*指针域*/

          }LinkQueueNode;

   typedef struct

     {

         LinkQueueNode  * front;

          LinkQueueNode  * rear;

     }LinkQueue;

 

链队列的常见操作算法：

 

          （1）初始化操作。

int InitQueue(LinkQueue * Q)

{ /* 将Q初始化为一个空的链队列 */

  Q->front=(LinkQueueNode *)malloc(sizeof(LinkQueueNode));

  if(Q->front!=NULL)

         {

                Q->rear=Q->front;

                Q->front->next=NULL;

                      return(TRUE);

         }

  else       return(FALSE);    /* 溢出！*/

}

 

（2）入队操作。

int EnterQueue(LinkQueue *Q, QueueElementType x)

{  /* 将数据元素x插入到队列Q中 */

LinkQueueNode  * NewNode;

NewNode=(LinkQueueNode * )malloc(sizeof(LinkQueueNode));

if(NewNode!=NULL)

{

   NewNode->data=x;

   NewNode->next=NULL;

   Q->rear->next=NewNode;

    Q->rear=NewNode;

return(TRUE);

}

   else  return(FALSE);    /* 溢出！*/

}

 

（3）出队操作。

int DeleteQueue(LinkQueue * Q, QueueElementType *x)

{  /* 将队列Q的队头元素出队，并存放到x所指的存储空间中 */

LinkQueueNode * p;

if(Q->front==Q->rear)

   return(FALSE);

p=Q->front->next;

Q->front->next=p->next;  /* 队头元素p出队 */

if(Q->rear==p)  /* 如果队中只有一个元素p，则p出队后成为空队 */

Q->rear=Q->front; 

*x=p->data;

free(p);   /* 释放存储空间 */

return(TRUE);     

}

 

---