利用C语言实现顺序表

利用C语言实现静态顺序表

//---------- 头文件#include "SeqList.h" --------------------

#pragma once

#include<stdio.h>
#include<stdlib.h>
#include<string.h>

#define MAX 100

//------------------ 定义数据类型 ----------------------------
typedef int DataType;

//------------ 线性表的静态分配顺序存储结构 ----------------
typedef struct SeqList
{
 DataType arr[MAX];
 int size;
}SeqList,*pSeqList;

//---------------------- 基本操作 ----------------------------
void InitSeqList(pSeqList pslist);                            //初始化
void PrintSeqList(SeqList slist);                              //打印顺序表
void PushBack(pSeqList pslist, DataType x);         //尾插
void PopBack(pSeqList pslist);                              //尾删
void PushFront(pSeqList pslist, DataType x);        //头插
void PopFront(pSeqList pslist);                             //头删
void Insert(pSeqList pslist, int pos, DataType x);  //插入
void Remove(pSeqList pslist,DataType x);            //删除
void RemoveAll(pSeqList pslist, DataType x);       //删除所有相同节点
int Find(pSeqList pslist,DataType x);                     //查找
void ReverseList(pSeqList pslist);                          //逆序
void SortList(pSeqList pslist);                                //排序
int BinarySearch(pSeqList pslist,DataType x);       //折半查找

//------------- 基本操作的实现 ---------------------------
#include "SeqList.h"

void InitSeqList(pSeqList pslist)//初始化
{
 memset(pslist->arr, 0, sizeof(pslist->arr));
 pslist->size = 0;
}

void PrintSeqList(SeqList slist)//打印顺序表
{
 int i = 0;
 for(i=0; i<slist.size; i++)
 {
  printf("%d ",slist.arr[i]);
 }
 printf("over\n");
}

void PushBack(pSeqList pslist, DataType x)//尾插
{
 if(pslist->size >= MAX)
 {
  printf("顺序表已满!");
 }
 pslist->arr[pslist->size] = x;
 pslist->size++;
}

void PopBack(pSeqList pslist)//尾删
{
 if(pslist->size == 0)
 {
  printf("顺序表为空!");
 }
 pslist->size--;
}

void PushFront(pSeqList pslist, DataType x)//头插
{
 int i=0;
 if(pslist->size >=MAX)
 {
  printf("顺序表已满!");
 }
 for(i = pslist->size; i > 0; i--)
 {
  pslist->arr[i] = pslist->arr[i-1];
 }
 pslist->arr[0] = x;
 pslist->size++;
}

void PopFront(pSeqList pslist)//头删
{
 int i=0;
 if(pslist->size == 0)
 {
  printf("顺序表为空");
 }
 for(i=0;i<pslist->size-1;i++)
 {
  pslist->arr[i] = pslist->arr[i+1];
 }
 pslist->size-- ;
}

void Insert(pSeqList pslist, int pos, DataType x) //插入
{
 int i=0;
 if(pslist->size >= MAX)
 {
  printf("顺序表已满!");
 }
 for(i=pslist->size;i>pos;i--)
 {
  pslist->arr[i] = pslist->arr[i-1];
 }
 pslist->arr[pos] = x;
 pslist->size++ ;
}

void Remove(pSeqList pslist,DataType x) //删除
{
 int pos = Find(pslist,x);
 int i = 0;
 for(i = pos;i < pslist->size-1;i++)
 {
  pslist->arr[i] = pslist->arr[i+1];
 }
 pslist->size--;
}

void RemoveAll(pSeqList pslist, DataType x) //删除所有相同节点
{
 int i = 0;
 int pos = Find(pslist, x);
 while(pos != -1)
 {
  for(i = pos;i<pslist->size-1;i++)
  {
   pslist->arr[i] = pslist->arr[i+1];
  }
  pslist->size--;
  pos = Find(pslist,x);
 }
}

int Find(pSeqList pslist,DataType x)//查找
{
 int i = 0;
 for(i = 0;i < pslist->size;i++)
 {
  if(pslist->arr[i] == x)
  {
   return i;
  }
 }
 return -1;
}

void ReverseList(pSeqList pslist)//逆序
{
 int start = 0;
 int end = pslist->size-1;
 while(start < end)
 {
  DataType tmp =pslist->arr[start];
  pslist->arr[start] = pslist->arr[end];
  pslist->arr[end] = tmp;
  start++;
  end--;
 }
}

void SortList(pSeqList pslist)//排序
{
 int i = 0,j = 0;
 for(i = 0;i<pslist->size-1;i++)
 {
  for(j = 0;j<=pslist->size-2-i;j++)
  {
   if(pslist->arr[j] > pslist->arr[j+1])
   {
    DataType tmp = pslist->arr[j];
    pslist->arr[j] = pslist->arr[j+1];
    pslist->arr[j+1] = tmp;
   }
  }
 }
}

int BinarySearch(pSeqList pslist,DataType x)//折半查找
{
 int start = 0;
 int end = pslist->size-1;
 while(start < end)
 {
  int mid = (start + end)/2;
  if(x == pslist->arr[mid])
   return mid;
  else if(x < pslist->arr[mid])
  {
   end = mid - 1;
  }
  else
  {
   start = mid + 1;
  }
  return mid;
 }
 return 0;
}

//----------------- 测试函数 ---------------------------------

#include "SeqList.h"

void test1()
{
 SeqList seqlist1;
 InitSeqList(&seqlist1);
 PushBack(&seqlist1,1);
 PushBack(&seqlist1,2);
 PushBack(&seqlist1,3);
 PushBack(&seqlist1,4);
 PrintSeqList(seqlist1);
 PopBack(&seqlist1);
 PrintSeqList(seqlist1);
 PushFront(&seqlist1,8);
 PrintSeqList(seqlist1);
 PopFront(&seqlist1);
 PrintSeqList(seqlist1);
}

void test2()
{
 int ret = 0;
 SeqList seqlist1;
 InitSeqList(&seqlist1);
 PushBack(&seqlist1,1);
 PushBack(&seqlist1,2);
 PushBack(&seqlist1,3);
 PushBack(&seqlist1,4);
 PrintSeqList(seqlist1);
 Insert(&seqlist1 ,4 ,6 );
 PrintSeqList(seqlist1);
 ret = Find(&seqlist1, 4);
 printf("%d \n" ,ret);
}

void test3()
{
 int ret = 0;
 SeqList seqlist1;
 InitSeqList(&seqlist1);
 PushBack(&seqlist1,2);
 PushBack(&seqlist1,1);
 PushBack(&seqlist1,2);
 PushBack(&seqlist1,3);
 PushBack(&seqlist1,2);
 PushBack(&seqlist1,4);
 PushBack(&seqlist1,2);
 PrintSeqList(seqlist1);
 Remove(&seqlist1,3);
 PrintSeqList(seqlist1);
 RemoveAll(&seqlist1, 2);
 PrintSeqList(seqlist1);
}
void test4()
{
 int ret = 0;
 SeqList seqlist1;
 InitSeqList(&seqlist1);
 PushBack(&seqlist1,1);
 PushBack(&seqlist1,2);
 PushBack(&seqlist1,3);
 PushBack(&seqlist1,4);
 PrintSeqList(seqlist1);
 ReverseList(&seqlist1);
 PrintSeqList(seqlist1);
}
void test5()
{
 int ret = 0;
 SeqList seqlist1;
 InitSeqList(&seqlist1);
 PushBack(&seqlist1,3);
 PushBack(&seqlist1,1);
 PushBack(&seqlist1,4);
 PushBack(&seqlist1,2);
 PrintSeqList(seqlist1);
 SortList(&seqlist1);
 PrintSeqList(seqlist1);
 ret = BinarySearch(&seqlist1, 2);
 printf("%d\n",ret);
}
int main()
{
 test5();
 system("pause");
 return 0;
}

时间： 2024-10-10 06:23:13

利用C语言实现顺序表的相关文章

利用C++类实现顺序表

以前写过用C语言实现的顺序表,现在来看看用C++类实现的吧 class SeqList { public: SeqList(int capacity=DEFAULT_CAPACITY) :_capacity(capacity) ,_size(0) ,_pData(0) { _pData=new DataType[_capacity]; } ~SeqList() { if(_pData!=NULL) { delete[] _pData; } } SeqList(const SeqList& s)

C语言实现顺序表的增删查改以及排序

顺序表是线性表中的一种重要的数据结构,也是最基础的数据结构,今天我用C语言实现下线性表的基本操作,以及冒泡排序与选择排序在线性表中的算法实践,代码如下: seqlist.h: #ifndef __SEQLIST__ #define __SEQLIST__ #define MAX 5 #include <stdlib.h> typedef int DataType; typedef struct SeqList { DataType array[MAX]; size_t size; }SeqLi

【C语言】顺序表，数组

顺序表的搭建,就是一个本身的结构,利用的是数组,开辟的内存空间大小是固定的.没有链式结构那样的开辟空间的可控性.最基本的数据结构认知. 然后我们来看看数据结构中的基本实现和思想: #include "seqList.h" #include <stdio.h> #include <assert.h> //顺序表的初始化 void InitSeqList(SeqList* seq) { int _index = 0; assert(seq); for(;_index

C语言实现顺序表

顺序表是C语言中一种基本的结构,可以存储各种基本类型的数据,而且不但可以存储基本类型的数据,也可以存储一种结构.所以顺序表是一种在学C的过程中必须掌握的结构,通过学习整理,下面来实现一下: 首先,先要想好用什么实现,一般实现最基本的顺序表的话直接用数组实现,我们在这用一个结构体来封装这个顺序表(封装这一概念是在C++中最常用的概念) #define ARRAY_EMPTY -2 #define ARRAY_FULL -1 #define MAX_SIZE 10000 typedef int Da

用C语言实现顺序表的插入和删除算法

什么是线性表? 线性表是n个数据元素的有限序列.根据线性表的显现方式,线性表又分为顺序表(数据元素在内存中的存储空间是连续的)和链表(数据元素在内存中的存储空间是不连续的). 线性表如何用C语言实现?线性表可以进行哪些操作? 在C语言中,线性表通过结构体的方式来实现.结构体中定义了线性表的存储空间地址,当前长度,和当前分配的存储容量.操作包含在指定位置插入某一元素.删除指定元素.查找指定的元素等.在这里重点介绍插入和删除算法. 下面就是关于这一部分内容的陈述. 线性表的C语言实现 需要先定义好的

Java语言描述顺序表类，顺序表类的基本操作实现

数据结构(Java版)ch2 线性表的顺序存储(顺序表) 线性表的抽象数据Java接口描述如下: package ch2; /** * 线性表的抽象数据接口,用Java语言描述线性表的这些功能! * @author 房廷飞 * */ public interface IList { public void clear(); //将线型表置成空表 public boolean isEmpty(); //判断是不是空表 public int length(); //返回线性表的长度 public O

java语言建立顺序表

1 package datastructure; 2 //线性表 3 4 public interface IList { 5 public void clear(); 6 public boolean isEmpty(); 7 public int length(); 8 public Object get(int i) throws Exception; 9 public void insert(int i,Object x) throws Exception; 10 public void

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

顺序表:一段地址连续的存储单元依次存储数据元素的线性结构. 静态存储的结构: #define MAX_SIZE 5 typedef int DataType; typedef struct SeqList { DataType array[MAX_SIZE]; size_t size; }SeqList; /////////////   顺序表的 增 删 查   ////////////////// void InitSeqList(SeqList* pSeq)  //初始化   { asser

C语言【顺序表】顺序表的初始化，头插，尾插，头删，尾删，增删查改，全删

#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<assert.h> #include<stdlib.h> #include<string.h> #define MAX_SIZE 5 typedef int DataType; typedef struct SeqList {     size_t size;     DataType array[MAX_SIZE]; }SeqList;