算法入门第一课

1-1 位运算

打印一个整数的二进制

#include <iostream>
using namespace std;

// 打印一个数的32位二进制
// 一个整型的底层就是32进制，32位，long型是64位
void printBin(int num)
{
	for (int i = 31; i >= 0; i--)
	{
		cout << ((num & (1 << i)) == 0 ? "0" : "1");
		// 1 << i ：是1向左移动 i 位，一个数左移，就是右边拿 0 来补
	}
	cout <<  endl;
}

int main()
{
	int test = 8;
	printBin(test);
	printBin(test << 1);  // 一个数左移一位就相当于这个数乘以2

	return 0;
}

负数的另一种表示
~N+1 = -N

	int c = 5;
	int d = (~c + 1);  // 等价于 d = -c

	cout << c << endl;
	cout << d << endl;

1-2 什么是算法

1. 有具体的问题
2. 有设计解决这个问题的具体流程
3. 有评价处理流程的可量化指标

1-3 算法的分类

• 明确知道怎么算的流程
• 明确知道怎么尝试的流程

1-4 求一个数的阶乘累加

long fun(int N)  // 计算一个数阶乘的累加值
{
	long ans = 0;  // 记录总和
	long cur = 1;  // 先记录 1 的阶乘
	for (int i = 1; i <= N; i++)
	{
		cur = cur * i;
		ans += cur;
	}
	return ans;
}

1-5 选择排序

给一个数组，从小到大排好序

• 0-N-1 上选出最小值（遍历一遍数组，比较N-1次），放到0位置
• 1-N-1 上选出最小值（遍历一遍数组，比较N-2次），放到1位置
• 2-N-1 上选出最小值（遍历一遍数组，比较N-3次），放到2位置
• …
  时间复杂度O(N^2)。

#include <iostream>
using namespace std;


void SelectSort(int arr[], int len) 
{
	for (int i = 0; i < len; i++)  
	{
		int mindex = i;
		for (int j = i + 1; j < len; j++) 
		{
			if (arr[j] < arr[mindex])
				mindex = j;
		}
		int temp = arr[mindex];  //交换
		arr[mindex] = arr[i];
		arr[i] = temp;
		for (int m = 0; m < len; m++) /// 每找到一个最小值，打印当前数组
			cout << arr[m] << " ";
		cout << endl;
	}
}


int main()
{ 
	int arr[] = { 5, 4, 3, 2, 6, 1 };
	int len = sizeof(arr) / sizeof(arr[0]);
	SelectSort(arr, len);


	return 0;
}

1-6 冒泡排序

找最大值，从小到大排序

• 0和1之间谁大谁往后，7和3交换。3 7 2 1 7 6 5 3
• 1和2之间谁大谁往后，2和7交换。3 2 7 1 7 6 5 3
• 2和3之间谁大谁往后，1和7交换。3 2 1 7 7 6 5 3
• 3和4之间谁大谁往后，不交换。3 2 1 7 7 6 5 3
• 4和5之间谁大谁往后，6和7交换。3 2 1 7 6 7 5 3
• 5和6之间谁大谁往后，7和5交换。3 2 1 7 6 5 7 3
• 6和7之间谁大谁交换，7 和3交换。3 2 1 7 6 5 3 7
• 找到第一轮的最大值，第一轮结束。
• 1和2之间谁大谁交换，，，以此类推
• 0~N-1
• 0~N-2
• 0~N-3
• 。。。等差数列，时间复杂度O(N^2).

#include <iostream>
using namespace std;

void swapNum(int arr[],int a, int b)  //交换函数
{
	int temp = arr[a];
	arr[a] = arr[b];
	arr[b] = temp;
}

void printArr(int arr[],int len)
{
	for (int i = 0; i < len; i++)
	{
		cout << arr[i] << " ";
	}
	cout << endl;
}


void bubbleSort(int arr[], int len)
{
	if (arr == NULL || len < 2)  // 数组为空或数组元素小于2，不需要排序
		return;
	// 0~N-1
	// 0~N-2
	// 0~N-3
	for (int end = len - 1; end >= 0; end--) // 0~i 上遍历
	{
		// 0~end 上，两两去比较
		// 0 1，1 2 ，2 3，  end-1 end.
		for (int second = 1; second <= end; second++)
		{
			if (arr[second - 1] > arr[second]) // 前一个数比自己大，交换
				swapNum(arr, second - 1, second);
		}
	}
}


int main()
{ 
	int arr[] = { 5, 4, 3, 2, 6, 1 };
	int len = sizeof(arr) / sizeof(arr[0]);
	bubbleSort(arr, len);
	printArr(arr, len);

	return 0;
}

1-7 插入排序

• 让0和0位置有序，自然有序，比较0次
• 让0和1位置有序，1的位置往前看，比前面的数小，交换，3来到0位置，再往前看，没数了，结束，0到1范围上有序，3 4 1 2 5 2 1 6 4 （比较1次）
• 让0到2范围有序，0到1范围已经有序了，标志位来到2位置，2位置数往前看，比前面的数小就交换，1 3 4 2 5 2 1 6 4 （比较2次）
• 0到3范围有序，0到2范围已经有序了，标志位来到3位置，3位置的数往前看，比前面的数小就交换，1 2 3 4 5 2 1 6 4 （比较3次）
• 。。。
• 0~N-2范围有序
• 0~N-1范围有序 （比较N-1次），等差数列，时间复杂度O(N^2)

void insertSort(int arr[], int len)
{
	if (arr == NULL || len < 2)  // 数组为空或数组元素小于2，不需要排序
		return;
	// 0~0 默认完成
	// 0~1 , 0~2, 0~N-1 ,结尾位置在变，定义变量表述结尾
	for (int end = 1; end < len; end++)
	{
		int curNumIndex = end;  // 当前的标志位在end位置，前面的是已经排好序的
		 
	    // 标志位在end位置，先看end-1位置的数, 
		// end-1>=0说明左边有数，继续比较
	    // 左边有数，而且还比自身大，才需要交换
		while (curNumIndex -1>=0 && arr[curNumIndex -1] > arr[curNumIndex])
		{
			swapNum(arr, curNumIndex - 1, curNumIndex);
			curNumIndex--;// 标志位的数和左边交换了，所以要向左移动
		}
	}
}

1-8 优化插入排序

void insertSort(int arr[], int len)
{
	if (arr == NULL || len < 2)  // 数组为空或数组元素小于2，不需要排序
		return;
	// 0~0 默认完成
	// 0~1 , 0~2, 0~N-1 ,结尾位置在变，定义变量表述结尾
	for (int end = 1; end < len; end++)
	{
		// pre 是标志位的前一个位置，标志位一开始在end上
		// pre>=0 说明有前一个位置，左边有数
		for (int pre = end - 1; pre >= 0 && arr[pre] > arr[pre + 1]; pre--)
		{
			swapNum(arr, pre, pre + 1);
		}

	}

}