静态顺序表c语言实现

实现涉及到顺序表的增删改查排序。

seqList.h

#pragma once
typedef int DataType;
#define MAX_SIZE 10 

typedef struct SeqList
{
    DataType _array[MAX_SIZE];
    int _size; // 表示顺序表中有效元素的个数 
}SeqList, *PSeqList;

// 顺序表的初始化 
void SeqListInit(PSeqList ps);

// 顺序表的尾插 
void SeqListPushBack(PSeqList ps, DataType data);

// 顺序表的尾删 
void SeqListPopBack(PSeqList ps);

// 顺序表的头插 
void SeqListPushFront(PSeqList ps, DataType data);

// 顺序表的头删 
void SeqListPopFront(PSeqList ps);

// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, DataType data);

// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos);

// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, DataType data);

// 移除顺序表中所有值为data的元素 
void RemoveAll(PSeqList ps, DataType data);

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

// 获取顺序表中元素的个数 
int SeqListSize(PSeqList ps);

// 打印顺序表 
void PrintSeqList(PSeqList ps);

// 使用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(PSeqList ps);

// 使用选择排序堆顺序表中的元素进行排序 
void SelectSort(PSeqList ps);

seqList.c

#include "seqList.h"
#include <stdlib.h>
#include <stdio.h>
// 顺序表的初始化 
void SeqListInit(PSeqList ps) {
    if (NULL == ps) {
        return;
    }
    ps->_size = 0;
}

// 顺序表的尾插 
void SeqListPushBack(PSeqList ps, DataType data) {
    if (NULL == ps) {
        return;
    }
    if (ps->_size >= MAX_SIZE) {
        printf("满了\n");
        return;
    }
    ps->_array[ps->_size] = data;
    ++ps->_size;
}

// 顺序表的尾删 
void SeqListPopBack(PSeqList ps) {
    if (NULL == ps) {
        return;
    }
    if (ps->_size <= 0) {
        printf("没有可以删的元素了\n");
        return;
    }
    --ps->_size;
}

// 顺序表的头插 
void SeqListPushFront(PSeqList ps, DataType data) {
    if (NULL == ps) {
        return;
    }
    if (ps->_size >= MAX_SIZE) {
        printf("满了\n");
        return;
    }
    int i = 0;
    for (i = ps->_size; i > 0; i--) {
        ps->_array[i] = ps->_array[i-1];
    }
    ps->_array[0] = data;
    ps->_size++;
}


// 顺序表的头删 
void SeqListPopFront(PSeqList ps) {
    if (NULL == ps) {
        return;
    }
    if (ps->_size <= 0) {
        printf("没有元素可以删\n");
        return;
    }
    int i = 0;
    for (i = 1; i < ps->_size; i++) {
        ps->_array[i - 1] = ps->_array[i];
    }
    ps->_size--;
}

// 顺序表pos位置插入元素data 
void SeqListInsert(PSeqList ps, int pos, DataType data) {
    if (NULL == ps || !(pos >= 0 && pos <=ps->_size)) {
        return;
    }
    if (ps->_size >= MAX_SIZE) {
        printf("满了\n");
        return;
    }
    int i = 0;
    for (i = ps->_size; i > pos; i--) {
        ps->_array[i] = ps->_array[i - 1];
    }
    ps->_array[pos] = data;
    ps->_size++;
}


// 删除顺序表pos位置元素 
void SeqListErase(PSeqList ps, int pos) {
    if (NULL == ps || !(pos >=0 && pos <=ps->_size)) {
        return;
    }
    if (ps->_size <= 0) {
        printf("没有元素可以删\n");
        return;
    }
    int i = 0;
    for (i = pos; i < ps->_size-1; i++) {
        ps->_array[i] = ps->_array[i+1];
    }
    ps->_size--;
}

// 移除顺序表中第一个值为data的元素 
void Remove(PSeqList ps, DataType data) {
    if (NULL == ps) {
        return;
    }
    if (ps->_size <= 0) {
        printf("没有元素可以删\n");
        return;
    }
    int i = 0;
    int j = 0;
    for (i = 0; i < ps->_size; i++) {
        if (ps->_array[i] == data) {
            for (j = i; j < ps->_size-1; j++) {
                ps->_array[j] = ps->_array[j + 1];
            }
            ps->_size--;
            return;
        }
    }
    printf("没有元素可以删\n");
    return;
}

// 移除顺序表中所有值为data的元素O(1)
void RemoveAll(PSeqList ps, DataType data) {
    if (NULL == ps) {
        return;
    }
    if (ps->_size <= 0) {
        printf("没有元素可以删\n");
        return;
    }
    int i = 0;
    int count = 0;
    for (i = 0; i < ps->_size; i++) {
        if (ps->_array[i] == data) {
            count++;
        }
        else {
            ps->_array[i - count] = ps->_array[i];
        }
    }
    ps->_size -= count;
}

// 在顺序表中查找值为data的元素，找到返回该元素在顺序表中的位置，否则返回-1 
int SeqListFind(PSeqList ps, DataType data) {
    if (NULL == ps) {
        return -1;
    }
    int i = 0;
    for (i = 0; i < ps->_size; i++) {
        if (data = ps->_array[i]) {
            return i;
        }
    }
    return -1;
}

// 获取顺序表中元素的个数 
int SeqListSize(PSeqList ps) {
    if (NULL == ps) {
        return -1;
    }
    return ps->_size;
}

// 打印顺序表 
void PrintSeqList(PSeqList ps) {
    if (NULL == ps) {
        return;
    }
    int i = 0;
    for (i = 0; i < ps->_size; i++) {
        printf("%d\n", ps->_array[i]);
    }
}
void swap(int*a, int *b) {
    int tmp = 0;
    tmp = *a;
    *a = *b;
    *b = tmp;
}
// 使用冒泡排序对顺序表中的元素进行排序 
void BubbleSort(PSeqList ps) {
    if (NULL == ps) {
        return ;
    }
    int i = 0;
    int j = 0;
    for (i = 0; i < ps->_size - 1; i++) {
        for(j=0 ; j<ps->_size-1-i; j++){
            if(ps->_array[j] > ps->_array[j+1]){
                swap(&(ps->_array[j]), &(ps->_array[j + 1]));
            }
        }
    }
}

// 使用选择排序顺序表中的元素进行排序 
void SelectSort(PSeqList ps) {
    if (NULL == ps) {
        return;
    }
    int i = 0;
    int j = 0;
    int maxCur = 0;
    for (i = 0; i < ps->_size-1; i++) {
        maxCur = i;
        for (j = i; j < ps->_size; j++) {
            if (ps->_array[j] > ps->_array[maxCur]) {
                maxCur = j;
            }
        }
        if (maxCur != i) {
            swap(&ps->_array[i], &ps->_array[maxCur]);
        }
    }
}

test.c

#include "seqList.h"
int main()
{
    SeqList s;
    SeqListInit(&s);
    SeqListInsert(&s, 0, 1);
    SeqListInsert(&s, 0, 3);
    SeqListInsert(&s, SeqListSize(&s), 5);
    BubbleSort(&s);
    SeqListPushBack(&s, 4);
    SeqListPushFront(&s, 0);
    SelectSort(&s);
    SeqListInsert(&s, SeqListSize(&s), 5);
    SeqListInsert(&s, SeqListSize(&s), 3);
    SeqListErase(&s, 0);
    Remove(&s, 3);
    SeqListPushFront(&s, 5);
    RemoveAll(&s, 5);
    system("pasue");
}