展开全部

#ifndef FUNS_H

#define FUNS_H

void error( char *, ... ); /* 输出错误信32313133353236313431303231363533e59b9ee7ad9431333234323734息，退出程序 */

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

#include

#include

#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

#include

#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) /* 接受用户输入的字符串 */

{

unsigned i;

L->length = 0;

for ( i = 0; ( L->elem[i]=getchar() ) != '\n' && L->elem[i] != EOF ; ++i ) {

++L->length;

if ( L->length == L->listsize ) { /* 如果顺序表已满 */

ElemType *newbase = realloc( L->elem, /* 增加空间 */

( L->listsize + INCREMENT ) * sizeof *L->elem );

if ( newbase ) { /* 如果分配成功 */

L->elem = newbase; /* 将指针指向新分配好的空间 */

L->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; /* 用于暂时存储用户输入的字符 */

long i;

if ( !InitList( &tmp ) ) {

return 0;

}

if ( InputList( &tmp ) ) {

if ( !tmp.length ) {

free(tmp.elem);

return 1;

}

if ( L->listsize - L->length < tmp.length ) {

ElemType *newbase = realloc( L->elem,

( L->listsize + tmp.length ) * sizeof *L->elem );

if ( newbase ) {

L->elem = newbase;

L->listsize += tmp.length;

} else {

free(tmp.elem);

return 0;

}

}

--pos;

/* 移动字符 */

for ( i = L->length - 1; i >= (long)pos; --i ) {

L->elem[i + tmp.length] = L->elem[i];

}

i = 0;

while ( i < (long)tmp.length ) {

L->elem[pos++] = tmp.elem[i++];

}

L->length += tmp.length; /* 更新字符串长度 */

free(tmp.elem);

return 1;

}

free(tmp.elem);

return 0;

} /* end of InsertList */

/* begin of DelList 05-8-13 12:00 */

void DelList(Sqlist *L, unsigned pos, unsigned size)

{

for ( --pos; pos + 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 为同一顺序表 */

return 1;

}

for ( k = 0; k < 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 ) * sizeof *L1->elem );

if ( newbase ) {

L1->elem = newbase;

L1->listsize += INCREMENT;

} else {

return 0; /* 增加空间失败，返回 */

}

}

L1->elem[ L1->length ] = 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 = 0; i < L->length; i++ ) {

for ( j = i+1; j < L->length; ) {

if ( L->elem[i] == L->elem[j] ) { /* 若找到重复元素 */

for ( k = j; k < L->length; k++ ) { /* 删除重复元素 */

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 = 1; i < L->length; i++ ) {

if ( !Location( &T, L->elem[i] ) ) { /* 若找不到重复元素 */

T.elem[T.length] = L->elem[i]; /* 插入 */

T.length++; /* 更新长度 */

}

}

L->length = T.length; /* 更新长度 */

} /* end of Purge2 */

/* begin of Bubble 05-8-13 14:10 */

void Bubble(Sqlist *L, unsigned ascend)

{

ElemType temp;

unsigned i, j, k = L->length - 1;

unsigned l;

if ( !L->length ) {

return;

}

for ( l = 1; l; k-- ) {

l = 0;

for ( i = 0, j = 1; i < k; i++, j++ ) {

/* 根据 ascend 的值进行升序或者降序排列 */

if ( ( L->elem[i] < L->elem[j] ) ^ ascend ) {

temp = L->elem[i];

L->elem[i] = L->elem[j];

L->elem[j] = temp;

l = 1;

}

}

}

} /* end of Bubble */

/* begin of Compare 05-8-13 14:40 */

int Compare(Sqlist *L1, Sqlist *L2) /* 比较两个顺序表 */

{

unsigned k;

if ( L1 == L2 ) {

return 0;

}

for ( k = 0; k < L1->length && k < L2->length; k++ ) {

if ( L1->elem[k] > L2->elem[k] ) {

return 1;

}

if ( L1->elem[k] < L2->elem[k] ) {

return -1;

}

}

return L1->length - L2->length;

} /* end of Compare */

/* begin of Exchange 05-8-13 15:10 */

void Exchange(Sqlist *L, unsigned i) /* 前N个元素和后M个元素互换 */

{

/* 三次逆转 */

Three( L, 0, i-1 );

Three( L, i, L->length-1 );

Three( L, 0, L->length-1 );

} /* end of Exchange */

/* begin of Three 05-8-13 14:55 */

void Three(Sqlist *L, unsigned i, unsigned j) /* 三次逆转法 */

{

ElemType temp;

for (; i < j; i++, j-- ) {

temp = L->elem[i];

L->elem[i] = L->elem[j];

L->elem[j] = temp;

}

} /* end of Three */

/* begin of Location 05-8-13 12:10 */

int Location(Sqlist *L, ElemType elem) /* 求元素位置 */

{

unsigned l;

for ( l=0; l < L->length && L->elem[l] != elem; l++ ) {

;

}

if ( l == L->length ) { /* 在顺序表中找不到elem */

return 0; /* 返回0 */

}

return ++l; /* 找到则返回元素位置 */

} /* end of Location */

/* begin of Disp 05-8-13 15:20 */

void Disp( Sqlist *L, unsigned total_lists ) /* 显示顺序表信息 */

{

unsigned short i;

unsigned j;

printf( "\n当前一共有 %u 个顺序表。每个表的数据如下：\n", total_lists );

for ( i = 0; i < total_lists; i++ ) {

printf( "\n顺序表 %d ：", i+1 );

for ( j = 0; j < L[i].length; j++ ) {

printf( "%c", L[i].elem[j] );

}

printf( "\n字符串长度：%u 顺序表长度：%u\n", L[i].length, L[i].listsize);

}

} /* end of Disp */

#include

#include

#include "header/sqlist.h"

#include "header/funs.h"

#define MAX_LISTS 10 /* 最多可以建立的顺序表个数 */

/* 函数声明 */

char Menu( void ); /* 打印菜单，请用户选择 */

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; /* ch 用于接收用户输入 */

for (;;) {

printf( "\n********************************\n"

"* 1. 创建顺序表 *\n"

"* 2. 输入数据 *\n"

"* 3. 插入数据 *\n"

"* 4. 删除数据 *\n"

"* 5. 求顺序表并集 *\n"

"* 6. 删除重复元素 *\n"

"* 7. 冒泡排序 *\n"

"* 8. 比较顺序表大小 *\n"

"* 9. 前N个元素和后M个元素互换 *\n"

"*10. 删除重复元素(2) *\n"

"* 0. 退出 *\n"

"********************************\n\n"

"请输入您要执行的操作(按回车确定)：");

scanf( "%d", &ch );

flush_stdin(); /* 清空输入缓冲区 */

if ( ch < 11 && ch > -1 ) {

break; /* 输入合法，退出循环 */

}

/* 非法输入，请用户重新输入 */

puts("\n请输入 0 到 10 之间的数字。\n");

} /* end of for */

return ch; /* 返回操作号 */

} /* end of Menu */

已赞过

已踩过<

你对这个回答的评价是？

评论

收起