顺序表操作与排序算法-优快云博客

本文介绍了一种基于数组实现的顺序表数据结构，并提供了多种基本操作如插入、删除等的实现方法。此外，还实现了几种排序算法，包括冒泡排序、选择排序及其优化版本，以及二分查找算法。

摘要生成于 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;
}