动态顺序表

最新推荐文章于 2018-10-10 20:37:23 发布
最新推荐文章于 2018-10-10 20:37:23 发布
阅读量1.1k 收藏 1
点赞数 1
文章标签： 顺序表 动态 增 删 查
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangrujing/article/details/46662597
版权

seqlist.h

#pragma once
#define  _SEQ_LIST_
#ifdef  _SEQ_LIST_
#include<stdio.h>
#include<assert.h>
#include<string.h>

#define DEFAULT_CAPACITY  3
typedef int DataType;

typedef struct SeqList
{
    DataType *arr;
    size_t size;
    size_t capacity;

}SeqList;
typedef enum TAG
{
    TRUE,
    FALSE,
}TAG;
typedef struct Findret
{
    TAG Isfind;  //是否找到下标
    size_t index;  //找到数据的下标
}Findret;


void Cheekcapacity(SeqList* pSeq);//检查容量
void InitSeqList(SeqList* pSeq); //初始化链表
void PrintSeqList(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, size_t index, DataType x);//在index位置插入x
void Modified(SeqList* pSeq, size_t index, DataType x);//将index位置的元素修改为x
void removed(SeqList* pSeq, size_t index); //移除index位置的元素
Findret  Find(SeqList* pSeq, DataType x, size_t index);//查找数据x，并返回下标
TAG Erase(SeqList* pSeq, DataType x, TAG all); //all等于TURE表示删除所有x
                                              //all等于FALSE表示删除第一个x
void Destorycapacity(SeqList* pSeq);
void BubbleSort(SeqList* pSeq); //冒泡排序
void SelectSort(SeqList* pSeq); //选择排序
Findret BinarySearch(SeqList* pSeq, DataType x);//二分搜索，在已将排好序的数组中进行搜索

#endif  //_SEQ_LIST

seqlist.c

#include"seqlist.h"


void InitSeqList(SeqList* pSeq)
{
    assert(pSeq);
    pSeq->arr = (DataType*)malloc(DEFAULT_CAPACITY * sizeof(DataType));
    pSeq->size = 0;
    pSeq->capacity = DEFAULT_CAPACITY;
}
void PrintSeqList(SeqList* pSeq)
{
    int i = 0;
    assert(pSeq);
    for (; i < pSeq->size; i++)
    {
        printf("%d ", pSeq->arr[i]);
    }

    printf("\n");
}
void Cheekcapacity(SeqList* pSeq)
{
    if ((pSeq->size) == pSeq->capacity) //判断链表是否已满
    {
        DataType* tmp = malloc(pSeq->capacity * 2 * sizeof(DataType));
        pSeq->capacity = pSeq->capacity * 2;
        memcpy(tmp, pSeq->arr, sizeof(DataType)* pSeq->size);
        free(pSeq->arr);
        pSeq->arr = tmp;
    }
}
void PushBack(SeqList* pSeq, DataType x)
{
    assert(pSeq);
    Cheekcapacity(pSeq);

    pSeq->arr[(pSeq->size)++] = x;
}

void PopBack(SeqList* pSeq)
{
    assert(pSeq);
    if (pSeq->size == 0)
    {
        printf("SeqList is empty\n");
        return;
    }
    pSeq->arr[--(pSeq->size)] = 0; //或者 --（pSeq->size);
}
void PushFront(SeqList* pSeq, DataType x)
{
    int i = 0;
    assert(pSeq);
    Cheekcapacity(pSeq);
    for (i = pSeq->size; i > 0; i--)
    {
        pSeq->arr[i] = pSeq->arr[i - 1];
    }
    pSeq->arr[0] = x;
    ++(pSeq->size);
}
void PopFront(SeqList* pSeq)
{
    int i = 0;
    assert(pSeq);
    if (pSeq->size == 0)
    {
        printf("SeqList is empty\n");
        return;
    }
    for (; i < pSeq->size; i++)
    {
        pSeq->arr[i] = pSeq->arr[i + 1];

    }
    (pSeq->size)--;
}
void Insert(SeqList* pSeq, size_t index, DataType x)
{
    int i = 0;
    assert(pSeq);
    assert(index <= pSeq->size);
    Cheekcapacity(pSeq);

    for (i = pSeq->size; i > index; i--)
    {
        pSeq->arr[i] = pSeq->arr[i - 1];
    }
    pSeq->arr[index] = x;
    (pSeq->size)++;
}
void Modified(SeqList* pSeq, size_t index, DataType x)
{
    assert(pSeq);
    assert(index < pSeq->size);
    pSeq->arr[index] = x;
}
void removed(SeqList* pSeq, size_t index)
{

    assert(pSeq);
    assert(index <= pSeq->size);
    for (; index < pSeq->size; index++)
    {
        pSeq->arr[index] = pSeq->arr[index + 1];
    }
    (pSeq->size)--;
}

Findret  Find(SeqList* pSeq, DataType x, size_t index)
{
    Findret ret;
    assert(pSeq);
    for (; index < pSeq->size; index++)
    {
        if (pSeq->arr[index] == x)
        {
            ret.Isfind = TRUE;
            ret.index = index;
            return ret;
        }
    }
    ret.Isfind = FALSE;
    return ret;
}
TAG Erase(SeqList* pSeq, DataType x, TAG all)
{
    TAG success = FALSE;
    Findret ret;
    assert(pSeq);
    ret = Find(pSeq, x, 0);
    while (ret.Isfind == TRUE)
    {
        success = TRUE;
        removed(pSeq, ret.index);
        pSeq->size--;
        if (all == FALSE)
        {
            break;
        }
        ret = Find(pSeq, x, ret.index);
    }
    return success;

}

void swap(DataType* l, DataType* r)
{
    DataType tmp = *l;
    *l = *r;
    *r = tmp;
}
void BubbleSort(SeqList* pSeq)
{
    int i = 0;
    int j = 0;
    int exchange = 0;  //优化减少循环次数
    assert(pSeq);
    for (i = 0; i < pSeq->size; i++)
    {
        for (j = 0; j < pSeq->size - i - 1; j++)
        {
            exchange = 0;
            if (pSeq->arr[j] > pSeq->arr[j + 1])
            {
                swap(&pSeq->arr[j], &pSeq->arr[j + 1]);
                exchange = 1;
            }

        }
        if (exchange == 0) //没有进行一次交换，已经排好序
            {
                break;
            }
    }
}
void SelectSort(SeqList* pSeq)
{
    size_t minindex, index, begin;
    for (begin = 0; begin < pSeq->size - 1; begin++)
    {
        minindex = begin;
        for (index = begin + 1; index < pSeq->size; index++)
        {
            if (pSeq->arr[minindex] > pSeq->arr[index])
            {
                minindex = index; //找到最小的数的下标
            }
        }
        if (minindex != begin)
        {
            swap(&pSeq->arr[minindex], &pSeq->arr[begin]);//把最小的数放到最前面
        }

    }
}
//Findret BinarySearch(SeqList* pSeq, DataType x)
//{
//  size_t left, right, mid;
//  Findret ret ;
//  ret.Isfind = FALSE;
//  left = 0;
//  right = pSeq->size - 1;
//  while (left <= right)
//  {
//      //mid = (left + right) / 2; 
//      // 当left&right都大于无符号整形的一半的时候，相加就溢出了
//      mid = left + (right - left) / 2; //or mid = left + (right - left) >> 1;
//      if (pSeq->arr[mid] == x)
//      {
//          ret.Isfind = TRUE;
//          ret.index = mid;
//          return ret;
//      }
//      else if (pSeq->arr[mid] > x)
//      {
//          right = mid - 1;
//      }
//      else
//      {
//          left = mid + 1;
//      }
//  }
//  return ret;
//}

Findret BinarySearch(SeqList* pSeq, size_t begin, size_t end, DataType x)//递归二分搜索
{
    size_t mid = begin + (end - begin) / 2;
    Findret ret;
    ret.Isfind = FALSE;
    if (begin == end && pSeq->arr[begin] != x)//没找到x
    {
        return ret;
    }
    if (pSeq->arr[mid] > x)
    {
        BinarySearch(pSeq, begin, mid - 1, x);
    }
    else if (pSeq->arr[mid] < x)
    {
        BinarySearch(pSeq, mid + 1, end, x);
    }
    else //pSeq->arr[mid] = x 找到x
    {
        ret.Isfind = TRUE;
        ret.index = mid;
        return ret;
    }
}

void Destorycapacity(SeqList* pSeq)
{
    assert(pSeq);
    free(pSeq->arr);
    pSeq->size = 0;
    pSeq->capacity = 0;
}

test.c

#include"seqlist.h"

void test()
{
    SeqList s;
    InitSeqList(&s);
    PushBack(&s, 1);
    PushBack(&s, 2);
    PushBack(&s, 3);
    PushBack(&s, 4);
    PopBack(&s);
    PushFront(&s, 10);
    PopFront(&s);
    Insert(&s, 2, 10);
    Modified(&s, 3, 11);
    removed(&s, 1);
    PrintSeqList(&s);

}

void test2()
{
        SeqList s;
        InitSeqList(&s);
        Insert(&s, 0, 0);
        Insert(&s, 1, 1);
        Insert(&s, 2, 2);
        Insert(&s, 3, 2);
        Insert(&s, 4, 3);
        Insert(&s, 5, 2);
        PrintSeqList(&s);

        Erase(&s, 2, FALSE);
        PrintSeqList(&s);

        Erase(&s, 2, TRUE);
        PrintSeqList(&s);
        Destorycapacity(&s);
}
void test3()
{
    SeqList s;
    Findret ret;
    int x;
    InitSeqList(&s);
    Insert(&s, 0, 0);
    Insert(&s, 1, 1);
    Insert(&s, 2, 2);
    Insert(&s, 3, 2);
    Insert(&s, 4, 3);
    Insert(&s, 5, 2);
    BubbleSort(&s);
    //SelectSort(&s);
    PrintSeqList(&s);
    x = 1;
    ret = BinarySearch(&s,0,s.size - 1 ,1);
    if (ret.Isfind == TRUE)
    {
        printf("find %d,index=%d\n", x, ret.index);
    }
    else
    {
        printf("not find\n");
    }


}

int main()
{

    test();
    test2();
    test3();
    getchar();
    return 0;
}
yangrujing
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言实现动态顺序表的实现代码
12-31
C语言实现动态顺序表的实现代码 顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。线性表采用顺序存储的方式存储就称之为顺序表。顺序表是将表中的结点...
C语言实现动态顺序表
ljx_5489464的博客
03-14 2245
1、用于存放声明的头文件#pragma once //避免重复引入头文件，作用于预编译指令几乎相同#define _CRT_SECURE_NO_WARNINGS 1 #include <stdio.h> #include <assert.h> #include <malloc.h>typedef int DataType; typedef struct SepList_d { DataTy
实现动态顺序表
Lsxlsxls(*^▽^*)
10-10 503
静态顺序表和动态顺序表之间的区别就是静态顺序表的存储大小一旦设定好之后便不能修改；显然动态顺序表采用的是动态分配内存，容量是可以增加的，当然动态顺序表要比静态顺序表多增加一个监测容量的参数，每当当前容量存满的时候就要触发扩容机制，实现动态开辟内存。由于两者差别不是很大，这里我就只实现动态顺序表，静态的基本一样，只是少了扩容机制。（这里我设置的初始容量为3，便于我们观察扩容机制） 现将动态顺序表的实...
C++实现动态顺序表
08-19
主要为大家详细介绍了C++实现动态顺序表，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
数据结构动态顺序表的初始化
最新发布
03-13
动态顺序表是一种数据结构，它可以根需要动态地调整存储空间的大小。初始化一个动态顺序表过程如下： 1. 首先，需要定义一个结构体来表示动态顺序表，该结构体包含两个成员变量：data（用于存储数据元素的数组）和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值