#define FUNS_H
void error( char *, ... )/* 输出错误信息，退出程序 */
void flush_stdin( void ) /* 清空“输入缓冲区” */
#endif#ifndef SQLIST_H
#define SQLIST_H
#define INITSIZE 100 /* 顺序表初始空间分配量 */
#define INCREMENT 10 /* 顺序表空间分配增量 */
typedef int ElemType/* 声明ElemType代表的数据类型 */
/* 定义顺序表结构 */
typedef struct {
ElemType *elem/* 存储空间基址 */
unsigned length /* 当前长度 */ unsigned listsize /* 当前空间分配量 */
} Sqlist
/* 函数声明 */int InitList(Sqlist *) /* 创建顺序表 */
int InputList(Sqlist *)/* 输入数据 */
int InsertList(Sqlist *, unsigned) /* 插入数据 */
void DelList(Sqlist *, unsigned, unsigned) /* 删除数据 */
int Union(Sqlist *, Sqlist *) /* 求顺序表并集 */
void Purge(Sqlist *)/* 删除表中重复元素 */
void Purge2(Sqlist *) /* 删除表中重复元素 */
void Bubble(Sqlist *, unsigned) /* 冒泡排序 */
int Compare(Sqlist *, Sqlist *)/* 比较两个顺序表的大小 */
void Exchange(Sqlist *, unsigned) /* 前N个元素和后M个元素互换 */
int Location(Sqlist *, ElemType) /* 求元素位置 */
void Disp(Sqlist *, unsigned) /* 显示顺序表信息 */
void Three(Sqlist *, unsigned, unsigned) /* 三次逆转法 */
#endif /* end of sqlist.h */
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include "../header/funs.h"
/* begin of error 05-8-15 18:40 */
void error( char *fmt, ... )
{ /* 输出错误信息，退出程序 */
va_list args
va_start( args, fmt )
fprintf( stderr, "error: " )
vfprintf( stderr, fmt, args )
fprintf( stderr, "\n" )
va_end( args )
exit( -1 )
} /* end of error */
/* begin of flush_stdin 05-8-31 19:30 */
void flush_stdin( void ) /* 清空“输入缓冲区” */
{ int c
if ( !feof(stdin) ) {
while( ( c=getchar() ) != '\n' &&c != EOF )
/* end of flush_stdin */
#include <stdio.h>
#include <stdlib.h>
#include "../header/sqlist.h"
/* begin of InitList 05-8-13 0:30 */
int InitList( Sqlist *L ) /* 创建顺序表 */
{/* malloc 返回值为 void 类型，不需要显式转换 */
L->elem = malloc( INITSIZE * sizeof *L->elem )/* 分配初始空间 */
if ( !L->elem ) {
return 0/* 创建失败返回 0 */
/* 创建成功，初始化字符串长度和顺序表长度 */
L->length = 0
L->listsize = INITSIZE
return 1/* 创建成功返回 1 */
} /* end of InitList */
* begin of InputList 05-8-13 2:15 */
int InputList(Sqlist *L) /* 接受用户输入的字符串 */ usigned i
L->length = 0for ( i = 0( L->elem[i]=getchar() ) != '\n' &&L->elem[i] != EOF ++i ) {
++L->lengthif ( L->length == L->listsize ) { /* 如果顺序表已满 */
ElemType *newbase = realloc( L->elem, /* 增加空间 */
( L->listsize + INCREMENT ) * sizeof *L->elem )
f ( newbase ) { /* 如果分配成功 */L->elem = newbase /* 将指针指向新分配好的空间 */
->listsize += INCREMENT/* 增大 listsize 的值 */} else { /* 分配空间失败 * return 0/* 增加空间失败，返回 0 */
return 1} /* end of InputList *//* begin of InsertList 05-8-13 5:00 */
int InsertList(Sqlist *L, unsigned pos) /* 插入数据 */
{Sqlist tmp /* 用于暂时存储用户输入的字符 */<br/>long iif ( !InitList( &tmp ) ) {<br/> return 0<br/> if ( InputList( &tmp ) ) {<br/> if ( !tmp.length ) {<br/> free(tmp.elem)<br/> return 1if ( L->listsize - L->length <tmp.length ) {<br/> ElemType *newbase = realloc( L->elem,( L->listsize + tmp.length ) * sizeof *L->elem )<br/> if ( newbase ) {L->elem = newbase<br/> L->listsize += tmp.length<br/> } else { /* 移动字符 */
for ( i = L->length - 1i >= (long)pos--i ) {
L->elem[i + tmp.length] = L->elem[i]
i = 0L->elem[pos++] = tmp.elem[i++]
L->length += tmp.length/* 更新字符串长度 */free(tmp.elem)
begin of DelList 05-8-13 12:00 */
void DelList(Sqlist *L, unsigned pos, unsigned size)
{
for ( --pospos + size <L->length++pos ) {
L->elem[pos] = L->elem[pos + size]
}L->length -= size
} /* end of DelList */* begin of Union 05-8-13 12:30 */
int Union(Sqlist *L1, Sqlist *L2){ /* 求顺序表并集 */
unsigned k/* 开始进行并集 *** 作 */
if ( L1 == L2 ) { /* 如果 L1 和 L2 为同一顺序表 * for ( k = 0k <L2->length++k ) {
/* 在顺序表 L1 中找不到顺序表 L2 中的第k+1个元素，将第k+1个元素插入顺序表 L1 */
if ( !Location( L1, L2->elem[k]) ) {
if ( L1->length == L1->listsize ) { /* 如果顺序表已满 */
ElemType *newbase = realloc( L1->elem, /* 增加空间 */
( L1->listsize + INCREMENT ) * return 0/* 增加空间失败，返回= L2->elem[k]/* 插入到表 L1 */
L1->length++/* 表 L1 长度增加 */
}
}
return 1/* 无误返回 */
} /* end of Union */
/* begin of Purge 05-8-13 13:00 */
void Purge(Sqlist *L) /* 删除表中重复元素 */
{
unsigned i, j, k
for ( i = 0i <L->lengthi++ ) {
for ( j = i+1j <L->length) {
if ( L->elem[i] == L->elem[j] ) { /* 若找到重复元素 */
for ( k = jk <L->lengthk++ ) { /* 删除重复元素 */
L->elem[k] = L->elem[k+1]
}
L->length--/* 顺序表长度减1 */
}
else {
j++
}
}
}
} /* end of Purge */
/* begin of Purge2 05-8-13 13:20 */
void Purge2(Sqlist *L) /* 删除表中重复元素 */
{
Sqlist T = *L
unsigned i
T.length = 1
for ( i = 1i <L->lengthi++ ) {
if ( !Location( &T, L->elem[i] ) ) { /* 若找不到重复元素 */
T.elem[T.length] = L->elem[i]/* 插入 */
T.length++/* 更新长度 */
}
}
L->length = T.length/* 更新长度 */ /* 根据 ascend 的值进行升序或者降序排列 /* begin of Exchange 05-8-13 15:10 */
void Exchange(Sqlist *L, unsigned i) /* 前N个元素和后M个元素互换 */
{
/* 三次逆转 */
Three( L, i, L->length-1 )
Three( L, 0, void Three(Sqlist *L, unsigned i, unsigned j) /* 三次逆转法 for (i <ji++, j-- ) {
temp = L->eint Location(Sqlist *L,
if ( l == L->length ) { /* 在顺序表中找不到elem */
return 0 /* 返回0 */
return ++l/* 找到则返回元素位置 */
} /* end of Location */l_lists }
printf( "\n字符#define MAX_LISTS 10/* 最多可以建立的顺序表个数 */
/* 函数声明 *择 */
unsigned Choose( unsigned, unsigned, char )/* 接收用户输入的选择 */
static int tmp/* tmp 用于清空输入缓冲区 */
const char *msg[] = { "\n请问您要对哪个顺序表（%u — %u）进行 *** 作：",
"\n请输入删除数目（%u — %u）：",
"\n请输入字符串（原有数据会被覆盖）：",
"\n请输入插入位置（%u — %u）：",
"\n请输入删除位置（%u — %u）：",
"\n此项 *** 作至少要有两个顺序表才能进行。请再建立一个顺序表。",
"\n重复元素已被删除。",
"\n请问您要进行降序排序还是升序排序（%u 代表降序，%u 代表升序）：",
"\n顺序表 %u %c 顺序表 %u",
"\n请输如互换点（%u — %u）：",
"\n排序完成。" }
int main( void )
{
Sqlist L[ MAX_LISTS ] /* 顺序表数组 */
char choice /* 记录用户选择的 *** 作 */
unsigned short total_lists = 0/* 用于记录目前一共有多少个顺序表 */
char *init_msg[] = { "内存不足！创建失败。", /* 创建顺序表的提示信息 */
"顺序表创建成功！您可以开始对顺序表进行 *** 作了。" }
printf( "\n请先创建一个顺序表。最多可以创建 %u 个顺序表。\n", MAX_LISTS )
while ( choice = Menu() ) { /* 根据用户输入选择函数运行 */
if ( !total_lists &&choice != 1 ) {
printf( "\n请先创建一个顺序表。最多可以创建 %u 个顺序表。\n", MAX_LISTS )
} else {
switch ( choice ) {
case 1 :
if ( total_lists == MAX_LISTS ) { /* 达到最大限制 */
printf( "\n最多只能建立 %u 个顺序表。\n", MAX_LISTS )
} else {
int i = InitList( &L[total_lists] )
total_lists += i/* 更新顺序表数目 */
printf( "\n%s\n", init_msg[i] )
}
break
case 2 :
{
unsigned num = Choose( total_lists, 1, 0 )
printf( "%s", msg[choice] )
InputList(&L[num-1])
break
}
case 3 :
{
unsigned num, pos
num = Choose( total_lists, 1, 0 )
pos = Choose( L[num-1].length + 1, 1, choice )
printf( "\n请输入字符串：" )
/* 在第 num 个顺序表的第 pos 个元素处开始插入 */
InsertList( &L[num-1], pos )
break
}
case 4 :
{
unsigned num, pos, size
num = Choose( total_lists, 1, 0 )
if ( !L[num-1].length ) {
printf( "\n顺序表为空，不能进行删除 *** 作。\n" )
break
}
pos = Choose( L[num-1].length, 1, choice )
size = Choose( L[num-1].length - pos + 1, 1, 1 )
/* 从第 num 个顺序表的第 pos 个位置开始，删除 size 个元素 */
DelList( &L[num-1], pos, size )
break
}
case 5 :
{
unsigned num1, num2
if ( total_lists <2 ) {
puts( msg[choice] )
break
}
num1 = Choose( total_lists, 1, 0 )
num2 = Choose( total_lists, 1, 0 )
if ( Union( &L[num1-1], &L[num2-1] ) ) {
printf( "\n并集 *** 作完成。 *** 作结果保存于顺序表 %u 。\n", num1 )
} else {
printf( "\n并集 *** 作失败。\n" )
}
break
}
case 6 :
{
unsigned num = Choose( total_lists, 1, 0 )
Purge( &L[num-1] )
puts( msg[choice] )
break
}
case 7 :
{
unsigned num = Choose( total_lists, 1, 0 )
unsigned ascend = Choose( 1, 0, choice )
Bubble( &L[num - 1], ascend )
puts( msg[10] )
break
}
case 8 :
{
unsigned num1, num2
int flag
if ( total_lists <2 ) {
puts( msg[5] )
break
}
num1 = Choose( total_lists, 1, 0 )
num2 = Choose( total_lists, 1, 0 )
flag = Compare( &L[num1-1], &L[num2-1] )
if ( !flag ) {
flag = '='
} else if ( flag >0 ) {
flag = '>'
} else {
flag = '<'
}
printf( msg[choice], num1, flag, num2 )
break
}
case 9 :
{
unsigned num = Choose( total_lists, 1, 0 ), point
if ( L[num-1].length <2 ) {
puts("\n元素太少，不能进行互换。")
break
}
point = Choose( L[num-1].length - 1, 1, choice )
Exchange( &L[num-1], point )
puts( "\n互换完成。" )
break
}
case 10 :
{
unsigned num = Choose( total_lists, 1, 0 )
Purge2( &L[num-1] )
puts( msg[6] )
break
}
break
default:
break
}
}
/* 打印顺序表的内容 */
Disp( L, total_lists )
}
while ( total_lists ) {
free( L[ --total_lists ].elem )/* 释放内存 */
}
puts( "\n感谢您使用我们的产品！请按回车退出..." )
getchar()
return 0/* 退出程序 */
} /* end of main */
/* begin of Choose 05-8-13 3:00 */
unsigned Choose( unsigned up, unsigned low, char c )
{
unsigned num = 0
do {
printf( msg[c], low, up )
scanf( "%u", &num )
flush_stdin()/* 清空输入缓冲区 */
} while ( num >up || num <low )
return num
} /* end of Choose */
/* begin of Menu 05-8-12 23:20 */
char Menu( void ) /* 打印菜单，并且接受用户输入 */
{
int ch = -1
#include<stdio.h>#include<iostream.h>
#include<stdlib.h>
#defineOVERFLOW -2
#define OK 1
#define ERROR 0
#defineLIST_INIT_SIZE 100
#defineLISTINCREMENT 10
typedef intElemType
typedef intStatus
//定义顺序存储结构
typedef struct
{
ElemType *elem
int length
int listsize
}SqList
//初始化顺序表
StatusInitList_Sq(SqList &L)
{
L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType))
if(!L.elem ) exit(ERROR)
L.length =0
L.listsize =LIST_INIT_SIZE
return OK
}
//自定义创建顺序表
voidCreate_SqList(SqList &L)
{
int c,i=0
int *newBase
printf("请输入顺序表元素：\n")
while((scanf("%d",&c))!=EOF)
{
if(i>=L.listsize) //自定义顺序表大小超过初始化大小
{
newBase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType))
//为初始顺序表以LISTINCREMENT大小重新增加存储空间
if(!newBase)exit(OVERFLOW)
L.elem=newBase
L.listsize+=LISTINCREMENT
}
L.elem[i++]=c
}
L.length=i
printf("输入的顺序表元素：\n")
for(i=0i<L.lengthi++)
printf("%d ",L.elem[i])
printf("\n")
}
//在指定位置插入元素
StatusListInsert(SqList &L,int i,ElemType e)
{
ElemType *p,*q,*newbase
if(i<1||i>L.length+1)
{
printf("插入位置错误\n")
return(ERROR)
}
if(L.length>=L.listsize)
{
newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType))
if(!newbase) exit(OVERFLOW)
L.elem=newbase
L.listsize+=LISTINCREMENT
}
if(i==L.length) L.elem[i+1]=e
q=&(L.elem[i-1])
for(p=&(L.elem[L.length-1])p>=q--p)*(p+1)=*p
*q=e
++L.length
return OK
}
//在指定位置删除元素
StatusListDelete_Sq(SqList &L,int i,ElemType *e)
{
ElemType *p,*q
if(i<1||i>L.length+1)
return ERROR
p=&(L.elem[i-1])
*e=*p
q=L.elem+L.length-1
for(++pp<=q++p)
*(p-1)=*p
--L.length
return OK
}
void main()
{
SqList L
int m,n
int location,element
if(!InitList_Sq(L))
{
printf("初始化顺序表失败！\n")
exit(ERROR)
}
Create_SqList(L)
for(m=0m<3m++)
{
printf("输入插入位置：")
scanf("%d",&location)
while(location>L.length+1||location<1)
{
printf("输入位置错误，请重新输入！\n")
scanf("%d",&location)
}
printf("插入元素：")
scanf("%d",&element)
if(!ListInsert(L,location,element))
{
printf("顺序表插入失败！\n")
exit(ERROR)
}
printf("插入顺序表为：\n")
for(int i=0i<=L.length -1i++)
{
printf("%d ",L.elem[i])
}
printf("\n新顺序表一共有%d个元素。\n",L.length)
}
for(n=0n<3n++)
{
printf("输入删除位置：")
scanf("%d",&location)
while(location>L.length||location<1)
{
printf("输入位置错误，请重新输入！\n")
scanf("%d",&location)
}
if(!ListDelete_Sq(L,location,&element))
{
printf("删除错误！\n")
exit(ERROR)
}
printf("被删除的元素为：%d \n",element)
printf("被删除后的顺序表为：\n")
for(int j=0j<=L.length-1j++)
{
printf("%d ",L.elem[j])
}
printf("\n新顺序表一共有%d个元素。\n",L.length)
}
}
这个是我最近编写的 顺序表也是线性表的
这里还有链表的程序 用的话再传给你
代码如下：
头文件：
2_1.h
#ifndef _2_1_H
#define _2_1_H
typedef void SeqList
typedef void SeqListNode
//创建线性表
SeqList * SeqList_Create(int capacity)
//销毁线性表
void SeqList_DesTroy(SeqList * list)
void SeqList_Clear(SeqList* list)
int SeqList_Length(SeqList* list)
int SeqList_Capacity(SeqList* list)
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
SeqListNode* SeqList_Get(SeqList* list, int pos)
SeqListNode* SeqList_Delete(SeqList* list, int pos)
#endif
源文件：
// 顺序线性表.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <malloc.h>
#include <stdlib.h>
#include "2_1.h"
typedef unsigned int TSeqListNode
typedef struct {
int len //长度
int capacity//总长度
TSeqListNode * node//每个节点的指针
} TSeqList
int main()
{
SeqList* list = SeqList_Create(5)//创建线性表
int i = 6//赋值6个变量，已超过线性表最大值 5
int j = 1
int k = 2
int x = 3
int y = 4
int z = 5
int index = 0
SeqList_Insert(list, &i, 7) //将这6个变量插入线性表中
SeqList_Insert(list, &j, 0)
SeqList_Insert(list, &k, 0)
SeqList_Insert(list, &x, 0)
SeqList_Insert(list, &y, 0)
SeqList_Insert(list, &z, 0)
//遍历
for(index=0index<SeqList_Length(list)index++)
{
int* p = (int*)SeqList_Get(list, index)
printf("%d ", *p)
}
printf("\n")
//删除 *** 作
while( SeqList_Length(list) >0 )
{
int* p = (int*)SeqList_Delete(list, 0)
printf("删除了： %d\n", *p)
}
SeqList_Clear(list)
SeqList_DesTroy(list)
system("pause")
return 0
}
//创建线性表
SeqList * SeqList_Create(int capacity)
{
TSeqList* ret = NULL
if(capacity >= 0)
{
ret = (TSeqList*)malloc(sizeof(TSeqList) + sizeof(TSeqListNode)*capacity) //为线性表分配空间，包含结 //构体和节点的总大小
}
if(NULL != ret)
{
ret->len = 0
ret->capacity = capacity
ret->node = (TSeqListNode*)(ret + 1)//将节点指向上述分配到的空间的后部分
}
return ret
}
//销毁
void SeqList_DesTroy(SeqList * list)
{
free(list)
}
//清空
void SeqList_Clear(SeqList* list)
{
TSeqList * ret = (TSeqList*)list
if(NULL != ret)
{
ret->len = 0
}
}
//获得线性表的长度
int SeqList_Length(SeqList* list)
{
TSeqList * ret = (TSeqList*)list
int len = -1
if(NULL != ret)
{
len = ret->len
}
return len
}
//线性表的总长度
int SeqList_Capacity(SeqList* list)
{
TSeqList * ret = (TSeqList*)list
int capacity = -1
if(NULL != ret)
{
ret->capacity = capacity
}
return capacity
}
//插入
int SeqList_Insert(SeqList* list, SeqListNode* node, int pos)
{
TSeqList * sList = (TSeqList*)list
int i,ret = -1
if((sList != NULL) &&(pos >= 0) &&sList->capacity >= sList->len+1)
{
if(pos >= sList->len)
{
pos = sList->len
}
for(i = sList->leni >posi--)
{
sList->node[i] = sList->node[i-1]
}
sList->node[i] = (TSeqListNode)node
++sList->len
ret = 1
}
return ret
}
//获得指定位置的节点
SeqListNode* SeqList_Get(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list
TSeqListNode* node = NULL
if(NULL != sList &&pos>=0 &&pos <sList->len)
{
node = (TSeqListNode*)sList->node[pos]
}
return node
}
//删除
SeqListNode* SeqList_Delete(SeqList* list, int pos)
{
TSeqList * sList = (TSeqList*)list
SeqListNode * node = SeqList_Get( list, pos)
int i
if(sList != NULL &&pos >= 0 &&pos<sList->len)
{
for( i=pos+1i<sList->leni++)
{
sList->node[i-1] = sList->node[i]
}
sList->len--
}
return node
}
演示：
资料拓展：
线性表是最基本、最简单、也是最常用的一种数据结构。
线性表中数据元素之间的关系是一对一的关系，即除了第一个和最后一个数据元素之外，其它数据元素都是首尾相接的（注意，这句话只适用大部分线性表，而不是全部。比如，循环链表逻辑层次上也是一种线性表（存储层次上属于链式存储），但是把最后一个数据元素的尾指针指向了首位结点）。
我们说“线性”和“非线性”，只在逻辑层次上讨论，而不考虑存储层次，所以双向链表和循环链表依旧是线性表。
在数据结构逻辑层次上细分，线性表可分为一般线性表和受限线性表。一般线性表也就是我们通常所说的“线性表”，可以自由的删除或添加结点。受限线性表主要包括栈和队列，受限表示对结点的 *** 作受限制。
线性表的逻辑结构简单，便于实现和 *** 作。因此，线性表这种数据结构在实际应用中是广泛采用的一种数据结构。
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）