算法实现笔记（持续更新）

最新推荐文章于 2022-05-02 09:13:55 发布
最新推荐文章于 2022-05-02 09:13:55 发布
阅读量307 收藏
点赞数
分类专栏： 复习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39521181/article/details/97302070
版权

 

冒泡排序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
static void  bubble_sort(int array[],int n)
{
    int i,j,tmp;
    for(j=0;j<n-1;j++)
    {
        for(i=0;i<n-1-j;i++)
        {
            if(array[i]>array[i+1])
            {
                tmp = array[i];
                array[i] = array[i+1];
                array[i+1] = tmp;
            }
        }
    
    }
 
 
    
}
int main (int argc, char **argv)
{
   int a[6] = {5,2,6,4,1,3};
   bubble_sort(a,6);
   int i = 0;
   for(i;i<6;i++)
       printf("%d\n",a[i]);
   return 0;
 
}

strstr （判断子串）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
const char *my_strstr(const char *str,const char *sub_str)
{
    int i;
    for(i=0;str[i]!='\0';i++)
    {
        int tmp = i;
        int j=0;
        while(str[i++]==sub_str[j++])
        {
            if(sub_str[j]=='\0')
                return &str[tmp];
        }
        i = tmp;
 
    }
    return NULL;
}
 
int main(void)
{
    char *s1="12345";
    char *s2="34";
    printf("%s\n",my_strstr(s1,s2));
}

 

strcpy（字符串复制）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
char *my_strcpy(char *dest, const char *src)
{
    assert(dest);
    assert(src);
    char *tmp = dest;
    while((*dest++=*src++)!='\0')
        ;
    return tmp;
}
int main(int argc, char ** argv)
{
    char a[10];
    char *b = "hello";
    printf("%s\n",my_strcpy(a,b));
    return 0;
}

 

strncpy（复制子串前n个字节）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
char *my_strncpy(char *dst, const char *src,size_t count)
{
    assert(dst&&src);
    char *tmp = dst;
    while(count)
    {
        if((*dst=*src)!=0)
        {
            dst++;
            src++;
        }
        count--;
    }
    *dst = '\0';
    return tmp;
}
int main()
{
    char a[5] = "hello";
    char *b = "12345";
    printf("%s\n",my_strncpy(a,b,6));
    
}

 

strcat（字符串连接）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
char *my_strcat(char *dest, const char *src)
{
    assert(dest);
    assert(src);
    char *tmp = dest;
    while(*dest)
        dest++;
    while((*dest++=*src++)!='\0')
        ;
    return tmp;
}
int main(int argc, char ** argv)
{
    char a[10] = "world";
    char *b = "hello";
    printf("%s\n",my_strcat(a,b));
    return 0;
}

 

strncat

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
char *my_strncat(char *dest, const char *src, size_t count)
{
    assert(dest);
    assert(src);
    char *tmp = dest;
    if(count)
    {
        while(*dest)
            dest++;
        while((*dest++=*src++)!='\0')
<span>	</span>{
            if(--count==0)
            {
                *dest = '\0';
                break;
            }
<span>	</span>}
    }
    return tmp;
}
int main(int argc, char ** argv)
{
    char a[10] = "world";
    char *b = "hello";
    printf("%s\n",my_strncat(a,b,3));
    return 0;
}

 

strcmp（字符串比较）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
int my_strcmp(const char *cs, const char *ct)
{
    assert(cs);
    assert(ct);
    unsigned char c1,c2;
    while(1)
    {
       c1 = *cs++; 
       c2 = *ct++; 
       if(c1!=c2)
           return c1 < c2 ? -1 : 1;
       if(!c1)
           break;
    }
    return 0;
}
int main(int argc, char ** argv)
{
    char a[10] = "gello";
    char *b = "hello";
    printf("%d\n",my_strcmp(a,b));
    return 0;
}

 

memmove：

#include<stdio.h>
#include<assert.h>
 
void my_memmove(void *p1,void const *p2,size_t count)
{	
        assert(p1);
	assert(p2);
	char *dest = (char *)p1;
	char *src = (char *)p2;
	if((dest > src) && (dest < src +count))  //判断内存重叠时的情况
	{
		while(count--)
		{
			*(dest + count) = *(src + count); 
		}
	}
	else       //判断不重叠是的情况
	{
		while(count--)
		{
			*dest++ = *src++;
		}
	return p1;
	}
}
 
int main()
{
	int arr1[10]={1,2,3,4,5,6,7,8,9,10};
	int i = 0;
	my_memmove(arr1+4,arr1+2,16);
	for(i=0;i<10;i++)
	{
		printf("%d ",arr1[i]);
	}
	printf("\n");
	return 0;
}

memcpy

void *memcpy(void *dest, const void *src, size_t count)
{
     char *tmp = dest;
     const char *s = src;
 
     while (count--)
         *tmp++ = *s++;
     return dest;
 }

字符串逆序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <assert.h>
 
char *reverse(char *dest, const char *src)
{
    assert(dest);
    assert(src);
    char *tmp = dest;
    int len,i;
    len = strlen(src);
    dest[len] = '\0';
    for(i=0;i<len;i++)
    {
        *(dest+i) = *(src+len-i-1);
    }
    
    return tmp;
}
int main(int argc, char ** argv)
{
    char a[10];
    char *b = "abcde";
    printf("%s\n",reverse(a,b));
    return 0;
}

二分法/折半法

#include<stdio.h>
//递归算法
int recurbinary(int *a, int key, int low, int high)
{
    int mid;
    if(low > high)
        return -1;
    mid = low + (high-low)/2;
    if(a[mid] == key) return mid;
    else if(a[mid] > key)
        return recurbinary(a,key,low,mid -1);
    else
        return recurbinary(a,key,mid + 1,high);
}
 
//非递归算法
int binary( int *a, int key, int n )
{
    int left = 0, right = n - 1, mid = 0;
    mid = left + (right - left) / 2;
    while( left < right && a[mid] != key )
    {
        if( a[mid] < key ) {
            left = mid + 1;
        } else if( a[mid] > key ) {
            right = mid;
        }
        mid = ( left + right ) / 2;
    }
    if( a[mid] == key )
        return mid;
    return -1;
}
int main()
{
    int a[] = {1,2,3,4,5,6,7,8,9,12,13,45,67,89,99,101,111,123,134,565,677};
    int b[] = {677,1,7,11,67};
    int i;
    for( i=0; i<sizeof(b)/sizeof(b[0]); i++ )
    {
        //printf( "%d\n", recurbinary(a, b[i],0,sizeof(a)/sizeof(a[0])-1) );
        printf( "%d\n", binary( a, b[i], sizeof(a)/sizeof(a[0])));
    }
    return 0;
}

volatile关键字

定义为volatile的变量表示该变量可能被意想不到的改变，使用该变量时，必须每次重新从内存中读取数据，而不是使用保存在寄存器中的备份。

eg：

（1）并行设备的硬件寄存器；如状态寄存器

（2）一个中断服务子程序中会访问的非自动变量；

（3）多线程应用中被几个任务共享的变量；

static关键字

  （1）函数体内static变量的作用范围为该函数体，不同于auto变量，该变量的内存只被分配一次，因此其值在下次调用时仍维持上次的值；  
  （2）在模块内的static全局变量可以被模块内所用函数访问，但不能被模块外其它函数访问；  
  （3）在模块内的static函数只可被这一模块内的其它函数调用，这个函数的使用范围被限制在声明它的模块内；

const关键字

  （1）欲阻止一个变量被改变，可以使用const关键字。在定义该const变量时，通常需要对它进行初始化，因为以后就没有机会再去改变它了；  
  （2）对指针来说，可以指定指针本身为const，也可以指定指针所指的数据为const，或二者同时指定为const；  
  （3）在一个函数声明中，const可以修饰形参，表明它是一个输入参数，在函数内部不能改变其值；  
  （4）对于类的成员函数，若指定其为const类型，则表明其是一个常函数，不能修改类的成员变量；
 

Saturnus.
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
machine-learning:常用机器学习算法实践笔记，持续更新！
05-23
常用机器学习算法的实现代码（Python），还包括一些具体的小Demo测试和其他python机器学习库（eg.sklearn...）的实践。 名称 目录 Linear Regression Perceptron KNN Naive Bayes Decision Tree Logisitc Regression...
字符串比较算法总结以及朴素字符串比较的实现
GJ_FB_dabai的专栏
03-14 1175
字符串比较算法几个基本算法: 1.朴素,基本用不到,复杂度O(n^2) 2.KMP,常用判断连续子串或者综合题,比较的题现在基本都是多串模式匹配,KMP就扯淡了~ O(m+n) 3.后缀树,后缀数组,多串匹配的好算法,O(nlog) 的预处理 O(1)的结果 4.trip 树 自动机,全文匹配的强大算法,研究中. 以前实现的一个朴素字符串比较,算不上什么算法,找找手感吧~
数据结构代码实现笔记
weixin_46032370的博客
05-02 87
线性表 插入 #include<iostream> #include<stdio.h> #include<stdlib.h> using namespace std; #define MAXSIZE 50//宏定义数据数组名字 typedef int ElemType;//把int型给命名成ElemType 型 typedef struct {//定义结构体 ElemType data[MAXSIZE];//结构体的数据数组 int length;//数据数组的长
算法提高 11-1实现strcmp函数
cyh
12-25 1989
问题描述 　　自己实现一个比较字符串大小的函数，也即实现strcmp函数。函数：int myStrcmp(char *s1,char *s2) 按照ASCII顺序比较字符串s1与s2。若s1与s2相等返回0，s1>s2返回1，s1 　　"A" 　　"a">"A" 　　"computer">"compare" 　　"hello" 样例输出 数据规模和约定 　　
实现strcmp非常easy的思维
weixin_34163553的博客
01-02 74
#define _CRT_SECURE_NO_WARNINGS #include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; void strcom(char *str1 , char *str2,int *num) { int a = 0; int count = 0; //关键在这里 用指针进行循环推断 while (*str1&amp;&a...
字符串操作汇总-持续更新中
梦想腾飞
08-27 1238
目录 1 char *strtok(char *s, char *delim). 2 char *strtok_r(char *s, const char *delim, char **ptrptr);2 2 extern char *strstr(char *str1, char *str2). 3 3 size_t strspn (const char *s,const
机器学习算法笔记.zip
04-08
机器学习是一门多领域交叉学科，涉及概率论、统计学、逼近论、凸分析、算法复杂度理论等多...总之，机器学习是一门具有广阔应用前景和深远影响的学科，它将持续推动人工智能技术的发展，为人类社会的进步做出重要贡献。
Android 工程师成长之路：JAVA算法的实现，数据结构 和 Android源码笔记等 分享.zip
03-14
社区活跃：Java有着全球范围内庞大的开发者社区和开源项目，持续推动技术进步和创新。 多线程支持：Java内建对多线程编程的支持，使并发编程变得更加简单直接。 动态性：Java可以通过反射、注解等机制实现在...
autoplait:AutoPlait（SIGMOD'14）的Python实现，无需平滑算法。 笔记
05-09
AutoPlait抽象的给定大量共同发展的多个时间序列，其中包含未知数量的不同持续时间的模式，我们如何才能有效地找到典型的模式和变化点？ 我们如何统计所有序列并实现有意义的分割？...笔记现在，此代码没有平滑算法。
C //习题 8.17 写一函数，实现两个字符串的比较。即自己写一个strcmp函数，函数原型为int strcmp(char *p1, char *p2)；
热门推荐
Made in Code
03-02 3万+
【代码】C //习题 8.17 写一函数，实现两个字符串的比较。即自己写一个strcmp函数，函数原型为int strcmp(char *p1, char *p2);
VB：编一个子过程DeleStr(s1,s2)，将字符串s1中出现的s2子字符串删去，结果存放在s1中
Caleb Sung的博客
05-02 6211
题目来源：大工慕课 链接 原题：Visual Basic程序设计教程（第二版）龚沛曾主编，高等教育出版社 实验6-8 作者：Caleb Sung 题目要求 编一个子过程DeleStr(s1,s2)，将字符串s1中出现的s2子字符串删去，结果存放在s1中。 例如：s1= “12345678AAABBDFG12345 ” S2= “234 ” 结果：s1= “15678AAABBDFG...
strcmp函数的实现
温故而知新
06-19 376
//p1 > p2 返回1 //p1 == p2 返回0 //p1 int mystrcmp(const char* p1,const char* p2) { if (p1 == NULL && p2) { return -1; } if (p1 && p2 == NULL) { return 1; } if (p1 == NULL && p2 == NULL) {
硬链接与软链接 (符号链接)的区别与联系
烬
08-15 7595
在linux系统中，链接分两种 ：一种被称为硬链接（Hard Link），另一种被称为符号链接或软链接（Symbolic Link）。 硬链接与软链接是 Linux 文件系统中的一个重要概念，其涉及文件系统中的索引节点 (index node 又称 inode)，而索引节点对象是 Linux 虚拟文件系统 (VFS) 的四个基本概念之一。通过剖析硬链接与软链接的联系与区别，我们可更好的了解 L...
在不使用临时变量的情况下交换两个变量的值(三种方法)
烬
07-29 5723
在做笔试题的时候遇到议一个比较有意思的题--如标题 实现方法有三种： 1.加减法 code： #include<stdio.h> int main() { int a=520,b=1314; printf("after:\n"); printf("a=%d,b=%d\n",a,b); a=a+b; b=a-b; a=a-b; printf("aft...
知识杂记（持续更新）
烬
07-23 349
进程间通信方式： 1. 信号 ( Sinal ) ： 信号是一种比较复杂的通信方式，用于通知接收进程某个事件已经发生； 2. 管道（Pipe）：管道是一种半双工的通信方式，数据只能单向流动，而且只能在具有亲缘关系（通常是指父子进程关系） 的进程间使用； 3. 命名管道FIFO：命名管道（Named Pipe）也是半双工的通信方式，但是它允许无亲缘关系进程间的通信; 4. 命名socket...
操作系统笔记
烬
05-23 239
章节一：绪论 主要讲解了操作系统为何产生以及发展。思考一下，刚开始把一堆CPU,内存，硬盘和鼠标键盘给你，你要怎么用起来，要想对他们进行各种协助就要一个东西来管理。最初的硬件是通过人工来管理的，特别选择女性来管理，因为各个插头的拔插和连接需要很细心。但是慢慢的发现这样很麻烦，就开始有脱机输入输出技术--》批处理技术--》操作系统。 现代操作系统最基本的特征是：并发和共享。 ...
infrared-remote-candroid studiodemo
最新发布
05-05
android studio下载
数据结构与算法c语言笔记
10-11
好的，下面是关于数据结构与算法c语言笔记的内容： C语言是一种常用的编程语言，也是许多算法和数据结构的实现语言之一。对于初学者来说，掌握一些基本的数据结构和算法是非常重要的。 常见的数据结构包括数组、...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值