论坛 › 编程技术 › 逆向学习第14天_字符数组代码练习及多种冒泡排序法

Guido 发表于 2020-10-28 09:28:04

逆向学习第14天_字符数组代码练习及多种冒泡排序法

本帖最后由 Guido 于 2020-11-10 10:00 编辑

1.編写以下函数，求字符串数组的长度：
int StringLength（char str[]）#include<stdio.h>
int StringLength(char str[])
{
      int i = 0;
      while (str)
      {
                i++;
      }
      return i;
}
int main()
{
      char s;
      int a;
      printf("请输入一组少于31个字符的字符串\n");
      scanf_s("%s", s, sizeof(s));                  //这里一定要用%s控制符，这样才能表示连续输入一串，刚开始自己用了%c出错了
      a=StringLength(s);
      printf("%d", a);
      return 0;
}

2.编写以下函数，将字符串在数组内反序：
void Reverse（char str[]）#include<stdio.h>
void Reverse(char str[])
{
      int i=0;
      int j=0;
      char c;
      while (str) //先计算数组中的元素个数，不包括\0
      {
                i++;
      }
      while (--i>j)      //1 2 3 4 5   
      {
                c = str;
                str = str;
                str = c;
                j++;
      }
}
int main()
{
      char s;
      scanf_s("%s", s, sizeof(s));
      Reverse(s);
      puts(s);
      return 0;
}

3.编写以下函数，将字符串数组内的所有小写字母转为大写：
void StringUpper（char str[])
#include<stdio.h>
void StringUpper(char str[])
{
      int i = 0;
      while (str)
      {
                i++;
      }
      while (i--)
      {
                if (str >= 'a'&&str <= 'z')
                {
                        str -= ('a' - 'A');
                }
      }
}
int main()
{
      char s;
      scanf_s("%s", s, sizeof(s));
      StringUpper(s);
      puts(s);
      return 0;
}

4.编写以下函数，将带入的n个数组元素按从小到大排序：。
void Sort（int array[]，int n）

#include<stdio.h>
#include<stdlib.h>
void Sort(int s[], int len)
{
      int j = 0;
      int t;
      while (--len)
      {
                j = 0;
                while (j<len)
                {
                        if (s > s)
                        {
                              t = s;
                              s = s;
                              s = t;
                        }
                        j++;
                }
      }
}
int main()
{
      int a = {1,3,2,4,5,0,123,3,0,9};
      int len=_countof(a);
      Sort(a,len);
      return 0;
}


//由小到大排列，从右边推到左边
#include<stdio.h>
void sort2(int p[], int nLen)
{
      int i = 0;
      int t = 0;
      int j = nLen-1;
      int k = -1;
      while (j)   
      {
                i = nLen-1;
                ++k;                //设置k是为了限制内层循环的次数
                while (i>k)//内存循环
                {
                        if (p < p)
                        {
                              t = p;
                              p = p;
                              p = t;
                        }
                        i--;
                }
                j--;
      }
}
int main()
{
      int a[] = { 9,8,7,6,5,4,3,2,1,0 };
      int b = 10;
      sort2(a, b);
      return 0;
}
5.编写4种置泡排序函数，使用数组作参数：分别将最大值最小值推回头部或尾部。
（在main函数或全局区定义一个数组，作为实际参数调用4种排序函数进行测试）
注意：数组在做实际参数时，在被调函数中不能通过sizeof或者countof来测量元素个数；
因此，每个排序函数中要将数组的元素个数通过参数传递到被调函数；
例如：
void sort1（int p[]，int nLen）
void sort2（int p[]，int nLen）
void sort3（int p[]，int nLen）
void sort4（int p[]，int nLen）
.......
//由小到大排列，从左边推到右边
#include<stdio.h>
void sort1(int p[], int nLen)
{
      int i = 0;
      int t = 0;
      while (--nLen)   //外层循环一定要先自身减减，因为数组下标是从0开始的
      {
                i = 0;
                while (i < nLen)//内存循环
                {
                        if (p > p)
                        {
                              t = p;
                              p = p;
                              p = t;
                        }
                        i++;
                }
      }
}
int main()
{
      int a[] = { 9,9,7,6,5,4,3,2,1,0 };
      int b = 10;
      sort1(a, b);
      return 0;
}

//由大到小排列，从左边推到右边
#include<stdio.h>
void sort1(int p[], int nLen)
{
      int i = 0;
      int t = 0;
      while (--nLen)   //外层循环一定要先自身减减，因为数组下标是从0开始的
      {
                i = 0;
                while (i < nLen)//内存循环
                {
                        if (p < p)
                        {
                              t = p;
                              p = p;
                              p = t;
                        }
                        i++;
                }
      }
}
int main()
{
      int a[] = { 0,1,2,3,4,5,6,7,8,9 };
      int b = 10;
      sort1(a, b);
      return 0;
}

//由大到小排列，从右边推到左边
#include<stdio.h>
void sort2(int p[], int nLen)
{
      int i = 0;
      int t = 0;
      int j = nLen-1;
      int k = -1;
      while (j)   
      {
                i = nLen-1;
                ++k;                //设置k是为了限制内层循环的次数
                while (i>k)//内存循环
                {
                        if (p > p)
                        {
                              t = p;
                              p = p;
                              p = t;
                        }
                        i--;
                }
                j--;
      }
}
int main()
{
      int a[] = { 0,1,2,3,4,5,6,7,8,9 };
      int b = 10;
      sort2(a, b);
      return 0;
}
6.编写一个函数在字符串内查找一个字符：
int StringFind（char str[]，char c）
查找不到就返回-1：
查找到学符串内包含这个字符，返回的是0到n的数字。
代表这个学符距离字符串头的相对位置，如果字符串第一个元素就是要查找的字符返回0。
在main函数中定义一个学符串数组，输入一些文学后调用查找函数测试。
//查找某一个字符串中是否包含某个字符，存在则返回所在位置，不存在这返回-1
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
int StringFind(char str[], char c)
{
      int i = 0;
      while (str)
      {
                if (str == c)
                {
                        printf("\n%c在字符串%s中的位置为%d", c, str, i);
                        return i;
                }
                i++;
      }
      return -1;
}
int main()
{
      char str;
      char c;
      int a;
      printf("请输入小于32个字符的字符串\n");
      scanf_s("%s", str, sizeof(str));
      printf("请输入想要查找的字符\n");
      fflush(stdin);
      c = getchar();
      a=StringFind(str, c);
      return 0;
}
7.编写函数：
void StringUpper（char str[]）
void StringLower（char str[]）
在main函数中定义一个字符串数组，输入一些文字后调以上两个函数：
将实际参数内的文字全部变成大写或者小写。
#include<stdio.h>
void StringLower(char str[])
{
      int i = 0;
      while (str)
      {
                i++;
      }
      while (i--)
      {
                if (str >= 'A'&&str <= 'Z')
                {
                        str += ('a' - 'A');
                }
      }
}
int main()
{
      char s;
      scanf_s("%s", s, sizeof(s));
      StringLower (s);
      puts(s);
      return 0;
}

8.阅读翻译以下字符串操作函数，
strlen

strcpy

strcat

strcmp

strstr

strtok

strupr

strlwr

strchr

仔细测试这些函数的功能，思考自己能否编写代码实现以上函数的功能。

roger 发表于 2020-10-28 14:46:42

第三条格式出问题了，你看一下代码

Guido 发表于 2020-10-28 20:21:00

roger 发表于 2020-10-28 14:46
第三条格式出问题了，你看一下代码

好的好的，改过来啦

查看完整版本: 逆向学习第14天_字符数组代码练习及多种冒泡排序法