顺序表

于 2017-09-13 21:41:39 发布
阅读量175 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Adoiphs/article/details/77971459
本文介绍了一种基于数组实现的顺序表数据结构，并提供了多种基本操作如插入、删除等的实现方法。此外，还实现了几种排序算法，包括冒泡排序、选择排序及其优化版本，以及二分查找算法。

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

#include<string.h>
typedef int DataType;
#define N 100
typedef  struct SeqList
{
 DataType array[N];
 size_t size;
}SeqList;
void InitSeqList(SeqList* s);
void PrintSeqList(SeqList* s);
void PushBack(SeqList* s, DataType x);
void PopBack(SeqList* s);
void PushFront(SeqList* s,DataType x);
void PopFront(SeqList* s);
void Insert(SeqList* s, size_t pos, DataType x);
void Erase(SeqList* s, size_t pos);
int  Find(SeqList* s, DataType x);
void Modify(SeqList* s, size_t pos, DataType x);
int  Remove(SeqList* s, DataType x);
int  RemoveAll(SeqList* s, DataType x);
void BubbleSort(SeqList* s);
void SelectSort(SeqList* s);
void SelectSort_OP(SeqList* s);
int  BinarySearch(SeqList* s, DataType x);
#include<stdio.h>
#include<assert.h>
#include"test.h"
void InitSeqList(SeqList* s)
{
 memset(s->array, 0, sizeof(DataType)*N);
 s->size = 0;
}
void PrintSeqList(SeqList* s)
{
 for (size_t i = 0; i < s->size; ++i)
 {
  printf("%d ", s->array[i]);
 }
 printf("\n");
}
void PushBack(SeqList* s, DataType x)
{
 assert(s);
 if (s->size == N)
 {
  printf("SeqList is Full!");
  return;
 }
 s->array[s->size] = x;
 s->size++;
}
void PopBack(SeqList* s)
{
 assert(s);
 if (s->size == 0)
 {
  printf("SeqList is Empty!");
  return;
 }
 //s->array[s->size-1] = 0;
 s->size--;
}
void PushFront(SeqList* s, DataType x)
{
 int end = s->size - 1;
 assert(s);
 if (s->size == N)
 {
  printf("SeqList is Full!");
  return;
 }
 for (; end >= 0; --end)
 {
  s->array[end + 1] = s->array[end];
 }
 s->array[0] = x;
 s->size++;
}
void PopFront(SeqList* s)
{
 size_t i = 0;
 assert(s);
 if (s->size == 0)
 {
  printf("SeqList is Empty!");
  return;
 }
 for (; i < s->size - 1; ++i)
 {
  s->array[i] = s->array[i+1];
 }
 s->size--;
}
void Insert(SeqList* s, size_t pos, DataType x)
{
 size_t end = s->size;
 assert(s);
 assert(pos <= s->size);
 if (s->size == N)
 {
  printf("SeqList is Full\n");
  return;
 }
 for (; end > pos; --end)
 {
  s->array[end ] = s->array[end-1];
 }
 s->array[pos] = x;
 s->size++;
}
void Erase(SeqList* s, size_t pos)
{
 size_t end = pos;
 assert(s);
 assert(pos < s->size);
 for (; end < s->size - 1; ++end)
 {
  s->array[end] = s->array[end + 1];
 }
 s->size--;
}
int  Find(SeqList* s, DataType x)
{
 size_t i = 0;
 assert(s);
 for (; i < s->size; ++i)
 {
  if (s->array[i] == x)
  {
   return i;
  }
 }
 return -1;
}
void Modify(SeqList* s, size_t pos, DataType x)
{
 assert(s);
 assert(pos < s->size);
 s->array[pos] = x;
}
int  Remove(SeqList* s, DataType x)
{
 int pos;
 assert(s);
 pos = Find(s, x);
 if (pos != -1)
 {
  Erase(s,pos);
  return 0;
 }
 else
 {
  return -1;
 }
}
int  RemoveAll(SeqList* s, DataType x)
{
 size_t i = 0;
 size_t j = 0;
 while (i < s->size)
 {
  if (s->array[i] != x)
  {
   s->array[j] = s->array[i];
   ++j;
  }
  ++i;
 }
 s->size = j;
 return i == j ? -1 : 0;
}
void Swap(DataType* left, DataType* right)
{
 DataType tmp = *left;
 *left = *right;
 *right = tmp;
}
void BubbleSort(SeqList* s)
{
 size_t start = 0;
 size_t end;
 assert(s);
 for (end = s->size; end > 0; --end)
 {
  int exchange = 0;
  while (start + 1 < end)
  {
   if (s->array[start] > s->array[start + 1])
   {
    Swap(s->array + start, s->array + start + 1);
    exchange = 1;
   }
   ++start;
  }
  if (exchange == 0)
  {
   break;
  }
 }
}
void SelectSort(SeqList* s)
{
 size_t start = 0;
 assert(s);
 for (; start < s->size; ++start)
 {
  size_t i = start;
  size_t min = start;
  for (; i < s->size; ++i)
  {
   if (s->array[min]>s->array[i])
   {
    min = i;
   }
  }
  Swap(s->array+start, s->array+min);
 }
}
void SelectSort_OP(SeqList* s)
{
 size_t start = 0, finish = s->size - 1;
 assert(s);
 while (start < finish)
 {
  size_t i = start;
  size_t min = start, max = start;
  while (i <= finish)
  {
   if (s->array[i] < s->array[min])
   {
    min = i;
   }
   if (s->array[i]>s->array[max])
   {
    max = i;
   }
   Swap(s->array + start, s->array + min);
   if (start == max)
   {
    max = min;
   }
   Swap(s->array + finish, s->array + max);
   start++;
   finish--;
  }
 }
}
int  BinarySearch(SeqList* s, DataType x)
{
 int left = 0, right = s->size-1;
 while (left <= right)
 {
  int mid = left + (right - left) / 2;
  if (s->array[mid] > x)
  {
   right = mid-1;
  }
  else if (s->array[mid] < x)
  {
   left = mid + 1;
  }
  else
  {
   return mid;
  }
 }
 return -1;
}
//PushBack\PopBack
void TestSeqList1()
{
 SeqList s;
 InitSeqList(&s);
 PushBack(&s, 0);
 PushBack(&s, 1);
 PushBack(&s, 2);
 PushBack(&s, 3);
 PushBack(&s, 4);
 PrintSeqList(&s);
 PopBack(&s);
 PopBack(&s);
 PopBack(&s);
 PrintSeqList(&s);
}
//PushFront\PopFront
void TestSeqList2()
{
 SeqList s;
 InitSeqList(&s);
 PushFront(&s, 1);
 PushFront(&s, 2);
 PushFront(&s, 3);
 PushFront(&s, 4);
 
 PrintSeqList(&s);
 PopBack(&s);
 PopBack(&s);
 PopBack(&s);
 PrintSeqList(&s);
}
void TestSeqList3()
{
 int ret = 0;
 int win = 0;
 SeqList s;
 InitSeqList(&s);
 PushBack(&s, 0);
 PushBack(&s, 1);
 PushBack(&s, 2);
 PushBack(&s, 3);
 PushBack(&s, 4);
 PrintSeqList(&s);
 Insert(&s, 2, 7);
 Insert(&s, 0, -1);
 PrintSeqList(&s);
 Erase(&s, 2);
 PrintSeqList(&s);
    ret = Find(&s, 3);
 printf("%d\n", ret);
 Modify(&s, 3, 5);
 PrintSeqList(&s);
 win = Remove(&s, 3);
 printf("%d\n", win);
 PrintSeqList(&s);
}
void TestSeqList4()
{
 int ret = 0;
 SeqList s;
 InitSeqList(&s);
 PushBack(&s, 0);
 PushBack(&s, 1);
 PushBack(&s, 2);
 PushBack(&s, 3);
 PushBack(&s, 2);
 PushBack(&s, 4);
 PushBack(&s, 2);
 PushBack(&s, 2);
 PrintSeqList(&s);
    RemoveAll(&s, 2);
 PrintSeqList(&s);
}
void TestSeqList5()
{
 SeqList s;
 InitSeqList(&s);
 PushBack(&s, 0);
 PushBack(&s, 1);
 PushBack(&s, 2);
 PushBack(&s, 5);
 PushBack(&s, 4);
 PushBack(&s, 3);
 PushBack(&s, 8);
 PushBack(&s, 7);
 PushBack(&s, 6);
 PrintSeqList(&s);
 SelectSort_OP(&s);
 //SelectSort(&s);
 PrintSeqList(&s);
 //BubbleSort(&s);
 //PrintSeqList(&s);
}
void TestSeqList6()
{
 SeqList s;
 int ret;
 InitSeqList(&s);
 PushBack(&s, 1);
 PushBack(&s, 2);
 PushBack(&s, 3);
 PushBack(&s, 4);
 PushBack(&s, 5);
 PrintSeqList(&s);
 ret = BinarySearch(&s,2);
 printf("%d\n", ret);
}
int main()
{
 //TestSeqList1();
 //TestSeqList2();
 //TestSeqList3();
 //TestSeqList4();
 //TestSeqList5();
   TestSeqList6();
 return 0;
}

Adoiphs
关注
C语言实现动态顺序表的实现代码
08-29
C语言实现动态顺序表的实现代码 本文主要介绍了C语言实现动态顺序表的实现代码，动态顺序表是指在内存中开辟一块空间，可以随我们数据数量的增多来扩容的线性表。下面将详细介绍动态顺序表的实现代码。 一、顺序表...
PTA—C语言数据结构：顺序表.ppt
10-11
本文件"PTA—C语言数据结构：顺序表.ppt"是针对PTA（Programming Training Assistant）平台上数据结构课程的一个教学资源，专门探讨了顺序表这一基本数据结构，并提供了相关练习题的解答。下面我们将详细讨论顺序表...
头歌数据结构顺序表的基本操作1-6关
05-18
【顺序表】是一种基本的数据结构，它在计算机科学中被广泛使用，特别是在处理大量有序或无序数据时。顺序表的实现通常是通过数组来完成的，数组中的元素按顺序存储，便于快速访问和操作。本题涉及顺序表的六种基本...
shunxubiao.rar_shunxubiao_输入一组整型元素序列，建立顺序表
09-19
输入一组整型元素序列，建立顺序表。 (2)．实现该顺序表的遍历。 (3)．在该顺序表中顺序查找某一元素,查找成功返回1,否则返回0。 (4)．判断该顺序表中元素是否对称,对称返回1,否则返回0。 (5)．实现把该表中所有奇数...
顺序表和链表.pdf
最新发布
04-24
### 顺序表与链表详解 #### 一、概述 本文档主要介绍顺序表和链表这两种基本的数据结构。在计算机科学中，数据结构是指在计算机中组织和存储数据的一种特殊方式，它允许高效地访问和修改数据。顺序表和链表作为...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值