实现静态顺序表

于 2018-03-23 23:17:09 发布
阅读量287 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/asliband/article/details/79673817
本文详细介绍了如何实现静态顺序表，包括头文件`seqlist.h`的定义，`.c`源文件中实现的主要操作，以及`test.c`进行的测试案例，通过实例展示了静态顺序表的创建、插入、删除和查找等基本操作。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

//seqlist.h

#pragma once
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<assert.h>

#define MAX_SIZE 10 //数组元素的个数
typedef unsigned int size_t;
typedef int DataType; //定义数组类型

typedef struct Seqlist
{
 DataType _arry[MAX_SIZE]; //创建一个数组
 int _size; //顺序表中有效元素的个数
}SeqList, *PSeqList; //PSeqList是一个自定义变量类型，该类型为指向结构体的指针
void SeqListlnit(PSeqList ps);//初始化
void SeqListPushBack(PSeqList ps, DataType data);//尾插
void SeqListPopBack(PSeqList ps);//尾删
void SeqListPushFront(PSeqList ps, DataType data);//头插
void SeqListPopFront(PSeqList ps);//头删
void SeqListInsert(PSeqList ps, size_t pos, DataType data);//任意位置中插入值为data的元素
void SeqListErase(PSeqList ps, size_t pos);//删除任意位置中的元素
int SeqListFind(PSeqList ps, DataType data);// 在顺序表中查找值为data的元素，返回该元素在顺序表中的下标
void SeqListRemove(PSeqList ps, DataType data); // 删除顺序表中值为data的元素
void SeqListRemoveAll(PSeqList ps, DataType data);//删除顺序表中所有值为data的元素
int SeqListEmpty(PSeqList ps);//判断顺序表是否为空
int SeqListSize(PSeqList ps);// 获取顺序表中元素的个数
void PrintSeqList(PSeqList ps);// 打印顺序表中的元素
void BubbleSort(int* array, int size);// 用冒泡排序对顺序表中的元素进行排序
void SelectSort(int* array, int size);// 用选择排序对顺序表中的元素进行排序
void SelectSort_OP(int* array, int size);// 选择排序优化---一次找出最大最小元素所在的位置

 //.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"
void SeqListlnit(PSeqList ps) //初始化
{
 assert(ps != NULL); //确保ps不等于空
 ps->_size = 0; 
 memset(ps->_arry, 0, sizeof(DataType)*MAX_SIZE);
}
void SeqListPushBack(PSeqList ps, DataType data) //尾插
{
 assert(ps!=NULL);
 if (ps->_size == MAX_SIZE)
 {
  return;
 }
 ps->_arry[ps->_size] = data;
 ps->_size++;
}
void SeqListPopBack(PSeqList ps)//尾删
{
 assert(ps != NULL);
 if (ps->_size == 0)
 {
  return;
 }
 ps->_size--;
}
void SeqListPushFront(PSeqList ps, DataType data)//头插
{
 assert(ps != NULL);
 if (ps->_size == MAX_SIZE)
 {
  return;
 }
 int i;
 for (i = ps->_size - 1; i >= 0; i--)
 {
  ps->_arry[i+1] = ps->_arry[i];
 }
 ps->_size++;
}
void SeqListPopFront(PSeqList ps)//头删
{
 assert(ps != NULL);
 if (ps->_size == 0)
 {
  return;
 }
 int i;
 for (i = 1; i < ps->_size; i++)
 {
  ps->_arry[i-1] = ps->_arry[i];
 }
 ps->_size--;
}
void SeqListInsert(PSeqList ps, size_t pos, DataType data)//任意位置中插入值为data的元素
{
 assert(ps != NULL);
 if (ps->_size == MAX_SIZE)
 {
  return;
 }
 int i;
 for (i = ps->_size-1; i >= pos; i--)
 {
  ps->_arry[i+1] = ps->_arry[i];
 }
 ps->_arry[pos] = data;
 ps->_size++;
}
void SeqListErase(PSeqList ps, size_t pos)//删除任意位置中的元素
{
 assert(ps != NULL);
 if (ps->_size == 0)
 {
  return;
 }
 int i;
 for (i = pos; i < ps->_size-1; i++)
 {
  ps->_arry[i] = ps->_arry[i+1];
 }
 ps->_arry[ps->_size-1] == 0;
 ps->_size--;
}
int SeqListFind(PSeqList ps, DataType data)// 在顺序表中查找值为data的元素，返回该元素在顺序表中的下标
{
 assert(ps != NULL);
 int i;
 for (i = 0; i < ps->_size; i++)
 {
  if (ps->_arry[i] == data)
   return i;
 }
 return 0;
}
void SeqListRemove(PSeqList ps, DataType data)// 删除顺序表中值为data的元素
{
 assert(ps != NULL);
 int i;
 for (i = 0; i < ps->_size; i++)
 {
  if (ps->_arry[i] == data)
   SeqListErase(ps, i);
  break;
 }
}
void SeqListRemoveAll(PSeqList ps, DataType data)//删除顺序表中所有值为data的元素
{
 assert(ps != NULL);
 int i;
 for (i = 0; i < ps->_size; i++)
 {
  if (ps->_arry[i] == data)
   SeqListErase(ps, i);
  continue;
 }
}
int SeqListEmpty(PSeqList ps)//判断顺序表是否为空
{
 if (ps == NULL)
  return 1;
 return 0; 
}
int SeqListSize(PSeqList ps)// 获取顺序表中元素的个数
{
 if (ps == NULL)
  return 0;
 return ps->_size;
}
void PrintSeqList(PSeqList ps)// 打印顺序表中的元素
{
 assert(ps != NULL);
 int i;
 for (i = 0; i < ps->_size; i++)
 {
  printf("%d", ps->_arry[i]);
 }
}
void BubbleSort(int* array, int size)// 用冒泡排序对顺序表中的元素进行排序
{
 assert(size != NULL);
 int i=0;
 int j=0;
 int tmp = 0;
 for (; i < size; i++)
 {
  for (; j < size - i; j++)
  {
   if (array[j]>array[j + 1])
   {
    tmp = array[j];
    array[j] = array[j + 1];
    array[j + 1] = tmp;
   }
  }
 }
}
void SelectSort(int* array, int size)// 用选择排序对顺序表中的元素进行排序
// 用选择排序对顺序表中的元素进行排序</span> 
//初始序列：{49 27 65 97 76 12 38} 
//第1趟：12与49交换：12{ 27 65 97 76 49 38 } 
//第2趟：27不动　：12 27{65 97 76 49 38} 
//第3趟：65与38交换：12 27 38{97 76 49 65} 
//第4趟：97与49交换：12 27 38 49{76 97 65} 
//第5趟：76与65交换：12 27 38 49 65{97 76} 
//第6趟：97与76交换：12 27 38 49 65 76 97 完成
{
 int i=0;
 int j=0;
 int index=0;
 int ret = 0;
 for (; i < size - 1; i++)
 {
  index = i;
  for (j = i; j < size - 1; j++)
  {
   if (array[j] < array[index])
    index = j;
  }
 }
 if (index != i)
 {
  ret = array[index];
  array[index] = array[i];
  array[i] = ret;
 }
}
void swap(int *a, int *b)
{
    int p;
    p = *a;
    *a = *b;
    *b = p;

}
void SelectSort_OP(int* array, int size)// 选择排序优化---一次找出最大最小元素所在的位置
{
     int i = 0;
     int left = 0;
     int right = size - 1;
 
     while (left <= right)
     {
         int min = left;
         int max = right;
   for (i = left; i <= right; i++)
   {
    if (array[i]<array[min])
    {
     min = i;
    }
    if (array[i]>array[max])
    {
     max = i;
    }
   }
         swap(&array[left], &array[min]);
         if (left == max)//最大的在最小位置上,最小的在最大 
             max = min;
         swap(&array[right], &array[max]);
         left++;
         right--;
     }
}

 //test.c

#define _CRT_SECURE_NO_WARNINGS 1
#include"seqlist.h"

int main()
{
     SeqList s;
  SeqListlnit(&s); // 初始化顺序表  
 
     SeqListPushBack(&s, 1); // 在顺序表的尾部插入元素data  
     SeqListPushBack(&s, 2);
     SeqListPushBack(&s, 3);
     SeqListPushBack(&s, 4);
     SeqListPushBack(&s, 5);
     PrintSeqList(&s);
 
     SeqListInsert(&s, 2, 6); // 在顺序表的pos位置插入元素data  
     PrintSeqList(&s);
 
     SeqListErase(&s, 2); // 删除顺序表pos位置上的元素  
     PrintSeqList(&s);
 
     SeqListInsert(&s, 3, 4); // 在顺序表的pos位置插入元素data  
     PrintSeqList(&s);
 
  SeqListRemoveAll(&s, 4); //删除顺序表中所有值为data的元素 
     PrintSeqList(&s);
 
     SeqListPopBack(&s); // 删除顺序表尾部的元素  
     PrintSeqList(&s);
 
     SeqListPushFront(&s, 0); // 在顺序表的头部插入元素data  
     PrintSeqList(&s);
 
     SeqListPopFront(&s); // 删除顺序表头部元素  
     PrintSeqList(&s);
 
  int pos = SeqListFind(&s, 2); //查找顺序表中第一个值为data的元素 
     printf("pos = %d\n", pos);
 
  SeqListRemove(&s, 2);//删除顺序表中第一个值为data的元素 
     PrintSeqList(&s);
 
     SeqListPopBack(&s);// 删除顺序表尾部的元素  
     SeqListPopBack(&s);
 
     SeqListPushBack(&s, 10); // 在顺序表的尾部插入元素data  
     SeqListPushBack(&s, 2);
     SeqListPushBack(&s, 4);
     SeqListPushBack(&s, 3);
     SeqListPushBack(&s, 1);
     SeqListPushBack(&s, 5);
     SeqListPushBack(&s, 7);
     SeqListPushBack(&s, 8);
     SeqListPushBack(&s, 9);
     SeqListPushBack(&s, 6);
     PrintSeqList(&s);
 
     //BubbleSort(&s); //对顺序表进行冒泡排序操作 
     //SelectSort(&s); //对顺序表进行选择排序操作 
     //PrintSeqList(&s);


  printf("pos = %d\n", pos);

     system("pause");
     return 0;
}

 

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值