一些简单算法C语言实现

最新推荐文章于 2024-07-13 13:36:16 发布

Proudyzh

最新推荐文章于 2024-07-13 13:36:16 发布

阅读量837

点赞数 19

文章标签：算法数据结构 c语言

本文链接：https://blog.csdn.net/proud_yang/article/details/135912503

版权

文章探讨了在处理大数字符串时的累加操作，包括字符转数字、关系判断、字符串移动和逆序，以及进制转换、素数检测、数组去重、中心索引查找、平方根计算、链表逆转和斐波那契数列计算的方法。还涉及PAT字符计数问题的解决方案。

摘要由CSDN通过智能技术生成

数字字符串累加求和

当输入一个数特别大以致于long数据类型也无法存储，则使用字符串存储，如果是数字字符串对每一个元素及进行累加，需要使求和数 - ‘0’，ASCII码才对应正确，即如下
```
char a[];
for(int i=0;i<strlen(a);i++){
 sum += a[i] - '0';
}
```

判断数组后面元素与选定元素的关系

需要找x元素后面的元素是否和他存在某种关系（比如相等，比如某个f(x)函数的值存在），不要使用双重循环嵌套去判断对比，可以开一个标记数组使得

 //考虑先初始化mark数组为-1;
 memset(mark,-1,sizeof(mark));
 mark[x] = 0;//即mark数组中的下表为x的值为0
 //去遍历mark数组,若为0则是有效元素,然后采取砍数的思想
 mark[f(x)] = 1;
 //最后mark数组剩下为0的下标即为与x元素没有关系的元素

字符串循环左（右）移或者字符串逆序输出

封装一个reverse函数专用于倒换,一般循环右移这类的问题调用reverse函数三次即可

void reverse(char *a,int l,int r){ //l表示低位,r表示高位
    for(int i=0;i<(r-l+1)/2;i++){
        int temp = a[l+i];
        a[l+i] = a[r-i];
        a[r-i] = temp;
    }
}

数字字符串给定n输出含有的n组成一个数

比如3567865 n=6 输出66 因为该数字含有两个6

这种情况下，第一反应是划分字符串，按位划分然后再组成一个数。方法应该是通过while循环，对数字字符串s进行对10的取余即可得到最后一个位数的值，然后把s除以10，即可除去s的最高位，通过循环即可依次得到每一位的值，从后到前，然后把得到的位数*10+自身就是所求结果

本题要求计算 A/B，其中 A 是不超过 1000 位的正整数，B 是 1 位正整数。你需要输出商数 Q 和余数 R，使得 A=B×Q+R 成立

因为A的位数过多，所以只能用字符串存储，采用切割数的方法每次输出进行除法后的值，并更新余数，若切割的值小于除数，则直接将除数赋给余数

#include <stdio.h>
#include <string.h>
int main(){
  int b,p,q;// q为余数
  char a[1001];
  scanf("%s %d", a, &b);
  int length = strlen(a);
  for(int i=0;i<length;i++){
    p = (a[i] - '0') + q * 10; //切割字符串取得值
    if(p >= b){
      printf("%d",p/b);
      q = p % b;
    }else{ //单个位小于除数
      if(length == 1)
        printf("0"); //a为小于b的一位数
      else if(i)
        printf("0");
      q = p; //然后进一个位两个位除以除数
    }
  }
  printf(" %d", q);
  return 0;
}

十进制数转换为任意进制数

char letter[16]={'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
void change(int d,int k) { //k进制
  	int r=0;
   	r=d%k;
   	d=d/k;
   	if(d!=0) change(d,k);
   	printf("%c",letter[r]);
}

任意进制转化为十进制

int change(char* s, int k) { //k进制
	int len = strlen(s);
	int ans = 0;
	int digit = 1; //表示位数
	for (int i = len - 1;i >= 0;i--) {
		if (s[i] >= 'A') ans += (s[i] - '0' - 7) * digit; //通过-7将A转为数字10
		else ans += (s[i] - '0') * digit; //通过-'0'可以将数字转为ascii码
		digit *= k;
	}
	return ans;
}

统计n内的素数（挨筛法）

解决暴力搜索会存在很多重复搜索的数，只要有合数即把数组标记设为true

int eratosthenes(int n){
  boolean isPrime[]; //数组全设为false,false代表素数
  int count = 0;
  for(int i=2;i<n;i++){
		if(!isPrime[i]){
      count++;
      for(int j=i*i;j<n;j+=i){ //j自增表示i*2i/3i一直自增寻找
        isPrime[j] = true;
      }
    }
  }
  return count;
}

原地删除数组中的重复数字，最后返回数组长度

原地删除即不能开辟新的数组，采用双指针，j属于快指针，遇到不等的时候i，j同时向前，遇到相等的数i不变，j自增，并把j指向的数赋给i的后一位

int removeDuplicates(int n[]){
  if(strlen(nums) == 0){
    return 0;
  }
  int i=0;
  for(int j=1;j<strlen(nums);j++){
    if(nums[j] != nums[i]){
      i++;
      nums[i] = nums[j];
    }
  }
  return i+1;
}

寻找数组中某一个下标，使得左右两边元素之和相等,该下标即为中心索引

先统计出整个数组的总和，然后从第一个元素开始叠加，总和递减当前元素，叠加递增当前元素，直到两个值相等

int pivotIndex(int sum,int nums[]){
  int sumCurr = 0; //代表目前元素的总和
  for(int i=0;i<strlen(nums);i++){
    sumCurr += nums[i];
    if(sum == sumCurr){
      return i;
    }
    sum = sum - nums[i];
  }
  return i;
}

返回x的平方根最大的整数

二分查找

int binarySearch(int x){
  int index=-1,l=0,r=x;
  while(l<=r){
    int mid=l+(r-l)/2;
    if(mid*mid<=x){
      index=mid;
      l=mid+1;
    }else{
      r=mid-1;
    }
  }
  return index;
}

牛顿迭代法

double sqrt(double i,int x){
  double res=(i+x/i)/2; //数学公式
  if(res == i){
    return i;
  }else{
    return sqrt(res,x);
  }
}

链表逆转

迭代法

ListNode iterate(ListNode head){
  ListNode prev=null,next;
  ListNode curr=head;
  while(curr != null){
    next = curr.next; //保存next
    curr.next = prev; //给下一个指针赋值
    prev = curr; //保存curr
    curr = next; //指针后移
  }
  return null;
}

递归法

ListNode recursion(ListNode head){
  if(head==null||head.next==null){
    return head;
  }
  ListNode new_head=recursion(head.next);
  head.next.next=head;
  head.next=null;
  return new_head;
}

斐波那契数列（给定一个num，返回下标为num的斐波那契数）

去重递归

int recurse(int num){
  int arr[num+1];
  if(num == 0){
    return 0;
  }
  if(num == 1){
    return 1;
  }
  if(arr[num] != 0){ 
    return arr[num];
  } //这一步就是去重操作
  arr[num] = recurse(arr,num-1)+recurse(arr,num-2);
}

双指针迭代

int iterate(int num){
	if(num == 0){
    return 0;
  }
  if(num == 1){
    return 1;
  }
  int low = 0,high = 1;
  for(int i=2;i<=num;i++){
    int sum = low+high;
    low = high;
    high = sum;
  }
  return high;
}

逆序输出字符串

int reverse(int *a){
  int length = sizeof(a)/sizeof(int);
  int temp;
  for(int i=0;i<length/2;i++){
    temp = a[i];
    a[i] = a[length-1-i];
    a[length-1-i] = temp;
  }
}

输出n范围内的完数

所谓完数,即除本身以外的所有因数相加得该数,如6有因数1,2,3,6=1+2+3

void perfect(int n){
	int cnt;
	for(int i=1;i<n;i++){
		cnt=0;
		for(int j=1;j<i;j++){ //j为因子
			if(i%j==0)
			cnt+=j;
		}
		if(cnt==i)
		printf("完数为%d\n",i);
	}
}

给定一个字符串，只包含PAT三个字符，求输出该字符串可以组成多少个PAT

如APPAPT，一共可以组成2个PAT

char s[100001];
	int P[100001] = { 0 }, T[100001] = { 0 };
	gets(s);
	int length = strlen(s);
	long long sum = 0;
	for (int i = 0; i < length;i++) {
		if (i != 0) P[i] = P[i - 1]; //依次往后赋值
		if (s[i] == 'P') P[i]++; //当前位置左边有多少个P
	}
	for (int j = length - 1;j > 0;j--) {
		T[j] = T[j + 1]; //依次向前赋值
		if (s[j] == 'T') T[j]++; //当前位置右边有多少个T
	}
	for (int k = 0;k < length;k++) {
		if (s[k] == 'A') sum += P[k] * T[k];
	}
	printf("%lld", sum);

Proudyzh

关注

19
点赞
踩
20

收藏

觉得还不错? 一键收藏
0
评论
一些简单算法C语言实现

方法应该是通过while循环，对数字字符串s进行对10的取余即可得到最后一个位数的值，然后把s除以10，即可除去s的最高位，通过循环即可依次得到每一位的值，从后到前，然后把得到的位数*原地删除即不能开辟新的数组，采用双指针，j属于快指针，遇到不等的时候i，j同时向前，遇到相等的数i不变，j自增，并把j指向的数赋给i的后一位。因为A的位数过多，所以只能用字符串存储，采用切割数的方法每次输出进行除法后的值，并更新余数，若切割的值小于除数，则直接将除数赋给余数。数字字符串给定n输出含有的n组成一个数。
复制链接

扫一扫