总结１

C语言：编程思想、算法、数据结构

1. 数据类型：
     基本数据类型：整形, 浮点型 -> 存储方式不一样
     空类型：void
     指针类型：1. 地址的概念(随机访问) 2. 指针类型对象存储地址 3. 指针本身的类型，访问该地址后，当作什么类型看待 4. 指针特殊类型：数组指针 函数指针
     自定义类型：结构体 联合体

2. 代码结构：顺序结构，分支结果，循环结构

3. 函数：1. 函数声明 2. 函数定义 3. 函数调用 4. 控制转移

4. 内存：
     linux内核 动态分配 静态分配
     内核：1g 不可访问(非必要)
     动态：堆(非必要) 栈(必要)
     静态：.text 代码段 .data 数据段 .bss bss段(静态存储区)

代码在内存存放区域的例子

#include <stdio.h>

void fun(int data)
{
	printf("%d\n", data);
}

int var;

int main(void)
{
	int a = 0;
	printf("%p %p %p %p\n", fun, "1223", &var, &a);
	return 0;
}

  程序运行结果如下图，虽然运行了很多次，但是存放在静态区的代码地址都没有动过，而存放在栈中的地址就变了。

	//int指针数组
	//int* arr[10];

	//函数指针数组
	//void (*arr[10])(void);

	//数组指针
	//int (*arr)[10];

	//函数指针数组指针
	//void (*(*arr)[10])(void);
	//(*arr)[0]();

结构体字节对齐：
  最大对齐32位 4 64位 8 16位 2 128位 16
  具体对齐多少，根据结构体成员最大的跟1号最大对齐中，小的那个
  结构体成员排布，根据对齐量单元塞数据的形式排布，塞不下则下个单元
  塞的时候，不能跨一半

结构体字节对齐例子

斐波那契数列

#include <stdio.h>
//方法一
int fibonacci1(int n)
{
	if(n < 3)	return 1;

	return fibonacci1(n - 1) + fibonacci1(n - 2);//指数级别 时间o(n) 空间o(n)
}

//方法二
int fibonacci2(int n)
{
	if(n < 3) return 1;

	int arr[n];
	arr[0] = 1;
	arr[1] = 1;

	int i;
	for(i = 2; i < n; i++){
		arr[i] = arr[i-1] + arr[i-2];
	}

	return arr[n-1];
}

//方法三
int fibonacci3(int n)
{
	static int arr[1000];

	if(n < 3) return 1;
	if(arr[n - 1] > 0) return arr[n-1];

	int num1 = (arr[n-2] > 0 ? arr[n-2] : fibonacci3(n - 2));
	int num2 = (arr[n-3] > 0 ? arr[n-3] : fibonacci3(n - 3));

	arr[n-1] = num1 + num2;

	return arr[n-1];
}

int main(void)
{
	int i = 0;
    for(i = 1; i <= 10; i++){
        printf("%d ", fibonacci1(i));
    }
    printf("\n");

    for(i = 1; i <= 10; i++){
        printf("%d ", fibonacci2(i));
    }
    printf("\n");

    for(i = 1; i <= 10; i++){
        printf("%d ", fibonacci3(i));
    }
    printf("\n");

	return 0;
}

字符串中，打印所有回文子串

算法：时间复杂度 空间复杂度
有效的，有限的，无二义性，解决问题
时间复杂度、空间复杂度o(n) -> 次数
算法：

1. 二分法
2. 动态规划
3. 递归
4. 贪婪算法
5. 回溯法
6. 暴力法

动态规划：后面的计算，利用前面的计算结果，省略重复计算

用暴力法求所有回文子串

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

void printChar(const char* str, int left, int right)
{
	for(; left <= right; left++){
		putchar(str[left]);
	}
	putchar('\n');
	return;
}

int isPalindrome(const char* str, int left, int right)
{
	while(left < right){
		if(str[left] != str[right]) return 0;
		left++;
		right--;
	}

	return 1;
}

void printPalindromes(const char* str)
{
	int i = 0, j = 0;
	int len = strlen(str);
	//i表示right - left
	for(i = 0; i < len; i++){
		for(j = 0; j < len - i; j++){
			if(isPalindrome(str, j, j + i)) printChar(str, j, j + i);
		}
	}
}

int main(void)
{
	char str[] = "ababababa";
	printPalindromes(str);

	return 0;
}

用动态规划方法求所有回文的子串

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

void printChar(const char* str, int left, int right)
{
	for(; left <= right; left++) putchar(str[left]);
	putchar('\n');
}

void printPalindromes(const char* str)
{
	int len = strlen(str);
	int palindromesStatus[len][len];//二维数组
	memset(palindromesStatus, 0, sizeof(palindromesStatus));
	//[left][right] 是否为回文 1 是 0 不是

	int i = 0, j = 0;
	for(i = 0; i < len; i++){//right - left 宽度
		for(j = 0; j < len - i; j++){
			if(i == 0){
				//宽度为1,肯定是
				palindromesStatus[j][j+i] = 1;//是回文
				printChar(str, j, j + i);
			}else if(i == 1){
				if(str[j] == str[j+1]){
					//回文
					palindromesStatus[j][j+i] = 1;//是回文
					printChar(str, j, j + i);
				}else{
					//不是回文
				}
			}else{
				if(str[j] == str[j + i] && palindromesStatus[j+1][j+i-1] == 1/*j+1 ~ j+i-1是回文*/){
					palindromesStatus[j][j+i] = 1;//是回文
					printChar(str, j, j + i);
				}
			}
		}
	}

	return;
}

int main(void)
{
	char str[] = "abababaaba";
	printPalindromes(str);

	return 0;
}