顺序表经典面试题

头文件如下：

#include
#include
#include

#ifndef _SEQLIST_H_
#define _SEQLIST_H_
// 实现顺序表的以下接口
typedef int DataType;
#define MaxSize 10

typedef struct SeqList
{
    DataType array[MaxSize];
    int size;   // 有效数据元素的个数
}SeqList;



//////////////////////////////////////
// 初始化顺序表
void InitSeqList(SeqList* pSeq);

// 在顺序表的尾部插入值为data的元素
void PushBack(SeqList* pSeq, DataType _data);

// 删除顺序表的最后一个元素
void PopBack(SeqList* pSeq);

// 在顺序表的头部插入值为data的元素
void PushFront(SeqList* pSeq, DataType data);

// 删除顺序表头部元素
void PopFront(SeqList* pSeq);

// 在顺序表中pos位置上插入值为data的元素
void Insert(SeqList* pSeq, size_t pos, DataType data);

// 删除顺序表中pos位置上的元素
void Erase(SeqList* pSeq, size_t pos);

// 在顺序表中查找值为data的元素，找到返回该元素的位置，否则返回-1
int Find(SeqList* pSeq, DataType data);

// 删除顺序表中第一个值为data的元素
void Remove(SeqList* pSeq, DataType data);

// 删除顺序表中所有值为data的元素
void RemoveAll(SeqList* pSeq, DataType data);

// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(SeqList* pSeq);

// 使用选择排序给顺序表中的元素排序
void SelectSort(SeqList* pSeq);

// 使用二分查找在顺序表中查找值为data
int BinarySearch(SeqList* pSeq, DataType data);

//打印顺序表中所有元素
void ShowSeqList(SeqList* pSeq);
#endif

实现源文件：

#include"seqlist.h"
 //初始化顺序表
void InitSeqList(SeqList* pSeq)
{
    assert(pSeq);
    memset(pSeq->array, 0, MaxSize*sizeof(DataType));
    pSeq->size = 0;
}


// 在顺序表的尾部插入值为data的元素
void PushBack(SeqList* pSeq, DataType _data)
{
    assert(pSeq);
    if (pSeq->size > MaxSize)
    {
        return;
    }
    pSeq->array[pSeq->size] = _data;
    pSeq->size++;
}


// 删除顺序表的最后一个元素
void PopBack(SeqList* pSeq)
{
    if (NULL == pSeq || pSeq->size == 0)
    {
        return 0;
    }
    pSeq->size--;

}

// 在顺序表的头部插入值为data的元素
void PushFront(SeqList* pSeq, DataType data)
{
    int idx=0;
    assert(pSeq);
    if (pSeq->size > MaxSize)
    {
        return;
    }
    for (idx = pSeq->size - 1; idx >= 0; idx--)
    {
        pSeq->array[idx + 1] = pSeq->array[idx];
    }
    pSeq->array[0] = data;
    pSeq->size++;
}

// 删除顺序表头部元素
void PopFront(SeqList* pSeq)
{
    int idx = 0;
    assert(pSeq);
    if (pSeq->size == 0)
    {
        return;
    }
    for (idx = 1; idx < pSeq->size; idx++)
    {
        pSeq->array[idx - 1] = pSeq->array[idx];

    }
    pSeq->size--;

}

//打印顺序表中所有元素
void ShowSeqList(SeqList* pSeq)
{
    int idx = 0;
    assert(pSeq);
    for (idx; idx < pSeq->size; idx++)
    {
        printf("%d ", pSeq->array[idx]);
    }
    printf("\n");

}



// 在顺序表中pos位置上插入值为data的元素
void Insert(SeqList* pSeq, size_t pos, DataType data)
{
    int idx = 0;
    assert(pSeq);
    if (pos > MaxSize)
    {
        return;
    }

    for (idx =pSeq->size-1; idx >=pos; idx--)
    {
        pSeq->array[idx + 1] = pSeq->array[idx];
    }
    pSeq->array[pos] = data;
    pSeq->size++;

}

// 删除顺序表中pos位置上的元素
void Erase(SeqList* pSeq, size_t pos)
{
    int idx = 0;
    assert(pSeq);
    if (pSeq->size == 0)
    {
        return;
    }
    for (idx = pos; idx < pSeq->size; idx++)
    {
        pSeq->array[idx] = pSeq->array[idx + 1];
    }
    pSeq->size--;

}



// 在顺序表中查找值为data的元素，找到返回该元素的位置，否则返回-1
int Find(SeqList* pSeq, DataType data)
{
    int idx = 0;
    assert(pSeq);

    for (idx = 0; idx < pSeq->size; idx++)
    {
        if (pSeq->array[idx] == data)
        {
            return 1;
        }
    }
    return -1;


}

// 删除顺序表中第一个值为data的元素
void Remove(SeqList* pSeq, DataType data)
{
    int idx = 0;
    assert(pSeq);

    for (idx = 0; idx < pSeq->size; idx++)
    {
        if (pSeq->array[idx] == data)
        {
            for (idx ; idx < pSeq->size-1; idx++)
            {
                pSeq->array[idx] = pSeq->array[idx + 1];
            }
            pSeq->size--;
            return;
        }
    }

}


// 删除顺序表中所有值为data的元素
void RemoveAll(SeqList* pSeq, DataType data)
{

    int idx = 0;
    int idz = 0;
    assert(pSeq);

    for (idx = 0; idx < pSeq->size; idx++)
    {
        if (pSeq->array[idx] == data)
        {
            for (idz=idx; idz < pSeq->size-1; idz++)
            {
                pSeq->array[idz] = pSeq->array[idz + 1];
            }
            pSeq->size--;
            idx--;
        }
    }
}



// 使用冒泡排序给顺序表中的元素排序
void BubbleSort(SeqList* pSeq)
{
    int i = 0, j = 0;
    int flag = 0;
    assert(pSeq);
    for (j = 0; j < pSeq->size; j++)
    {
        flag = 0;
        for (i = j+1; i < pSeq->size; i++)
        {
            if (pSeq->array[i]>pSeq->array[j])
            {
                pSeq->array[i] ^= pSeq->array[j];
                pSeq->array[j] ^= pSeq->array[i];
                pSeq->array[i] ^= pSeq->array[j];
                flag = 1;
            }
        }
        if (flag != 0)
        {
            return;
        }
    }
}

// 使用选择排序给顺序表中的元素排序
void SelectSort(SeqList* pSeq)
{

    int i = 0, j = 0;
    assert(pSeq);
    for (i = 0; i < pSeq->size; i++)
    {
        for (j = i+1; j < pSeq->size; j++)
        {
            if (pSeq->array[j]>pSeq->array[i])
            {
                i = j;
            }
        }
    }

}

// 使用二分查找降序排列中的元素
int BinarySearch(SeqList* pSeq, DataType data)
{
    int left = 0, mid = (p->size)/2,right=p->size-1;
    assert(pSeq);
    while (left < right)
    {
        if (data < pSeq->array[mid])
        {
            left = mid++;
        }
        else if (data>pSeq->array[mid])
        {
            right = mid--;
        }
        else
        {
            return 1;
        }
        mid = (left + right) / 2;
    }
    return -1;

}


int main()
{
    SeqList mylist;
    InitSeqList(&mylist);
    PushBack(&mylist, 1);
    PushBack(&mylist, 2);
    ShowSeqList(&mylist);

    //PopFront(&mylist);
    ShowSeqList(&mylist);

    //PushFront(&mylist, 6);
    ShowSeqList(&mylist);



    PushBack(&mylist, 3);
    PushBack(&mylist, 4);
    PushBack(&mylist, 5);
    PushBack(&mylist, 6);

    Insert(&mylist, 5, 9);
    //ShowSeqList(&mylist);
    Erase(&mylist, 5);
    printf("%d", Find(&mylist, 5));

    PushBack(&mylist, 6);
    PushBack(&mylist, 6);
    PushBack(&mylist, 6);

//  Remove(&mylist, 6);
    RemoveAll(&mylist, 6);



    return 0;
}