C语言实现静态顺序表

C语言实现静态顺序表

首先小小声明一下,最近一直没有更新博客，主要是在忙于搭建自己的博客，因为这个CSDN用起来确实不是很方便，再加上刚开学事情比较多，所以就没有太更新。

现在，做个小小的宣传，我的个人博客网站： www.louhang.xin  欢迎大家来访问，这个网站上也主要是我的学习历程和技术分析。以后我的主要博客技术分享就主要放在自己的网站上了，当然CSDN上也会更新的。

ok，闲话说完，进入正题：

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。

下面我们来看看以C语言的形式来如何实现数据结构–静态顺序表。

我将代码分成了三部分，第一步部分即头文件，第二部分顺序表代码部分，第三部分测试部分，详看代码如下：

1. 头文件（SqeList.h）

#ifndef __SEQLIST_H__
#define __SEQLIST_H__
 
#define  _CRT_SECURE_NO_WARNINGS 1
 
#include<stdio.h>
#include<assert.h>
#include <string.h>
#include <stdlib.h>
 
#define N 100
 
typedef int DataType;
 
typedef struct SeqList
{
    DataType array[N]; // 数组
    size_t size;       // 有效数据的个数
}SeqList;
 
void InitSeqList(SeqList* s);
void PrintSeqList(SeqList* s);
void PushBack(SeqList* s, DataType x);
void PopBack(SeqList* s);
void PushFront(SeqList* s, DataType x);
void PopFront(SeqList* s);
void Insert(SeqList* s, size_t pos, DataType x);
void Erase(SeqList* s, size_t pos);
int Find(SeqList* s, DataType x);
void Modify(SeqList* s, size_t pos, DataType x);
void Remove(SeqList* s, DataType x);
void RemoveAll(SeqList* s, DataType x);
void BubbleSort(SeqList* s);
void SelectSort(SeqList* s);
void SelectSort_OP(SeqList* s);
int BinarySearch(SeqList* s, DataType x);
 
#endif //__SEQLIST_H__

2. 顺序表（SqeList.c）

#include"Seqlist.h"
 
//初始化结构体
void InitSeqList(SeqList* s)
{
    assert(s);
    memset(s, 0, sizeof(DataType)*N);
    s->size = 0;
}
 
//打印函数
void PrintSeqList(SeqList* s)
{
    size_t i = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    for (i = 0; i < s->size; i++)
    {
        printf("%d ", s->array[i]);
    }
    printf("\n");
}
 
//输入元素
void PushBack(SeqList* s, DataType x)
{
    assert(s);
    if (s->size == N)
    {
        perror("SeqList is full\n");
        return;
    }
 
    s->array[s->size] = x;
    s->size++;
}
 
//删除元素
void PopBack(SeqList* s)
{
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    s->size--;
}
 
//在顺序表头部插入元素
void PushFront(SeqList* s, DataType x)
{
    size_t i = 0;
    assert(s);
    if (s->size == N)
    {
        perror("SeqList is full\n");
        return;
    }
 
    for (i = 0; i < s->size; i++)
    {
        s->array[s->size - i] = s->array[s->size - i - 1];
    }
 
    s->array[0] = x;
    s->size++;
}
 
//删除顺序表头部元素
void PopFront(SeqList* s)
{
    size_t i = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    for (i = 0; i < s->size-1; i++)
    {
        s->array[i] = s->array[i + 1];
    }
 
    s->size--;
}
 
//在指定位置插入元素
void Insert(SeqList* s, size_t pos, DataType x)
{
    size_t i = pos;
    assert(s);
    assert(pos >= 0 && pos <= s->size - 1);
    if (s->size == N)
    {
        perror("SeqList is full\n");
        return;
    }
     
    for (i = s->size-1; i >= pos; i--)
    {
        s->array[i + 1] = s->array[i];
    }
    s->array[pos] = x;
    s->size++;
}
 
//删除指定位置的元素
void Erase(SeqList* s, size_t pos)
{
    size_t i = 0;
    assert(s);
    assert(pos >= 0 && pos <= s->size - 1);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    for (i = pos; i < s->size - 1; i++)
    {
        s->array[i] = s->array[i + 1];
    }
    s->size--;
}
 
//查找元素
int Find(SeqList* s, DataType x)
{
    int i = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    for (i = 0; i < s->size; i++)
    {
        if (s->array[i] == x)
        {
            return i;
        }
    }
    printf("Find failed\n");
    return -1;
}
 
//修改指定位置的元素
void Modify(SeqList* s, size_t pos, DataType x)
{
    int i = 0;
    assert(s);
    assert(pos >= 0 && pos <= s->size - 1);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    s->array[pos] = x;
}
 
//删除某元素
void Remove(SeqList* s, DataType x)
{
    size_t i = 0;
    size_t j = 0;
    DataType pos;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    利用查找函数和擦除函数进行删除
    pos = Find(s, x);
    if (pos == -1)
    {
        return;
    }
    else if (pos != -1)
    {
        Erase(s, pos);
    }
 
    //利用for循环来进行删除
    //for (i = 0; i < s->size; i++)
    //{
    //  if (s->array[i] == x)
    //  {
    //      for (j = i; j < s->size - 1; j++)
    //      {
    //          s->array[j] = s->array[j + 1];
    //      }
    //      s->size--;
    //      break;
    //  }
    //}
}
 
//删除顺序中所有的某元素
void RemoveAll(SeqList* s, DataType x)
{
    DataType i = 0;
    DataType j = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    while (i < s->size)
    {
        if (s->array[i] != x)
        {
            s->array[j] = s->array[i];
            j++;
        }
        i++;
    }
    s->size = j;
     
        //遍历删除某元素
    //for (i = 0; i < s->size; i++)
    //{
    //  if (s->array[i] == x)
    //  {
    //      for (j = i; j < s->size - 1; j++)
    //      {
    //          s->array[j] = s->array[j + 1];
    //      }
    //      s->size--;
    //  }
    //}
}
 
//元素交换函数
void Swap(DataType *left, DataType *right)
{
    DataType temp = *left;
    *left = *right;
    *right = temp;
}
 
//冒泡排序
void BubbleSort(SeqList* s)
{
    size_t i = 0;
    size_t j = 0;
    int flag = 0;
    DataType temp = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList is empty\n");
        return;
    }
 
    for (i = 0; i < s->size; i++)
    {
        flag = 0;
         
        for (j = 0; j < s->size - i - 1; j++)
        {
            if (s->array[j] > s->array[j + 1])
            {
                Swap(s->array + j, s->array + j + 1);
                flag = 1;
            }  
        }
        if (flag == 0)
        {
            break;
        }
    }
}
 
//选择排序
void SelectSort(SeqList* s)
{
    size_t i = 0;
    size_t j = 0;
    size_t min = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList if empty\n");
        return;
    }
 
    for (i = 0; i < s->size; i++)
    {
        min = i;
        for (j = i; j<s->size; j++)
        {
            if (s->array[min]>s->array[j])
            {
                min = j;
            }
        }
        Swap(s->array + i, s->array + min);
    }
}
 
//优化选择排序
void SelectSort_OP(SeqList* s)
{
    size_t i = 0;
    size_t j = 0;
    size_t min = 0;
    size_t max = 0;
    size_t start = 0;
    size_t end = 0;
    assert(s);
    if (s->size == 0)
    {
        perror("SeqList if empty\n");
        return;
    }
 
    for (start = 0, end = s->size-1; start < end; start++, end--)
    {
        min = start;
        max = end;
        for (i = start; i <= end; i++)
        {
            if (s->array[min] > s->array[i])
            {
                min = i;
            }
            if (s->array[max] < s->array[i])
            {
                max = i;
            }
        }
        Swap(s->array + start, s->array + min);
         
        if (start == max)
        {
            max = min;
        }
        Swap(s->array + end, s->array + max);
    }
}
 
//二分查找
int BinarySearch(SeqList* s, DataType x)
{
    size_t left = 0;
    size_t right = s->size - 1;
    size_t mid;
    while (left < right)
    {
        mid = left + (right - left) / 2;
     
        if (s->array[mid] > x)
        {
            right = mid - 1;
        }
        else if (s->array[mid] < x)
        {
            left = mid + 1;
        }
        else
        {
            return mid;
        }
    }
}

3. 测试代码（test.c）

#include"Seqlist.h"
int main()
{
    SeqList s;
    int ret = 0;
    //Init
    InitSeqList(&s);
 
    //PushBack
    PushBack(&s, 1);
    PushBack(&s, 8);
    PushBack(&s, 3);
    PushBack(&s, 0);
    PushBack(&s, 9);
    PushBack(&s, 7);
    PushBack(&s, 2);
    PushBack(&s, 4);
 
    PrintSeqList(&s);
 
    //Popback
    PopBack(&s);
    PopBack(&s);
 
    PrintSeqList(&s);
 
    //PushFront
    PushFront(&s, 0);
    PushFront(&s, 4);
 
    PrintSeqList(&s);
 
    //PopFront
    PopFront(&s);
    PopFront(&s);
 
    PrintSeqList(&s);
 
    //Insert
    Insert(&s, 2, 1);
    Insert(&s, 4, 6);
    Insert(&s, 6, 2);
 
    PrintSeqList(&s);
 
    //Erase
    Erase(&s, 4);
 
    PrintSeqList(&s);
 
    //Find
    //ret = Find(&s, 1);
    //printf("%d\n", ret);
     
    //Modify(
    Modify(&s, 4, 6);
 
    PrintSeqList(&s);
 
    //Remove
    Remove(&s, 1);
 
    PrintSeqList(&s);
 
    //RemoveAll
    RemoveAll(&s, 2);
 
    PrintSeqList(&s);
 
    //BubbleSort
    //BubbleSort(&s);
 
    //PrintSeqList(&s);
 
    //SelectSort
    //SelectSort(&s);
 
    //PrintSeqList(&s);
 
    //SelectSort_OP
    SelectSort_OP(&s);
 
    PrintSeqList(&s);
     
    //BinarySearch
    ret = BinarySearch(&s, 3);
    printf("\n%d\n", ret);
 
    system("pause");
    return 0;
}