静态和动态顺序表的实现(c语言)

原创 2016年06月01日 00:05:10

 

(一)静态顺序表的实现

 

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

 (二)动态顺序表的实现(简略:只有部分主要功能)

SeqList_D.h文件

#pragma once
typedef int DataType;
typedef unsigned size_t;
typedef struct SeqList_D
{
 DataType* array;          
//指向数据块的指针
 size_t size;              //当前数据数
 size_t capacity;          
//总容量
}SeqList_D;
void InitSeqList_D(SeqList_D* pseq_d);
int IsFullCapacity(SeqList_D* pseq_d);
int IsEmptyCapacity(SeqList_D* pseq_d);
void PushBack(SeqList_D* pseq_d,DataType data);
void PopBack(SeqList_D* pseq_d);
void PrintSeq(SeqList_D* pseq_d);
 
 
SeqList_D.c
#include "SeqList_D.h"
#include <stdio.h>
#include <malloc.h>
#include <assert.h>
void InitSeqList_D(SeqList_D* pseq_d)
{
 assert(pseq_d);
 pseq_d->array = (DataType*)malloc(sizeof(DataType) * 3);
 pseq_d->size = 0;
 pseq_d->capacity = 3;
}
void PushBack(SeqList_D* pseq_d,DataType data)
{
 assert(pseq_d);
 if(IsFullCapacity(pseq_d))//full
 {
  pseq_d->capacity = pseq_d->capacity * 2 + 3;
  pseq_d->array = (DataType*)realloc(pseq_d->array, sizeof(DataType) * pseq_d->capacity);
 }
 pseq_d->array[pseq_d->size++] = data;
}
int IsFullCapacity(SeqList_D* pseq_d)
{
 if(pseq_d->size >= pseq_d->capacity)
 {
  return 1;   //full
 }
 else
 {
  return 0;  
 }
}
int IsEmptyCapacity(SeqList_D* pseq_d)
{
 if(pseq_d->size <= 0)
 {
  return 1;   //empty
 }
 else
  return 0;
}
void PopBack(SeqList_D* pseq_d)
{
 if(IsEmptyCapacity)
 {
  printf("SeqList is Eempty");
  return;
 }
 else
 {
  pseq_d->size--;
 }
}
void PrintSeq(SeqList_D* pseq_d)
{
 int i = 0;
 for(;i < pseq_d->size; i++)
 {
  printf("%d->", pseq_d->array[i]);
 }
}

test.c 文件

 

#include <stdio.h>
#include <stdlib.h>
#include "SeqList_D.h"
void text1()
{
 SeqList_D s1;
 InitSeqList_D(&s1);
 PushBack(&s1, 1);
 PushBack(&s1, 2);
 PushBack(&s1, 3);
 PushBack(&s1, 4);
 PushBack(&s1, 5);
 PrintSeq(&s1);
}
int main()
{
 text1();
 system("pause");
 return 0;

 

 

版权声明:本文为博主原创文章,未经博主允许不得转载。

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

C语言
  • SuLiJuan66
  • SuLiJuan66
  • 2015年06月29日 19:31
  • 1520

C语言实现动态顺序表

1、用于存放声明的头文件#pragma once //避免重复引入头文件,作用于预编译指令几乎相同#define _CRT_SECURE_NO_WARNINGS 1 #include #inclu...
  • ljx_5489464
  • ljx_5489464
  • 2016年03月14日 13:33
  • 991

静态顺序表和动态顺序表 对比

静态顺序表的缺陷:静态顺序表显然就是里面的内存是一定的,不能改变的,所以定义的时候可以定义一个宏,然后定义一个数组,这样就可以在数组中存储信息,而且,还可以随时改变数组的大小。typedef int ...
  • jhcconan614
  • jhcconan614
  • 2016年12月30日 23:13
  • 179

c语言动态顺序表的实现

动态顺序表是在静态顺序表的基础上优化更改的 1.其中将静态顺序表中的数组数据类型改成了指针类型方便内存的开辟 2.多增加了一个容量的变量来表示顺序表的容量 3.初始化的时候需要给*data动态开辟空间...
  • IT_iverson
  • IT_iverson
  • 2017年07月28日 12:01
  • 304

数据结构的静态查找(C语言实现)

#include "string.h" #include "stdio.h" #include "string.h" #include "malloc.h" #define ERROR 0...
  • zhouyanldh
  • zhouyanldh
  • 2011年09月15日 17:41
  • 2670

动态顺序表-c语言实现

上一篇实现了顺序表的静态实现,那么有没有一种更为优化的实现方式呢? 当然有,仿照之前实现的通讯录,接下来我们来实现一下动态的顺序表~ SeqListD.h#ifndef __SEQLISTD_H...
  • dove1202ly
  • dove1202ly
  • 2017年07月28日 16:28
  • 70

【动态顺序表】 c语言的动态顺序表

动态顺序表: 容量不够时 自动增容(静态顺序表的改进)            动态顺序表的结构:typedef int DataType;typedef struct SeqList{ DataTyp...
  • zweina111
  • zweina111
  • 2016年08月15日 13:59
  • 92

C语言——静态顺序表常见操作

不用多说,直接贴代码 list.h 文件#ifndef __LIST_H__ #define __LIST_H__ #include #include #include #define Max_...
  • qq_36782456
  • qq_36782456
  • 2017年05月01日 13:25
  • 276

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

其实动态顺序表就是在静态顺序表的基础上进行修改的,动态顺序表的底层实现是一个指向动态数组;我们根据存储数据的个数,在原开辟内存的基础上扩容,提供多余的空间储存数据;这种办法,不会造成多余开辟空间,对空...
  • qq_37964547
  • qq_37964547
  • 2017年07月28日 18:31
  • 129

c语言实现动态顺序表

#include #include #include #include #include typedef int DataType; typedef struct Seqlist { DataTyp...
  • youngyoungla
  • youngyoungla
  • 2016年06月12日 12:46
  • 97
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:静态和动态顺序表的实现(c语言)
举报原因:
原因补充:

(最多只允许输入30个字)