C++

用C语言中的strtok 函数来进行分割

#include <string.h>
#include <stdio.h>
 
int main(){
    char s[] = "a,b*c,d";
    const char *sep = ",*"; //可按多个字符来分割
    char *p;
    p = strtok(s, sep);
    while(p){
        printf("%s ", p);
        p = strtok(NULL, sep);
    }
    printf("\n");
    return 0;
}
//输出: a b c d

struct大小的确定

struct test
{
	int a;
	char b;
	int c;
}TEST;

其大小为4+4+4 = 12b

struct test
{
	int a;
	char b;
	char d;
	char e;
	char f;
	int c;
}TEST;

其大小为4+(1+1+1+1)+4 = 12b

struct test
{
	int a;
	char b;
	int c;
	char d;
}TEST;

其大小为4+4+4+4 = 16b

struct test
{
	char a;
}TEST;

其大小为1b

struct test
{
	char a;
	char b;
}TEST;

其大小为2b,说明如果前面的字节+后面的字节不超过内存对齐所需要的字节，是不会用0填充的。实际多少个字节就是多少个字节。

strlen、strcpy的实现

int _strlen(const char* str)
{
	if (!str || *str == 0) return 0;
	int len = 0;
	while (*str++)++len;
	return len;
}

char* _strcpy(char* d, const char* s)
{
	if (!s || *s == 0) return d ? &(*d = 0) : NULL; //防止d未初始化乱码
	char* td = d;
	if (d) while (*d++ = *s++); //防止d为NULL
	return td;
}

最大子数组的和问题–线性算法

int maxSubArray( int* array, int length)
{
    int boundry = array[0];
    int maxArray = array[0];
    for( int i=1; i<length; ++i )
    {
        if( boundry+array[i] >= array[i] ) 
            boundry += array[i];
        else
            boundry = array[i];
        if( maxArray < boundry )
            maxArray = boundry; 
    }
    return maxArray;
}

#include<iostream>
using namespace std;
int main()
{
    int a[] = {1,-2,3,10,-4,7,2,-48};
    int num = sizeof(a)/sizeof(a[0]);
    int result = maxSubArray(a, num);
    cout<<"result:"<<result<<endl;//输出结果为18

    int b[] = {3,-1,5,-1,9,-20,21,-20,20,21};
    num = sizeof(b)/sizeof(b[0]);
    result = maxSubArray(b, num);
    cout<<"result:"<<result<<endl;//输出结果为42
    return 0;
}

给定一个数组，值全是正数，请返回累加和为给定值k的最长子数组长度。

public static int getMaxLength(int[] arr, int k) {
		if (arr == null || arr.length == 0 || k <= 0) {
			return 0;
		}
		int left = 0;
		int right = 0;
		int sum = arr[0];
		int len = 0;
		while (right < arr.length) {
			if (sum == k) {
				len = Math.max(len, right - left + 1);
				sum -= arr[left++];
			} else if (sum < k) {
				right++;
				if (right == arr.length) {//边界判断
					break;
				}
				sum += arr[right];
			} else {
				sum -= arr[left++];
			}
		}
		return len;
	}

给定一个数组，值可以为正、负和0，请返回累加和为给定值k的最长子数组长度。

public static int maxLength(int[] arr, int k) {
		if (arr == null || arr.length == 0) {
			return 0;
		}
		HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(0, -1); // important
		int len = 0;
		int sum = 0;
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i];
			if (map.containsKey(sum - k)) {
				len = Math.max(i - map.get(sum - k), len);
			}
			if (!map.containsKey(sum)) {
				map.put(sum, i);
			}
		}
		return len;
	}

————————————————
版权声明：本文为CSDN博主「acme」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_18297675/article/details/77075245