静态顺序表实现

SeqList.h文件
  
#pragma once
#define MAX_SIZE 1000
typedef int DataType;
typedef unsigned int size_t;
typedef struct SeqList
{
 DataType array[MAX_SIZE];
 size_t size;
}SeqList;
 
void InitSeqList(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 pos, DataType x);
int Find(SeqList* pSeq, DataType x);
void Erase(SeqList* pSeq, size_t x);
int Remove(SeqList* pSeq, DataType x);
int RemoveAll(SeqList* pSeq, DataType x);
void BubbleSort(SeqList* pSeq);
void SelectSort(SeqList* pSeq);
int BinarySearch(SeqList* pSeq, DataType x);
void PrintSeqList(SeqList* pSeq);

SeqList.c文件

#include "SeqList.h"
#include <stdio.h>
#include <string.h>
#include <assert.h>
void InitSeqList(SeqList* pSeq)
{
 memset(pSeq->array, 0, sizeof(DataType) * MAX_SIZE);
 pSeq->size = 0;
}
//
//1.检查参数
//2.检查边界条件
//3.实现函数功能
//
void PushBack(SeqList* pSeq,DataType x)
{
 assert(pSeq);
 if(pSeq ->size >= MAX_SIZE)
 {
  printf("SeqList is fulled\n");
  return;
 }
 else
 {
  pSeq ->array[pSeq -> size++] = x;
 }
}
void PopBack(SeqList* pSeq)
{
 assert(pSeq);
 if(pSeq ->size == 0)
 {
  printf("SeqList is Empty\n");
  return;
 }
 else
 {
  pSeq -> array[pSeq -> size] = 0;
  pSeq -> size --;
 }
}
void PushFront(SeqList* pSeq, DataType x)
{
 size_t i = pSeq ->size;
 assert(pSeq);
 while(i > 0)
 {
  pSeq -> array[i] = pSeq->array[i - 1];
  i--;
 }
 pSeq ->array[0] = x;
 pSeq ->size++;
}
void PopFront(SeqList* pSeq)
{
 size_t i = 1;
 assert(pSeq);
 while(i <= pSeq->size - 1)
 {
  pSeq -> array[i - 1] = pSeq->array[i];
  i++;
 }
 pSeq ->array[pSeq->size - 1] = 0;
 pSeq ->size--;
}
void Insert(SeqList* pSeq, size_t pos, DataType x)
{
 int i = (int)pSeq ->size - 1;
 assert(pSeq);
 assert(pos >= 0 && pos <= pSeq->size);
 while(pos <= i && i >= 0) //i >= 0;解决问题 ：0位置插入
 {
  pSeq ->array[i + 1] = pSeq ->array[i];
  i--;
 }
 pSeq ->array[pos] = x;
 pSeq ->size++;
}
int Find(SeqList* pSeq, DataType x)
{
 int i = pSeq->size - 1;
 assert(pSeq);
 while(i >= 0)
 {
  if(pSeq->array[i] == x)
  {
   return i;
  }
  i--;
 }
 return -1;
}
void Erase(SeqList* pSeq, size_t x) //将第几个数删除 0始 
{
 int i = x;
 assert(pSeq);
 assert(x >= 0 && x < pSeq->size);
 while(i < pSeq->size - 1)
 {
  pSeq->array[i] = pSeq->array[i + 1];
  i++;
 }
 pSeq->size--;
}
int Remove(SeqList* pSeq, DataType x)
{
 int i = 0;
 assert(pSeq);
 while(i < pSeq->size)
 {
  if(pSeq->array[i] == x)
  {
   Erase(pSeq, i);
   return i;
  }
  i++;
 }
 return -1;
}
int RemoveAll(SeqList* pSeq, DataType x)
{
 int count = 0;
 int i = 0;
 while(i < pSeq->size)
 {
  if(pSeq->array[i] == x)
  {
   count++;
  }
  else
  {
   pSeq->array[i - count] = pSeq->array[i];
  }
  i++;
 }
 pSeq->size -= count;
 return count;
}
void BubbleSort(SeqList* pSeq)
{
 int i = 0;
 int j = 0;
 assert(pSeq);
 for(i = 0;i < pSeq->size - 1; i++)
  for(j = 0; j < pSeq->size - 1 - i; j++)
  {
   if(pSeq->array[j] > pSeq->array[j + 1])
   {
    int tmp = pSeq->array[j + 1];
    pSeq->array[j + 1] = pSeq->array[j];
    pSeq->array[j] = tmp;
   }
  }
}
void SelectSort(SeqList* pSeq)//一次选出最大最小的数据分别放在序列两边
{
 int left = 0;
 int right = pSeq->size - 1;
}
int BinarySearch(SeqList* pSeq, DataType x)
{
 int left = 0;
 int right = pSeq->size - 1;
 assert(pSeq);
 while(left <= right)
 {
  int mid = left + (right - left) / 2;
  if(x < pSeq->array[mid])
  {
   right = mid - 1;
  }
  else if(x > pSeq->array[mid])
  {
   left = mid + 1;
  }
  else
   return mid;
  mid = left + (right - left) / 2;
 }
 return -1;
}

void PrintSeqList(SeqList* pSeq)
{
 int i = 0;
 assert(pSeq);
 while(i < pSeq ->size)
 {
  printf("%d -> ",pSeq -> array[i]);
  i++;
 }
}

text.c文件
 
#include "SeqList.h"
#include <stdio.h>
#include <stdlib.h>
void test1()
{
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 4);
 PopBack(&seq);
 PopBack(&seq);
 PopBack(&seq);
 PopBack(&seq);
 PopBack(&seq);
 PrintSeqList(&seq);
}
void test2()
{
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 4);
 PushFront(&seq, 1);
 PopFront(&seq);
 PrintSeqList(&seq);
}
void test3()
{
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);

PushBack(&seq, 3);
 PushBack(&seq, 4);
 //Insert(&seq,0,5);
 Insert(&seq,4,5);
 PrintSeqList(&seq);
}
void test4()
{
 int ret;
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 4);
 
 ret = Find(&seq, 4);
 if(ret >= 0)
 {
  printf("pos:%d\n", ret);
 }
 else
 {
  printf("No Exit!\n");
 }
}
void test5()
{
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 4);
 //Erase(&seq, 0);
 Erase(&seq, 3);
 PrintSeqList(&seq);
}
void test6()
{
 int ret;
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 4);
 //ret = Remove(&seq, 3);
 ret = Remove(&seq, 5);
 if(ret < 0)
 {
  printf("No Exit!\n");
 }
 PrintSeqList(&seq);
}
void test7()
{
 int ret;
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 2);
 PushBack(&seq, 4);
 PushBack(&seq, 2);
 ret = RemoveAll(&seq, 2);
 //ret = RemoveAll(&seq, 5);
 if(ret == 0)
 {
  printf("No Exit!\n");
 }
 PrintSeqList(&seq);
}
void test8()
{
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 7);
 PushBack(&seq, 2);
 PushBack(&seq, 6);
 PushBack(&seq, 3);
 PushBack(&seq, 5);
 PushBack(&seq, 4);
 PushBack(&seq, 1);
 BubbleSort(&seq);
 PrintSeqList(&seq);
}
void test9()
{
 int ret = 0;
 SeqList seq;
 InitSeqList(&seq);
 PushBack(&seq, 1);
 PushBack(&seq, 2);
 PushBack(&seq, 3);
 PushBack(&seq, 4);
 PushBack(&seq, 5);
 PushBack(&seq, 6);
 PushBack(&seq, 7);
 //ret = BinarySearch(&seq, 1);
 //ret = BinarySearch(&seq, 8);
 //ret = BinarySearch(&seq, 4);
 ret = BinarySearch(&seq, 5);
 if(ret < 0)
  printf("No Exit!\n");
 else
  printf("%d\n", ret);
 PrintSeqList(&seq);
}
int main()
{
 //test1();
 //test2();
 //test3();
 //test4();
 //test5();
 //test6();
 //test7();
 //test8();
 test9();
 system("pause");
 return 0;
}

时间： 2024-08-24 17:25:34

静态顺序表实现的相关文章

【C++】模版类实现普通类静态顺序表

在C或C++里,我们已经学会了如何实现一个静态顺序表了,那为何还要引入模版类来实现静态顺序表呢?首先,我们看,在未引入模版前,我们在C++里是这样定义一个静态顺序表的: typedef int DataType; //此时我定义的是int型 class SeqList { DataType* _array; size_t _size; size_t _capacity; } 我们若要定义char型或者其他类型的,可以采用typedef了,这就是使用typedef的优

c语言：【顺序表】静态顺序表的头插、头删

#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> #include<assert.h> #include<string.h> #define MAXSIZE 1000 typedef int DateType; typedef struct SeqList { DateType arr[MAXSIZE]; size_t size; }SeqList;

静态顺序表和动态顺序表

实现一个静态顺序表,首先,要定义一个保存数据的数组,保存在结构体中,用size来存储数组中的元素个数, typedef struct SeqList { DataType array[MAX_SIZE]; size_t size; }SeqList; 首先来实现一下静态顺序表的初始化函数,可以借用系统的memset函数来实现,开辟一块空间全部初始化为0,没有存入数据所以size也为0 void InitSeqList(SeqList *pSeq) { assert(pSeq); memset(p

C++实现静态顺序表的增删查改以及初始化

C++实现静态顺序表的增删查改顺序表:用一段地址连续的存储单元依s次存储数据元素的线性结构,是线性表的一种. //SeqList.h #pragma once #include <assert.h> #include <string.h> #define MAX_SIZE 5 typedef int DataType; //定义顺序表结构体 typedef struct SeqList { DataType array[MAX_SIZE]; //数据块数组 size_t siz

【C语言】静态顺序表和动态顺序表的实现

静态顺序表定义一张顺序表也就是在内存中开辟一段连续的存储空间,并给它一个名字进行标识.只有定义了一个顺序表,才能利用该顺序表存放数据元素,也才能对该顺序表进行各种操作. 有两种定义顺序表的方法:一是静态地定义一张顺序表:二是动态地生成一张顺序表. 静态地定义一张顺序表的方法与定义一个数组的方法类似.可以描述如下: #define MAX_SIZE 100 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE

C实现静态顺序表

#include <stdio.h> #include <assert.h> #include <string.h> //顺序表的静态存储 #define MAXSIZE 5 typedef int DataType; typedef struct SeqList { DataType array[MAXSIZE]; //数组大小 size_t size; //有效元素个数 }SeqList; void InitSeqList(SeqList

静态顺序表

实现尾部插入.尾部删除.头部插入.头部删除.任意位置插入.任意位置删除.排序.查找.反转等功能 #ifndef __SEQ_TABLE_S_H__ #define __SEQ_TABLE_S_H__ #define MAX 100 #include<stdio.h> #include<string.h> #include<stdlib.h> #include<assert.h> typedef int DataType; //创建结构体类型对象 typede

C实现的静态顺序表

顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构.线性表采用顺序存储的方式存储就称之为顺序表.顺序表是将表中的结点依次存放在计算机内存中一组地址连续的存储单元中. 顺序表的存储特点是:只要确定了起始位置,表中任一元素地址都可以求出. 在c中实现顺序表时,由于函数较多,所以把函数的实现放在头文件中,在主函数中进行单元函数测试. SequenceList_Static.h #ifndef __SE

【C语言】静态顺序表的实现（包括头插、头删、尾插、尾删、查找、删除指定位置）

#define _CRT_SECURE_NO_WARNINGS 1 #include<iostream> using namespace std; #include<assert.h> #define MAXSIZE 100 typedef int DataType; typedef struct SeqList { DataType _array[MAXSIZE]; size_t _size; }SeqList; void InitSeqList(SeqList*