刁肥宅手笔：纯C语言实现堆式串主要操作

头文件HString.h：

/*HString.h*/

#ifndef HSTRING_H_INCLUDED
#define HSTRING_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define defaultSize 30

typedef struct
{
	char *ch;						/*顺序串的存储数组*/
	int maxSize;					/*字符串存储数组的最大长度*/
	int n;							/*顺序串的实际长度*/
} HString;





#endif  /*HSTRING_H_INCLUDED*/

源文件HString.c：

/*HString.c*/

#include "HString.h"

HString *initStr ( HString *s )/*串初始化*/
{
	s->ch = ( char *) malloc ( ( defaultSize+1 )*sizeof ( char ) );	/*动态分配*/
	s->ch[0] = '\0';
	s->maxSize = defaultSize;
	s->n = 0;			/*串s的最大容量和当前长度*/
	return s;
}

void createStr ( HString *s, char *init )/*从字符数组init构造串s*/
{
	s->maxSize = defaultSize;
	s->ch = ( char *) malloc (( defaultSize+1 )*sizeof ( char ));
	s->n = strlen ( init );
	strcpy ( s->ch, init );
}

void copyStr ( HString *s, HString *t )/*把串t复制给串s*/
{
	s->maxSize = defaultSize;
	s->ch = ( char *) malloc ( ( defaultSize+1 )*sizeof ( char ) );
	s->n = t->n;
	strcpy ( s->ch, t->ch );
}


HString *subStr ( HString *s, int pos, int len )/*在串s中连续取从pos开始的len个字符，
构成子串返回。若提取失败则函数返回NULL*/
{

	HString *tmp = ( HString * )malloc( sizeof(HString) );
	tmp->ch = ( char *) malloc ( ( defaultSize+1 )*sizeof ( char ) );
	tmp->maxSize = defaultSize;
	if ( pos < 0 || len < 0 || pos+len-1 >= s->maxSize )		/*参数不合理，返回空串*/
    {
        tmp->n = 0;
        tmp->ch[0] = '\0';
    }
	else
    {
		if ( pos+len-1 >= s->n )
            len = s->n-pos;			/*若提取个数超出串尾，修改个数*/
		for ( int i = 0, j = pos; i < len; i++, j++)
            tmp->ch[i] = s->ch[j];
	   	tmp->n = len;
        tmp->ch[len] = '\0';
	}
	return tmp;
}

void concat ( HString *s, HString *t )
{
/*将串t复制到串s后，串t不变。若完全连接成功，函数返回true；若部分连接成功，或
连接不成功，函数返回false*/
	if ( s->n+t->n <= s->maxSize )/*原空间可容纳连接后的串*/
    {
		for ( int i = 0; i < t->n; i++ )
            s->ch[s->n+i] = t->ch[i];
		s->n = s->n+t->n;
        s->ch[s->n] = '\0';
	}
	else
    {										/*原空间容不下连接后的串*/
		char *tmp = s->ch;
        s->maxSize = s->n+t->n;			/*暂存原串数组，算新串数组大小*/
		s->ch = ( char* ) malloc ( ( s->maxSize+1 )*sizeof ( char ) );
	   	strcpy ( s->ch, tmp );
	   	strcat ( s->ch, t->ch );			/*复制原串s数组, 连接串t数组*/
		s->n = s->n+t->n;
		free ( tmp );
	}
}

char getChar ( HString *s, int i )/*提取串s的第i个字符*/
{
	if ( i < 0 || i >= s->n )
    {
        printf ( "字符串下标超界!\n" );
        return '\0';
    }
	return s->ch[i];
}

void printStr ( HString *s )
{
	printf ("打印串长度s->n=%d, 最大长度=%d\n", s->n, s->maxSize);
	for ( int i = 0; i < s->n; i++ )
		if ( s->ch[i] == '\0' )
            break;
		else
            printf ( "%c", s->ch[i] );
	printf("\n");
}

测试源文件test.c：

/*test.c*/

#include "HString.h"
#define defSize 30

/*
HefeiUniversityofTechnology
*/

int main (  )
{
	char A[defSize] = {'H','e','f','e','i','U','n','i','v','e','r','s','i',
	't','y','O','f','T','e','c','\0'};
	char B[defSize] = {'H','e','f','e','i','U','n','i','v','e','r','s','i',
	't','y','O','f','T','e','c','h','n','o','l','o','g','y','\0'};
	HString *s1 = ( HString * )malloc( sizeof(HString) ), *s2 = ( HString * )malloc( sizeof(HString) ), *s3 = ( HString * )malloc( sizeof(HString) ), *s4 = ( HString * )malloc( sizeof(HString) );

	s3 = initStr ( s3 );
	s4 = initStr ( s4 );

	printf ( "createString ( s1, A )\n" );
	createStr ( s1, A );
	printStr ( s1 );

	printf ( "createString ( s2, B )\n" );
	createStr ( s2, B);
	printStr ( s2 );

	printf ( "copy ( s3, s2 )\n" );
	copyStr ( s3, s2 );
	printStr ( s3 );

	printf ( "s4 = subStr( s3, 5, 3 )\n" );
	s4 = subStr( s3, 5, 3 );
	printStr ( s4 );

	printf ( "initString ( s4 )\n" );
	initStr ( s4 );
	printStr ( s4 );

	printf ( "s4 = subStr ( s3, 8, 5 )\n" );

	s4 = subStr ( s3, 8, 5 );
	printStr ( s3 );
	printStr ( s4 );

	printf ( "concat ( s1, s4 )\n" );
	concat ( s1, s4 );
	printStr ( s1 );

	printf ( "%c\n", getChar ( s1, 5 ) );

	return 0;
}

程序运行截图：

刁肥宅手笔：纯C语言实现堆式串主要操作

猜你喜欢