算法：解决特定问题求解步骤
1. 算法的设计：
1. 正确性：语法正确；合法的输入能得到合理的结果；对非法的输入，给出满足要求的规格说明；对精心选择，甚至刁难的测试都能正常运行，结果正确；
2. 可读性：便于交流，阅读，理解（高内聚，低耦合）；
3. 健壮性：输入非法数据，能进行相应的处理，而不是产生异常；
4. 高效率：运行时间短（时间复杂度低）
5. 低存储：（空间复杂度）
2. 算法时间复杂度：
执行这个算法所花时间的度量，时间复杂度越高，效率越低。
将数据量增长和时间增长用函数表示出来，这个函数就叫做时间复杂度。
一般用大O表示：O(n)——>时间复杂度是关于数据n的一个函数，随着n的增加，时间复杂度增长较慢的算法时间复杂度低。
3. 时间复杂度的计算规则：
1. 用常数1取代运行时间中的所有加法常数；
2. 在修改后的运行函数中，只保留最高阶项；
3. 如果最高阶存在且系数不是1，则去除这个项相乘的常数；
练习：
Fun(int a,int b) //3 -> 时间复杂度为O(1)
{Int tmp = a;A = b;B = tmp;
}for(i = 0; i < n; i++) //3n -> 时间复杂度为O(n)
{Int tmp = a;A = b;B = tmp;
}for(i = 1; i < n; i *= 2) //2^x = n 即1*2*2*2*2*2*2 < n 时间复杂度为O(logn)for(i = 0; i < n; i++) //时间复杂度为O(nlogn)
{for(i = 0; i < n; i *= 2) //时间复杂度为O(logn){}
}for(i = 0; i < n; i++) //3(n+1)*n/2 -> n^2 时间复杂度为O(n^2)
{for(j = i; j < n; j++){Int tmp = a;A = b; B = tmp; }
}时间复杂度排序：
O(1) < O(logn) < O(n) < O(nlogn) < O(n^2) < O(n^3) < O(2^n) < O(n!) < O(n^n)
4. 排序算法：
1. 冒泡排序：时间复杂度：O(n²)
void Bubble_Sort(int *parry, int len)
{int tmp = 0;for(int i = 0; i < len-1; i++){for(int j = 0; j < len-1-i; j++){if(parry[j] > parry[j+1]){tmp = parry[j];parry[j] = parry[j+1];parry[j+1] = tmp;}}}return;
}2. 选择排序：时间复杂度O(n²)
void Select_Sort(int *parry, int len)
{int tmp = 0;for(int i = 0; i < len-1; i++){for(int j = i+1; j < len; j++){if(parry[i] > parry[j]){tmp = parry[i];parry[i] = parry[j];parry[j] = tmp;}}}return;
}
3. 插入排序：时间复杂度O(n²)
void Insert_Sort(int *parry, int len)
{int tmp = 0;int j = 0;for(int i = 1; i < len; i++){tmp = parry[i];j = i;while(tmp < parry[j-1] && j > 0){parry[j] = parry [j-1];j--;}parry[j] = tmp;}return;
}4. 快速排序：时间复杂度O(nlogn)
void Qulik_Sort(int *parry, int head, int tail)
{if(head >= tail){return;}int i = head;int j = tail;int key = parry[i];while(i < j){while(i < j && key <= parry[j]){j--;}parry[i] = parry[j];while(i < j && key >= parry[i]){i++;}parry[j] = parry[i];}parry[i] = key;Qulik_Sort(parry, head, i-1);Qulik_Sort(parry, i+1, tail);
}注意：在一个待排的序列中，如果两个相同的数的相对位置没有改变，说明排序算法稳定，所以根据上诉排序算法原理可知：冒泡排序、插入排序是稳定的排序算法，选择排序、快速排序是不稳定的排序算法。
5. 二分查找：必须是一个有序序列才能使用，时间复杂度O(logn)
int Binary_Search(int *parry, int len, int data)
{int left = 0;int right = len-1;while(left <= right){int middle = left + (right-left)/2;if(data < parry[middle]){right = middle - 1;}else if(data > parry[middle]){left = middle + 1;}else{return middle;}}return -1;
}
