C++博客-书呆子的 notepad-随笔分类-数据结构与算法

字符串反回首字母大写

书呆子 — Mon, 13 Sep 2010 13:26:00 GMT

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

int main()
{
    int i;
    int flag = 1; //用flag来判断是不是一个新的单词
    char a[100];
    gets(a);
    for(i = 0; a[i] != 0; i++)
    {
        if(a[i] == ' ')
        {
            flag = 1;
        }
        if((flag == 1)&&(a[i]>=97&&a[i]<=122)) //a <--> z
        {
            a[i]=a[i]-32;        //转换为A <--> Z 的ASCII值
            flag = 0;
        }
    }
    puts(a);
    system("PAUSE");
    return 0;
}

运行结果：

附
1.ASCII表：

2.扩展：

书呆子 2010-09-13 21:26 发表评论

[转]C库函数中字符串处理函数集合

书呆子 — Mon, 13 Sep 2010 11:46:00 GMT

原文：http://blog.csdn.net/General1982/archive/2009/03/21/4012566.aspx

bcmp

原型：extern int bcmp(const void *s1, const void *s2, int n);
用法：#include
功能：比较字符串s1和s2的前n个字节是否相等
说明：如果s1=s2或n=0则返回零，否则返回非零值。bcmp不检查NULL。

bcopy

原型：extern void bcopy(const void *src, void *dest, int n);
用法：#include
功能：将字符串src的前n个字节复制到dest中
说明：bcopy不检查字符串中的空字节NULL，函数没有返回值。

bzero

   原型：extern void bzero(void *s, int n);
   用法：#include
   功能：置字节字符串s的前n个字节为零。
   说明：bzero无返回值。

memccpy

   原型：extern void *memccpy(void *dest, void *src, unsigned char ch, unsigned int count);
   用法：#include
   功能：由src所指内存区域复制不多于count个字节到dest所指内存区域，如果遇到字符ch则停止复制。
   说明：返回指向字符ch后的第一个字符的指针，如果src前n个字节中不存在ch则返回NULL。ch被复制。

memchr

   原型：extern void *memchr(void *buf, char ch, unsigned count);
   用法：#include
   功能：从buf所指内存区域的前count个字节查找字符ch。
   说明：当第一次遇到字符ch时停止查找。如果成功，返回指向字符ch的指针；否则返回NULL。

memcmp

   原型：extern int memcmp(void *buf1, void *buf2, unsigned int count);
   用法：#include
   功能：比较内存区域buf1和buf2的前count个字节。
   说明：
         当buf1         当buf1=buf2时，返回值=0
         当buf1>buf2时，返回值>0

memcpy

   原型：extern void *memcpy(void *dest, void *src, unsigned int count);
用法：#include
   功能：由src所指内存区域复制count个字节到dest所指内存区域。
   说明：src和dest所指内存区域不能重叠，函数返回指向dest的指针。

memicmp

   原型：extern int memicmp(void *buf1, void *buf2, unsigned int count);
   用法：#include
   功能：比较内存区域buf1和buf2的前count个字节但不区分字母的大小写。
   说明：memicmp同memcmp的唯一区别是memicmp不区分大小写字母。
         当buf1         当buf1=buf2时，返回值=0
         当buf1>buf2时，返回值>0

memmove

   原型：extern void *memmove(void *dest, const void *src, unsigned int count);
   用法：#include
   功能：由src所指内存区域复制count个字节到dest所指内存区域。
   说明：src和dest所指内存区域可以重叠，但复制后src内容会被更改。函数返回指向dest的指针。

memset

   原型：extern void *memset(void *buffer, int c, int count);
   用法：#include
   功能：把buffer所指内存区域的前count个字节设置成字符c。
   说明：返回指向buffer的指针。

movmem

   原型：extern void movmem(void *src, void *dest, unsigned int count);
   用法：#include
   功能：由src所指内存区域复制count个字节到dest所指内存区域。
   说明：src和dest所指内存区域可以重叠，但复制后src内容会被更改。函数返回指向dest的指针。

setmem

   原型：extern void setmem(void *buf, unsigned int count, char ch);
   用法：#include
   功能：把buf所指内存区域前count个字节设置成字符ch。
   说明：返回指向buf的指针。

stpcpy

   原型：extern char *stpcpy(char *dest,char *src);
   用法：#include
   功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
   说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
         返回指向dest结尾处字符(NULL)的指针。

strcat

   原型：extern char *strcat(char *dest,char *src);
   用法：#include
   功能：把src所指字符串添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。
   说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
         返回指向dest的指针。

strchr

   原型：extern char *strchr(char *s,char c);
   用法：#include
   功能：查找字符串s中首次出现字符c的位置
   说明：返回首次出现c的位置的指针，如果s中不存在c则返回NULL。

strcmp

   原型：extern int strcmp(char *s1,char * s2);
   用法：#include
   功能：比较字符串s1和s2。
   说明：
         当s1         当s1=s2时，返回值=0
         当s1>s2时，返回值>0

stricmp,strcmpi

   原型：extern int stricmp(char *s1,char * s2);
   用法：#include
   功能：比较字符串s1和s2，但不区分字母的大小写。
   说明：strcmpi是到stricmp的宏定义，实际未提供此函数。
         当s1         当s1=s2时，返回值=0
         当s1>s2时，返回值>0

strcpy

   原型：extern char *strcpy(char *dest,char *src);
   用法：#include
   功能：把src所指由NULL结束的字符串复制到dest所指的数组中。
   说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
         返回指向dest的指针。

strcspn

   原型：extern int strcspn(char *s1,char *s2);
   用法：#include
   功能：在字符串s1中搜寻s2中所出现的字符。
   说明：返回第一个出现的字符在s1中的下标值，亦即在s1中出现而s2中没有出现的子串的长度。

strdup

   原型：extern char *strdup(char *s);
   用法：#include
   功能：复制字符串s
   说明：返回指向被复制的字符串的指针，所需空间由malloc()分配且可以由free()释放。

strlen

   原型：extern int strlen(char *s);
   用法：#include
   功能：计算字符串s的长度
   说明：返回s的长度，不包括结束符NULL。

strlwr

   原型：extern char *strlwr(char *s);
   用法：#include
   功能：将字符串s转换为小写形式
   说明：只转换s中出现的大写字母，不改变其它字符。返回指向s的指针。

strncat

   原型：extern char *strncat(char *dest,char *src,int n);
   用法：#include
   功能：把src所指字符串的前n个字符添加到dest结尾处(覆盖dest结尾处的'\0')并添加'\0'。
   说明：src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
         返回指向dest的指针。

strncmp

   原型：extern int strcmp(char *s1,char * s2，int n);
   用法：#include
   功能：比较字符串s1和s2的前n个字符。
   说明：
         当s1         当s1=s2时，返回值=0
         当s1>s2时，返回值>0

strnicmp,strncmpi

   原型：extern int strnicmp(char *s1,char * s2，int n);
   用法：#include
   功能：比较字符串s1和s2的前n个字符但不区分大小写。
   说明：strncmpi是到strnicmp的宏定义
         当s1         当s1=s2时，返回值=0
         当s1>s2时，返回值>0

strncpy

   原型：extern char *strncpy(char *dest, char *src, int n);
   用法：#include
   功能：把src所指由NULL结束的字符串的前n个字节复制到dest所指的数组中。
   说明：
         如果src的前n个字节不含NULL字符，则结果不会以NULL字符结束。
         如果src的长度小于n个字节，则以NULL填充dest直到复制完n个字节。
         src和dest所指内存区域不可以重叠且dest必须有足够的空间来容纳src的字符串。
         返回指向dest的指针。

strpbrk

   原型：extern char *strpbrk(char *s1, char *s2);
   用法：#include
   功能：在字符串s1中寻找字符串s2中任何一个字符相匹配的第一个字符的位置，空字符NULL不包括在内。
   说明：返回指向s1中第一个相匹配的字符的指针，如果没有匹配字符则返回空指针NULL。

strrev

   原型：extern char *strrev(char *s);
   用法：#include
   功能：把字符串s的所有字符的顺序颠倒过来（不包括空字符NULL）。
   说明：返回指向颠倒顺序后的字符串指针。

strset

   原型：extern char *strset(char *s, char c);
   用法：#include
   功能：把字符串s中的所有字符都设置成字符c。
   说明：返回指向s的指针。

strstr

   原型：extern char *strstr(char *haystack, char *needle);
   用法：#include
   功能：从字符串haystack中寻找needle第一次出现的位置（不比较结束符NULL)。
   说明：返回指向第一次出现needle位置的指针，如果没找到则返回NULL。

strtok

   原型：extern char *strtok(char *s, char *delim);
   用法：#include
   功能：分解字符串为一组标记串。s为要分解的字符串，delim为分隔符字符串。
   说明：首次调用时，s必须指向要分解的字符串，随后调用要把s设成NULL。
         strtok在s中查找包含在delim中的字符并用NULL('\0')来替换，直到找遍整个字符串。
         返回指向下一个标记串。当没有标记串时则返回空字符NULL。

strupr

   原型：extern char *strupr(char *s);
   用法：#include
   功能：将字符串s转换为大写形式
   说明：只转换s中出现的小写字母，不改变其它字符。返回指向s的指针。

书呆子 2010-09-13 19:46 发表评论

字符串循环移位问题

书呆子 — Mon, 13 Sep 2010 11:40:00 GMT

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

//向右循环移位
void loopmover ( char * pstr, int steps )
{
    int n = strlen(pstr) - steps;
    char *buff=(char*)malloc(strlen(pstr)+1);
    strcpy(buff,pstr+n);
    strncat(buff,pstr,n);
    buff[strlen(pstr)]='\0';
    strcpy(pstr,buff);
    free(buff);
}

//向左循环移位
void loopmovel ( char * pstr, int steps )
{
    char *buff=(char*)malloc(strlen(pstr)+1);
    strcpy(buff,pstr+steps);
    strncat(buff,pstr,steps);
    buff[strlen(pstr)]='\0';
    strcpy(pstr, buff);
    free(buff);
}

int main ()
{
    char a[]="abcdefg123456";
    printf("%s\n",a);
    loopmover(a,5);//右移5位
        printf("%s\n",a);
    loopmovel(a,5);
        printf("%s\n",a);
    system("PAUSE");
    return 0;
}

运行结果：

C库函数中字符串处理函数集合：

http://www.cppblog.com/GUO/archive/2010/09/13/126522.html

书呆子 2010-09-13 19:40 发表评论

[转]单链表反转问题

书呆子 — Sun, 12 Sep 2010 15:57:00 GMT

原文：http://nkshili.spaces.live.com/blog/cns!BB418D20B454CBE7!1489.entry

/*
两种方法，一种是直接把每个位置都倒转，最后头节点指向本来是尾巴的节点，另一个是每次拿到一个节点都插入到头节点后。
*/

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

//结点类型定义
typedef struct Node
{
int number; //数据域
struct Node *next; //指针域
}*PtrNode

//第一个方法：

void reverse_link_1(PtrNode link)
{

PtrNode first,second,ptr;
if(link->next==NULL)
{

return;

}
ptr=link->next;
first=ptr->next;
ptr->next=NULL;
while(ptr!=NULL)
{

if(first==NULL)
{

link->next=ptr;
break;

}
else
{

second=first->next;
first->next=ptr;
ptr=first;
first=second;

}

}

//第二个方法：

void reverse_link_2(PtrNode link)
{

PtrNode ptr,temp;
if(link->next==NULL)
{

return;

}
ptr=link->next;
while(ptr->next!=NULL)
{

temp=ptr->next;
ptr->next=ptr->next->next;
temp->next=link->next;
link->next=temp;

}

}

void fill_link(PtrNode link)
{

PtrNode ptr,temp;
int i;
ptr=link;
for(i=0;i<10;i++)
{

temp=(PtrNode)malloc(sizeof(struct Node));
temp->number=i;
temp->next=NULL;
ptr->next=temp;
ptr=ptr->next;

}

}

void print_link(PtrNode link)
{

PtrNode ptr=link->next;
printf("Link:\n");
while(ptr!=NULL)
{

printf("%d\t",ptr->number);
ptr=ptr->next;

}
printf("\n");

}

void free_link(PtrNode link)
{

PtrNode ptr=link;
while(ptr->next!=NULL)
{

PtrNode temp=ptr->next;
ptr->next=temp->next;
free(temp);

}

}

int main()
{

PtrNode head;
head=(PtrNode)malloc(sizeof(struct Node));
head->next=NULL;
head->number=-1;
fill_link(head);

print_link(head);

reverse_link_1(head);

print_link(head);

reverse_link_2(head);

print_link(head);

free_link(head);

print_link(head);

free(head);
system("PAUSE");
return 0;

}
运行结果:

书呆子 2010-09-12 23:57 发表评论

括号匹配问题(C++、堆栈)

书呆子 — Sun, 12 Sep 2010 15:11:00 GMT

/*
括号匹配问题，比较经典，利用堆栈来实现(摘自internet)

1. 括号匹配的四种可能性：

①左右括号配对次序不正确
②右括号多于左括号
③左括号多于右括号
④左右括号匹配正确

2. 算法思想：

顺序扫描算数表达式（表现为一个字符串），当遇到三种类型的左括号时候让该括号进栈；
当扫描到某一种类型的右括号时，比较当前栈顶元素是否与之匹配，若匹配，退栈继续判断；
若当前栈顶元素与当前扫描的括号不匹配，则左右括号配对次序不正确；
若字符串当前为某种类型的右括号而堆栈已经空，则右括号多于左括号；
字符串循环扫描结束时，若堆栈非空（即堆栈尚有某种类型的左括号），则说明左括号多于右括号；
否则，括号配对正确。

3. 程序实现：
*/
#include <iostream>
using namespace std;

#define maxsize 100

struct sStack
{
     char sign[maxsize];
     int top;
};

int InitsStack(sStack &SS)
{
     SS.top=-1;
     return 1;
}

int IsEmptysStack(sStack &SS)
{
     if(SS.top==-1)
         return 1;
     return 0;
}

int PushsStack(sStack &SS,char c)
{
     SS.sign[++SS.top]=c;
     return 1;
}

int UpsStack(sStack &SS)
{
    if(IsEmptysStack(SS))
    {
         cout<<"栈空"<<endl;
         return 0;
    }
    SS.top--;
    return 1;
}

char TopsStack(sStack &SS)
{
    if(IsEmptysStack (SS))
    {
         cout <<"栈空"<<endl;
         return 0;
    }
    return SS.sign[SS.top];
}

int main()
{
     string s;
     cout<<"输入表达式：";
     cin>>s;
     int length=s.length();
     int i;
     sStack SS;
     InitsStack(SS);
     for(i=0;i<length;++i)
     {
           if(s[i]=='('||s[i]=='['||s[i]=='{')
                    PushsStack(SS,s[i]);
           else if(s[i]==')'&&!IsEmptysStack(SS)&&TopsStack(SS)=='(')
                UpsStack(SS);
           else if(s[i]==')'&&!IsEmptysStack(SS)&&TopsStack(SS)!='(')
                    cout<<"括号匹配次序不正确"<<endl;
           else if(s[i]==']'&&!IsEmptysStack(SS)&&TopsStack(SS)=='[')
                    UpsStack(SS);
           else if(s[i]==']'&&!IsEmptysStack(SS)&&TopsStack(SS)!='[')
                    cout<<"括号匹配次序不正确"<<endl;
           else if(s[i]=='}'&&!IsEmptysStack(SS)&&TopsStack(SS)=='{')
                    UpsStack(SS);
           else if(s[i]=='}'&&!IsEmptysStack(SS)&&TopsStack(SS)!='{')
                    cout<<"括号匹配次序不正确"<<endl;
           else if((s[i]==')'||s[i]==']'||s[i]=='}')&&IsEmptysStack(SS))
                    cout<<"右括号多于左括号"<<endl;
     }
     if(!IsEmptysStack(SS))
           cout<<"左括号多于右括号"<<endl;
     else if(i=(length-1)&&IsEmptysStack(SS))
           cout<<"括号匹配正确"<<endl;

     system("PAUSE");
     return 0;
}

书呆子 2010-09-12 23:11 发表评论

[转]C++头文件包含内容概览

书呆子 — Fri, 10 Sep 2010 04:44:00 GMT

原文：http://developer.51cto.com/art/201002/183607.htm

我们在这里主要从C、传统 C++；标准 C++以及C99 增加等方面来为大家总结了C++头文件的各种类型，以方便大家将来的应用。

C++中对于头文件的应用是一个比较复杂的步骤，其中有很多比较重要的内容值得我们去不断的学习。在这里我们先来为大家总结一下C++头文件中的各种类型，以方便大家将来的应用。

C++头文件之C、传统 C++

#include < assert.h> //设定插入点
#include < ctype.h> //字符处理
#include < errno.h> //定义错误码
#include < float.h> //浮点数处理
#include < fstream.h> 　 //文件输入／输出
#include < iomanip.h> 　 //参数化输入／输出
#include < iostream.h> 　//数据流输入／输出
#include < limits.h> //定义各种数据类型最值常量
#include < locale.h> //定义本地化函数
#include < math.h> 　//定义数学函数
#include < stdio.h> //定义输入／输出函数
#include < stdlib.h> //定义杂项函数及内存分配函数
#include < string.h> //字符串处理
#include < strstrea.h> 　//基于数组的输入／输出
#include < time.h> 　//定义关于时间的函数
#include < wchar.h> //宽字符处理及输入／输出
#include < wctype.h> //宽字符分类

C++头文件之标准 C++　（同上的不再注释）

#include < algorithm> 　 //STL 通用算法
#include < bitset> 　//STL 位集容器
#include < cctype>
#include < cerrno>
#include < clocale>
#include < cmath>
#include < complex> //复数类
#include < cstdio>
#include < cstdlib>
#include < cstring>
#include < ctime>
#include < deque> 　 //STL 双端队列容器
#include < exception> 　 //异常处理类
#include < fstream>
#include < functional> 　//STL 定义运算函数（代替运算符）
#include < limits>
#include < list> //STL 线性列表容器
#include < map> //STL 映射容器
#include < iomanip>
#include < ios> //基本输入／输出支持
#include < iosfwd> 　//输入／输出系统使用的前置声明
#include < iostream>
#include < istream> //基本输入流
#include < ostream> //基本输出流
#include < queue> 　 //STL 队列容器
#include < set> //STL 集合容器
#include < sstream> //基于字符串的流
#include < stack> 　 //STL 堆栈容器
#include < stdexcept> 　 //标准异常类
#include < streambuf> 　 //底层输入／输出支持
#include < string> 　//字符串类
#include < utility> //STL 通用模板类
#include < vector> 　//STL 动态数组容器
#include < cwchar>
#include < cwctype>
using namespace std;

C++头文件之C99 增加

#include < complex.h> //复数处理
#include < fenv.h> //浮点环境
#include < inttypes.h> //整数格式转换
#include < stdbool.h> //布尔环境
#include < stdint.h> 　//整型环境
#include < tgmath.h> 　//通用类型数学宏

书呆子 2010-09-10 12:44 发表评论

重庆市第六届程序设计大赛试题

书呆子 — Sun, 05 Sep 2010 16:56:00 GMT

摘要: v\:* {behavior:url(#default#VML);} o\:* {behavior:url(#default#VML);} w\:* {behavior:url(#default#VML);} .shape {behavior:url(#default#VML);} Normal 0 7.8 磅 0 2 false false false ... 阅读全文

书呆子 2010-09-06 00:56 发表评论

数据结构——线性表

书呆子 — Sun, 30 May 2010 16:53:00 GMT

摘要: Win32控制台程序, 练习 list.hCode highlighting produced by Actipro CodeHighlighter (freeware)http://www.CodeHighlighter.com/-->#ifndef _LIST_H#define _LIST_H#define LIST_INIT_SIZE 1... 阅读全文

书呆子 2010-05-31 00:53 发表评论

C++博客-书呆子 的 notepad-随笔分类-数据结构与算法

字符串反回首字母大写

[转]C库函数中字符串处理函数集合

字符串循环移位问题

C库函数中字符串处理函数集合：

[转]单链表反转问题

括号匹配问题(C++、堆栈)

[转]C++头文件包含内容概览

重庆市第六届程序设计大赛试题

数据结构——线性表

C++博客-书呆子的 notepad-随笔分类-数据结构与算法