C语言实现顺序表

淩亂°似流年 2022-07-17 04:16 209阅读 0赞

#pragma once
    #include<stdio.h>
    
    #include<assert.h>
    #include<string.h>
    #define MAX_SIZE 5
    typedef int DataType;
     
    typedef struct SeqList
    {
               DataType array[MAX_SIZE ];
               size_t size;
    }SeqList;
    
    void PrintSeqList(SeqList * pSeq);
    void InitSeqList(SeqList * pSeq);
    void PushBack(SeqList * pSeq, DataType x);
    void PopBack(SeqList * pSeq);
    void PushFront(SeqList * pSeq, DataType x);
    void Popfront(SeqList * pSeq);
    void Insert(SeqList *pSeq, rsize_t pos, DataType x);
    int Find(SeqList *pSeq, DataType x);
    int  Remove(SeqList * pSeq, DataType x);
    void  RemoveAll(SeqList * pSeq, DataType x);
    
    void printSeqList(SeqList * pSeq);
    
    
    void InitSeqList(SeqList *  pSeq)
    {
              
              memset( pSeq->array, 0, sizeof (DataType)* MAX_SIZE);
               pSeq->size = 0;
    }
    
    void PushBack(SeqList * pSeq, DataType x )
    {
               assert(pSeq );
               if (pSeq ->size >= MAX_SIZE)
              {
                       printf( "SeqList is full");
                        return;
              }
               pSeq->array[pSeq ->size++] = x;
    }
    void PopBack(SeqList * pSeq)
    {
               assert(pSeq );
               if (pSeq ->size <= 0)
              {
                       printf( "SeqList is Empty");
                        return;
              }
               pSeq->array[--pSeq ->size ] = 0;
    }
    void PrintSeqList(SeqList * pSeq)
    {
               int i = 0;
               assert(pSeq );
               for (; i < pSeq ->size; ++i)
              {
                       printf( "%d ", pSeq ->array[i]);
              }
              printf( "\n");
    }
    
    
    void PushFront(SeqList * pSeq, DataType x )
    {
               int begin = pSeq ->size - 1;
               assert(pSeq );
               if (pSeq ->size >= MAX_SIZE)
              {
                       printf( "SeqList is full\n");
                        return ;
              }
               for (; begin >= 0; --begin)
              {
                        pSeq->array[begin + 1] = pSeq ->array[begin];
              }
               pSeq->array[0] = x ;
              ++ pSeq->size;
    }
    void Popfront(SeqList * pSeq)
    {
               int begin = 1;
               assert(pSeq );
               if (pSeq ->size <= 0)
              {
                       printf( "SeqList is Empty");
                        return;
              }
              
               for (; begin < pSeq ->size; ++begin)
              {
                        pSeq->array[begin - 1] = pSeq ->array[begin];
                       
              }
              -- pSeq->size;
    }
    
    
    void Insert(SeqList *pSeq, rsize_t pos , DataType x)
    {
               int begin = pSeq ->size - 1;
               assert(pSeq );
               assert(pos <= pSeq->size);
               if (pSeq ->size >= MAX_SIZE)
              {
                       printf( "SeqList is full\n");
                        return;
              }
               for (; begin >= pos ; --begin)
              {
                        pSeq->array[begin + 1] = pSeq ->array[begin];
              }
               pSeq->array[pos ] = x;
              ++ pSeq->size;
    }
    
    
    int Find(SeqList *pSeq, DataType x )
    {
               int i = 0;
               assert(x );
               for (; i < pSeq ->size; i++)
              {
                        if (pSeq ->array[i] == x)
                       {
                                  return i;
                       }
                        return -1;
              }
    }
    
    
    void Erase(SeqList * pSeq, size_t pos )
    {
               assert(pSeq );
               if (pSeq ->size <= 0)
              {
                       printf( "SeqList is Empty\n");
                        return;
              }
               assert(pos < pSeq->size);
               int begin = pos + 1;
               for (; begin < pSeq ->size; ++begin)
              {
                        pSeq->array[begin - 1] = pSeq ->array[begin];
              }
              --begin;
    }
    
    
    int  Remove(SeqList * pSeq, DataType x )
    {
               int pos;
               assert(pSeq );
              pos = Find( pSeq, x );
               if (pos != -1)
              {
                       Erase( pSeq, pos);
              }
               return pos;
    }
    
    
    void  RemoveAll(SeqList * pSeq, DataType x )
    {
               int pos;
               assert(pSeq );
              pos = Find( pSeq, x );
               while (pos != -1)
              {
                       Erase( pSeq, pos);
                       pos = Find( pSeq, x );
              }
    }
    
    
    int BinarySearch(SeqList * pSeq, DataType x )
    {
               assert(pSeq );
    
               int left = 0;
               int right = pSeq ->size;
               while (left < right)
              {
                        int mid = (right + left) / 2;
                        if (x >pSeq->array[mid])
                       {
                                 left = mid + 1;
                       }
                        else if (x < pSeq->array[mid])
                       {
                                 right = mid - 1;
                       }
                        else
                                  return mid;
              }
    }