【静态顺序表】的增删查改排序

版权声明： https://blog.csdn.net/spaceman_c/article/details/80607427

定义： 用一段地址连续的存储单元依次存储数据元素的线性结构

地址连续的空间：一般情况下采用数组，数组有静态数组和动态数组之分，所以顺序表分为静态顺序表和动态顺序表

静态顺序表：

#pragma once
#pragma once


#define MAX 10
// 值类型 
typedef int DataType;

typedef struct SeqList {

    DataType *data; // 值 
    int size; // 数量 
    int capacity;//最大容量

} SeqList, *pSeqList;

// 初始化 
void SeqListInit(SeqList *pSL);
//
// 尾部插入 
void SeqListPushBack(SeqList *pSL, DataType data);
//
// 头部插入 
void SeqListPushFront(SeqList *pSL, DataType data);
//
// 尾部删除 
void SeqListPopBack(SeqList *pSL);

// 头部删除 
void SeqListPopFront(SeqList *pSL);

// 按下标插入，pos 的范围是 [0, size] 
void SeqListInsert(SeqList *pSL, int pos, DataType data);
//
// 按下标删除，pos 的范围是 [0, size) 
void SeqListErase(SeqList *pSL, int pos);
//
// 按值删除，只删遇到的第一个 
void SeqListRemove(SeqList *pSL, DataType data);

// 按值删除，删除所有的 
void SeqListRemoveAll(SeqList *pSL, DataType data);

//// 清空 
//void SeqListClear(SeqList *pSL);
//
// 按值查找，返回第一个找到的下标，如果没找到，返回 -1 
int SeqListFind(SeqList *pSL, DataType data);
//
// 判断是否为空，1 表示空， 0 表示不空 
int SeqListEmpty(SeqList *pSL);

// 返回数量 
int SeqListSize(SeqList *pSL);
//
// 销毁 
void SeqListDestroy(SeqList *pSL);
//排序
void SelectSortEvolved(SeqList *pSL);

main.c中程序：

#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
#include"contant.h"

void SeqListInit(SeqList *pSL)
{
    pSL->size = 0;
    pSL->capacity = MAX;
    pSL->data = (DataType*)calloc(sizeof(DataType), pSL->capacity);
}

void SeqListShow(SeqList *pSL)
{
    int i = 0;
    for (i = 0; i < pSL->size; i++)
    {
        printf("%d  ", pSL->data[i]);
    }
    printf("\n");
}
void SeqListExtend(SeqList *pSL)
{
    DataType *p = (DataType*)realloc(pSL->data, sizeof(DataType)*(pSL->capacity + 2));
    if (NULL != p)
    {
        pSL->data = p;
        p = NULL;
    }
    pSL->capacity += 2;
    printf("增容成功");

}

void SeqListPushBack(SeqList *pSL, DataType data)
{
    assert(pSL != NULL);
    if (pSL->size >= pSL->capacity)
    {
        SeqListExtend(pSL);
    }
    pSL->data[pSL->size] = data;
    pSL->size++;

}

void SeqListPushFront(SeqList *pSL, DataType data)

{
    assert(pSL != NULL);
    if (pSL->size >= pSL->capacity)
    {
        SeqListExtend(pSL);
    }
    int i = 0;
    for (i = pSL->size; i >= 0; i--)
    {
        pSL->data[i + 1] = pSL->data[i];
    }
    pSL->data[0] = data;
    pSL->size++;

}

// 按下标插入，pos 的范围是 [0, size] 
void SeqListInsert(SeqList *pSL, int pos, DataType data)
{
    assert(pSL != NULL);
    if (pSL->size >= pSL->capacity)
    {
        SeqListExtend(pSL);
    }
    int i = 0;
    for (i = pSL->size; i >= pos; i--)
    {
        pSL->data[i + 1] = pSL->data[i];
    }
    pSL->data[pos] = data;
    pSL->size++;
}

// 尾部删除 
void SeqListPopBack(SeqList *pSL)
{
    assert(pSL != NULL);
    pSL->size--;
}

// 头部删除 
void SeqListPopFront(SeqList *pSL)
{
    int i = 0;
    for (i = 1; i < pSL->size; i++)
    {
        pSL->data[i - 1] = pSL->data[i];
    }
    pSL->size--;
}

// 按下标删除，pos 的范围是 [0, size) 
void SeqListErase(SeqList *pSL, int pos)
{
    int i = 0;
    for (i = pos; i <= pSL->size; i++)
    {
        pSL->data[i] = pSL->data[i + 1];

    }
    pSL->size--;

}

// 按值查找，返回第一个找到的下标，如果没找到，返回 -1 
int SeqListFind(SeqList *pSL, DataType data)
{
    int i = 0;
    for (i = 0; i < pSL->size; i++)
    {
        if (pSL->data[i] == data)
        {
            return i;
        }
    }
    return -1;
}

// 按值删除，只删遇到的第一个 
void SeqListRemove(SeqList *pSL, DataType data)
{
    int i = 0;
    int ret = SeqListFind(pSL, data);
    if (ret != -1)
    {
        SeqListErase(pSL, ret);
    }
}

// 按值删除，删除所有的 
void SeqListRemoveAll(SeqList *pSL, DataType data)
{
#if 0
    int i = 0;
    for (i = 0; i < pSL->size; i++)
    {
        int ret = SeqListFind(pSL, data);
        SeqListErase(pSL, ret);
    }
#endif

    int i = 0;
    int spc = 0;
    int count = 0;
    for (i = 0; i < pSL->size; i++)
    {
        if (pSL->data[i] == data)
        {
            count++;
        }
        else
        {
            pSL->data[spc] = pSL->data[i];
            spc++;
        }
    }
    pSL->size -= spc;
}

#if 1
// 判断是否为空，1 表示空， 0 表示不空 
int SeqListEmpty(SeqList *pSL)
{
    return pSL->size == 0 ? 1 : 0;
}

// 返回数量 
int SeqListSize(SeqList *pSL)
{
    return pSL->size;

}

// 清空 
void SeqListClear(SeqList *pSL)
{
    pSL->size = 0;
    pSL->data = (DataType*)calloc(sizeof(DataType), pSL->capacity);
}

void SeqListDestroy(SeqList *pSL)
{
    free(pSL->data);
    pSL->data = NULL;
    pSL->size = 0;
    pSL->capacity = 0;
    printf("销毁成功\n");

}

void Swap(DataType *a, DataType *b)
{
    DataType tmp;

    tmp = *a;
    *a = *b;
    *b = tmp;
}
//排序
void SelectSortEvolved(SeqList *pSL)
{
    int i = 0;
    int max = 0;
    int min = 0;
    for (i = 0; i < pSL->size / 2; i++)
    {
        min = max = i;
        int j = 0;
        for (j = i; j < pSL->size - i; j++)
        {
            if (pSL->data[min] >pSL->data[j])
            {
                min = j;
            }
            if (pSL->data[max] < pSL->data[j])
            {
                max = j;
            }

        }
        Swap(pSL->data + i, pSL->data + min);

        //相等情况下
        if (i == max)
        {
            max = min;
        }
        Swap(pSL->data + pSL->size - i - 1, pSL->data + max);
    }


}
#endif 

int main()
{
    SeqList my_son;
    SeqListInit(&my_son);

    SeqListPushBack(&my_son, 1);
    SeqListPushBack(&my_son, 2);
    SeqListPushBack(&my_son, 3);
    SeqListPushBack(&my_son, 3);
    SeqListShow(&my_son);

    SeqListPushFront(&my_son, 4);
    SeqListPushFront(&my_son, 5);
    SeqListPushFront(&my_son, 6);
    SeqListShow(&my_son);

    SeqListInsert(&my_son, 2, 7);
    SeqListShow(&my_son);

    SelectSortEvolved(&my_son);
    SeqListShow(&my_son);

    SeqListPopFront(&my_son);
    SeqListShow(&my_son);

    SeqListPopBack(&my_son);
    SeqListShow(&my_son);

    SeqListErase(&my_son, 4);
    SeqListShow(&my_son);

    int ret = SeqListFind(&my_son, 7);
    if (ret != -1)
    {
        printf("找到了下标:%d\n", ret);
    }
    else
    {
        printf("没找到\n");
    }

    SeqListRemove(&my_son, 2);
    SeqListShow(&my_son);

    SeqListRemoveAll(&my_son, 3);
    SeqListShow(&my_son);

    int count = SeqListSize(&my_son);
    printf("count=%d\n", count);

    int x = SeqListEmpty(&my_son);
    if (x == 1)
    {
        printf("为空\n");
    }
    else
    {
        printf("不为空\n");
    }

    // 清空 
    SeqListClear(&my_son);
    SeqListShow(&my_son);
    //销毁
    SeqListDestroy(&my_son);

    system("pause");
    return 0;
}