顺序表

#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;
}