“串”的定长顺序存储表示的实现

串——数据结构的实现——定长存储顺序。

//头文件sstring.h
#pragma once
#include<iostream>
using namespace std;
#define STRING_SIZE 20

typedef  char Sstring[STRING_SIZE+1];

int length(Sstring S)
{
  return strlen(S);
}

void StrAssign(Sstring T, char *str)
{
  int i=0;
  while(*str != '\0')
  {
     T[i++] = *str++;
  }
  T[i] = '\0';
}

bool StringConcat(Sstring T,Sstring s1,Sstring s2)
{
  int a = length(T);
  int b = length(s1);
  int c = length(s2);
  if(a>b+c)
  {
     for(int i=0;i<b;i++)
	 { T[i] = s1[i];}
	 for(int j= b; j < b+c;j++)
	 { T[j] = s2[j];}
	 T[j] = '\0';
	return true;
  }
  else if(a>b && a<b+c)
  {
     for(int i=0;i<b;i++)
	 { T[i] = s1[i];}
	 for(int j=b;j<=STRING_SIZE;j++)
	 { T[j] = s2[j];}
	 T[j] = '\0';
	return true;
  }
  else if(a<b)
  {
     for(int i=0;i<=STRING_SIZE;i++)
	 {T[i] = s1[i];}
	 T[i] = '\0';
  }
  return true;
}

void StrCopy(Sstring T, Sstring S)
{
   int i=0;
   while(S[i] != '\0')
   {
    T[i] = S[i];
	i++;
   }
   T[i] = '\0';
}

bool StrEmpty(Sstring S)
{
   if(S[0] == '\0')
	   return false;
   return true;
}

int StrCompare(Sstring T, Sstring S)
{
   int i=0;
   while(T[i]-S[i] == 0)
   {
         i++;
   }
   if(T[i]-S[i]>0)
     return 1;
   if(T[i]-S[i]<0)
	 return -1;
   else
	 return 0;
}

void ClearString(Sstring T)
{
  int i=0;
  T[i]='\0';
}

char * SubString(Sstring T,int pos,int len,Sstring S)
{
	if(length(T)<pos+len)
		return false;
	for(int i= 0;i<len;i++)
	{
	  S[i] = T[i+pos];
	}
	S[i] = '\0';
	return S;
}

int Index(Sstring S,Sstring T,int pos)
{
	int s_len=length(S);
	int t_len=length(T);
   for(int i=pos;i<=s_len - t_len;i++)
   {
	   for(int j=0;j <= t_len;++j)
	   {
		  if(S[j+i]==T[j])
		  {
			 if(j == t_len-1)
			 {return i;}
			 else
			 {continue;}
		  }
		  else
			  break;
	   }
   }
  return 0;
}

bool Replace(Sstring S,Sstring T,Sstring V)
{
  int sl=length(S);
  int tl=length(T);
  for(int i=0;i<sl-tl;i++)
  {
     for(int j=0;j <= tl;++j)
	   {
		  if(S[j+i]==T[j])
		  {
			 if(j == tl-1)
			 {
			   for(int m =0;m<tl;m++)
			   {
				   S[m+i] = V[m];
			   }
			 }
			 else
			 {continue;}
		  }
		  else
			break;
	   }
  }
 return 0;
}	

bool StrInsert(Sstring S,int pos,Sstring T)
{
    //1<=pos<=length(S)+1
	int sl=length(S);
	int tl=length(T);
	if(pos>sl+1)
		return false;
	for(int i=0;i<=sl-pos;i++)
	{
	  S[sl+tl-i]=S[sl-i];
	}
    for(int j=pos;j<tl+pos;j++)
	{
		S[j] = T[j-pos];
	}
	return true;
}

bool StrDelete(Sstring S,int pos,int len)
{
  if(pos>length(S)+1)
	 return false;
  for(int i=pos;i<length(S)-pos;i++)
  {
	  S[i]=S[i+len];
  }
  return true;
}

void DestroyString(Sstring S)
{
   S[0]='\0';
}

主函数:

#include"sstring.h"

void main()
{
  char *str1="asdcsdhasda";
  char *str2="sd";
  char *str3="zr";
  Sstring S;
  Sstring T;
  Sstring V;
  StrAssign(S,str1);
  StrAssign(T,str2);
  StrAssign(V,str3);
  Replace(S,T,V);
  //StrInsert(S,3,T);
  //StrDelete(S,1,2);
  /*
    int ret=Index(S,T,3);
    cout<<ret<<endl;
  */
  //int ret=StrCompare(T,S);
  //StrCopy(S,T);
  //cout<<ret<<endl;
  //cout<<SubString(T,0,5,S)<<endl;
  //cout<<length(S)<<endl;
  cout<<S<<endl;
}

注释部分为各函数的,图片没有一一附上。

时间: 05-27

“串”的定长顺序存储表示的实现的相关文章

串的定长顺序存储表示

串的定长顺序存储表示是一种类似于线性表的顺序存储结构,用一组地址连续的存储单元存储串值的字符序列. 在实现时主要实现以下功能: int Length(SString s);                               //串长 bool StringConcat(SString T, SString s1, SString s2);//用T返回s1和s2连接的串 void PrintString(char T[]);                          //输出 b

字符串定长顺序存储表示模板

1 ///page71 2 ///测试样例:nihao 3 ///output 4 /*5 5 5 nihao 6 0 7 10 nihaonihao 8 4 aoni 9 4 10 14 nihaoaoninihao 11 9 noninihao 12 13 nombxzmbxzhao*/ 13 #include <stdio.h> 14 #include <stdlib.h> 15 #include<string.h> 16 #include <malloc.

探究一种定长队列操作(C语言版本)

一 问题来源:南京烽火通信面试 二 问题: 现有一种定长队列,长度为2的n次方,此队列可被多线程访问,但必须确保线程级安全,即在任意时刻,队列的长度保持不变. 三 笔者分析 1. 队列的存储结构--链式和顺序均可. 2. 长度为2的n次方--便于移动队头和队尾指针,假设队列长度为size,那么rear = (rear + 1) & (size - 1),&运算比算术求模运算效率高.为此,笔者使用了顺序队列. 3. 怎么确保线程级安全 笔者认为此系统一定同时存在多个读者和写者,读者是读取队头

定长记录采用数据库读写并非最佳解决方案

对于有些应用场合如仪器仪表的采样数据,不需要对数据排序.插入和修改,只需要对数据写和读操作,在这种情况下,使用数据库来存取这样的记录数据,未必是最佳的选择,本文根据工作实践,采用文件的分块记录的方法,来处理采样这样的定长记录数据,实践证明,通过文件的分块存储方法,比数据库存储方法读写速度更快,尤其是在处理大批量的记录数据的读写的时候,这种速度上的优势更为显著.下面是分块记录的具体实现方法: 首先,假设我们的记录数据为:记录id号,电流,电压,温度,电阻,用结构体表示为: [html] view

内存池--定长内存池

简介 STL的 __pool_alloc, __mt_alloc,boost的pool系列, ace的ACE_Cached_Allocator均为定长内存池. 说明 内存池,根据存储的元素的长度是否可变,分为变长,与定长两种内存池. 从逻辑上来讲,定长内存池只需存储相同大小的元素,因此无须花费额外的空间(数据结构)来存储元素长度的信息. 以上几种定长内存池都可以较好的处理定长内存频繁分配的问题. STL--pool_alloc pool_alloc,原理是挂了16个链表(_S_free_list

报文格式【定长报文】

定长报文简介 定长报文,是目前使用最广泛的报文,同时比较简单的报文格式.理解起来也较为简单,但定长报文也有自身的局限性.其中最大的问题在于,如果定义域的长度需要加长,这时候相关的配置与程序代码都需要进行相应的改变,所以维护很不方便. 定长报文,就是使用固定的长度来表示一个信息.本报文格式常见于金融银行业,所以以银行开户场景为例说明,例如银行柜面开户时,需要记录开户人的姓名,假定用户名用30个字节来表示,这样应该就可以满足国人的需要,15个汉字长度.当然我们这里也有开户时间的需要,那我们假定为8位

定长内存池之BOOST::pool

内存池可有效降低动态申请内存的次数,减少与内核态的交互,提升系统性能,减少内存碎片,增加内存空间使用率,避免内存泄漏的可能性,这么多的优点,没有理由不在系统中使用该技术. 内存池分类: 1.              不定长内存池.典型的实现有apr_pool.obstack.优点是不需要为不同的数据类型创建不同的内存池,缺点是造成分配出的内存不能回收到池中.这是由于这种方案以session为粒度,以业务处理的层次性为设计基础. 2.             定长内存池.典型的实现有LOKI.B

求一个字串中最长的连续字符串

举例子来说:对于字符串"1234abcdef1234567abcdefghijklmn",这个字串中最长的连续字符串为"abcdefghijklmn". int continumax(char *outputstr,char *inputstr) { char maxrecord[100] = {0}; int maxlength = 0; char currentrecord[100] = {0}; int currentlength = 0; char valu

定长单元的批次内存缓存池的简洁实现

问题描述: 1.内存管理计算机编程中一个基本问题,其目的在于: 1)一次可分配多个单元块,缓存维护,以改善反复的小对象申请的性能开销: 2) 管理以分配的内存,有效减少碎片的产生: 3) 保证软件使用的内存透明,了解峰值,了解使用情况,便于优化查错: 2.常用的内存管理机制有以下: 1) 变长块,依靠链表维护,一个节点一块申请了的内存,内存块大小不等,等接到一个申请时,先查维护的链表,若有可从链表取出.这种方法有很多缺点:1,当申请的内存块要遍历链表节点找到大小合适的块,最坏情况下需要把链表所有