数据结构与算法学习

一、算法之美

如果说数学是皇冠上的一颗明珠，那么算法就是这颗明珠上的光芒，算法让这颗明珠更加熠熠生辉，为科技进步和社会发展照亮了前进的路。数学是美学，算法是艺术。走进算法的人，才能体会它的魅力。
多年来，我有一个梦想，希望每一位提到算法的人，不再立即紧皱眉头，脑海闪现枯燥的公式、冗长的代码；希望每一位阅读和使用算法的人，体会到算法之美，像躺在法国普罗旺斯小镇的长椅上，呷一口红酒，闭上眼睛，体会舌尖上的美味，感受鼻腔中满溢的薰衣草的芳香……

1.1打开算法之门

程序=数据结构+算法
数据结构是程序的骨架，算法是程序的灵魂。
算法是指对特定问题求解步骤的一种描述。
例，在我们的生活中，算法无处不在。我们每天早上起来，刷牙、洗脸、吃早餐，都在算着时间，以免上班或上课迟到；去超市购物，在资金有限的情况下，考虑先买什么、后买什么，算算是否超额；在家中做饭，用什么食材、调料，做法、步骤，还要品尝一下咸淡，看看是否做熟。所以，不要说你不懂算法，其实你每天都在用！

算法具有以下几个特征。

1. 有穷性: 算法是由若干条指令组成的有穷序列，总是在执行若干次后结算，不可能永无停止。
2. 确定性: 每条语句有确定的意义，无歧义。
3. 可行性: 算法在当前环境条件下可以通过有限次运算实现。
4. 输入输出: 有零个或多个输入，一个或多个输出。

好算法的标准如下。

1. 准确性: 正确性是指算法能够满足具体问题的需求，程序运行正常，无语法错误， 能够通过典型的软件测试，达到预期的需求。
2. 易读性: 算法遵循标识符命名规则，简洁易懂，注释语句恰当适量，方便自己和他人阅读，便于后期调试和修改。
3. 健壮性: 算法对非法数据及操作有较好的反应和处理。例如，在学生信息管理系 统中登记学生年龄时，若将 21 岁误输入为 210 岁，系统应该提示出错。
4. 高效性： 高效性是指算法运行效率高，即算法运行所消耗的时间短。算法时间复杂度就是算法运行需要的时间。现代计算机一秒钟能计算数亿次，因此不能用秒来具体计算算法消耗的时间，由于相同配置的计算机进行一次基本运算的时间是一定的，我们可以用算法基本运算的执行次数来衡量算法的效率。因此，将算法基本运算的执行次数作为时间复杂度的衡量标准。
5. 低存储性: 低存储性是指算法所需要的存储空间低。对于像手机、平板电脑这样的嵌入式设备，算法如果占用空间过大，则无法运行。算法占用的空间大小称为空间复杂度。

1.2算法复杂度

1. 时间复杂度O(n)：算法运行需要的时间，一般将算法的执行次数作为时间复杂度的度量标准。
2. 空间复杂度O(n)：算法占用的空间大小。一般将算法的辅助空间作为衡量空间复杂度的标准。空间复杂度的本意是指算法在运行过程中占用了多少存储空间。算法占用的存储空间包括：
   （1） 输入/输出数据；
   （2） 算法本身；
   （3） 额外需要的辅助空间。
   输入/输出数据占用的空间是必需的，算法本身占用的空间可以通过精简算法来缩减， 但这个压缩的量是很小的，可以忽略不计。而在运行时使用的辅助变量所占用的空间，即辅助空间是衡量空间复杂度的关键因素。
3. 算法复杂度排序：
   О(1)< О(logn)< О(n)< О(nlogn) < О(n^2)< О(n^3)< О(2^n) < О(n!)< О(n^n)
   我们在设计算法时要注意算法复杂度增量的问题，尽量避免爆炸级增量。

1.3入门算法案例

1. 经典的斐波那契数列(兔子问题)

//斐波那契数列3中算法-->兔子繁殖数列 
#include<iostream>
#include<ctime>
using namespace std;

//1.递归算法 
long long fun1(int n){
   if(n<1)
   	return -1;
   if(n==1 || n == 2)
   	return 1;
   else{
   	return fun1(n-1)+fun1(n-2);
   }
}

//2.动态规划 
long long fun2(int n){
   
   long long a[n+1];
   
   a[1] = 1;
   a[2] = 1;
   
   for(int i = 3;i <= n;i++){
   	a[i] = a[i-1] + a[i-2];
   	cout<<a[i]<<endl;
   }
   
   return a[n]; 
   
} 

//3.辗转相加 
long double fun3(int n){
   long double s1 = 1,s2 = 1;
   
   for(int i = 3;i <= n;i++){
   	s2 = s1 + s2;
   	s1 = s2 - s1; 
   	cout<<s2<<endl;
   }
   
   return s2;
}

int main(){
   int n; 
   time_t s,e,sumtime;
   cin>>n;
   s = clock();
   cout<<fun1(n)<<endl;
   cout<<fun2(n)<<endl;
   cout<<fun3(n)<<endl;
   e = clock();
   sumtime = e-s;
   cout<<"time:"<<sumtime<<endl;
   return 0;
} 

2. 算法复杂度
   (1).时间复杂度：递归O (2ⁿ) > 动态规划O(n) = 辗转相加O(n);
   (2).空间复杂度：递归O(n) = 动态规划O(n)>辗转相加O(1);

3. 总价：辗转相加法的时空复杂度最低，所有效率最高。

二、神奇的链表

• 链表是一系列的存储数据元素的单元通过指针串接起来形成的，因此每个单元至少有两个域，一个域用于数据元素的存储，另一个或两个域是指向其他单元的指针。这里具有一个数据域和多个指针域的存储单元通常称为节点（node）。
• 链表的第一个节点和最后一个节点，分别称为链表的头节点和尾节点。尾节点的特征是其 next 引用为空（null）。链表中每个节点的 next 引用都相当于一个指针，指向另一个节点，借助这些 next 引用，我们可以从链表的头节点移动到尾节点。
• 链表数据结构中主要包含单向链表、双向链表及循环链表。
• 缺点：
  1、比顺序存储结构的存储密度小 (每个节点都由数据域和指针域组成，所以相同空间内假设全存满的话顺序比链式存储更多)。
  2、查找结点时链式存储要比顺序存储慢（每个节点地址不连续、无规律，导致按照索引查询效率低下）。
  优点：
  1、插入、删除灵活 (不必移动节点，只要改变节点中的指针，但是需要先定位到元素上)。
  2、有元素才会分配结点空间，不会有闲置的结点。

一、单链表

#include<iostream>
#include<string>
#include<iomanip>
#include<stdlib.h>

using namespace std;

//单链表的定义 
typedef struct LNode{
	int data;
	struct LNode *next;
}LNode,*LinkList;

//初始化 
bool InitList_L(LinkList &L){
	L = new LNode;
	if(!L)
		return false;
	L -> next = NULL;
	return true;
}

//头插法创建单链表 
void CreateList_H(LinkList &L){
	
	int n;

	cout<<"请输入要插入的元素个数："<<endl;
	cin>>n;
	cout<<"头插法..."<<endl; 
	cout<<"请输入"<<n<<"个元素："<<endl; 
	while(n--){
		LinkList s = new LNode;
		cin>>s->data;
		s->next = L->next;
		L->next = s;
	}
		
}

//尾插法创建单链表 
void CreateList_R(LinkList &L){
	int n;
	LinkList s,r;
	r = L;
	cout<<"请输入要插入元素个数:"<<endl; 
	cin>>n;
	cout<<"尾插法..."<<endl; 
	cout<<"请输入"<<n<<"个元素："<<endl; 
	while(n--){
		s = new LNode;
		cin>>s->data;
		s->next = NULL;
		r->next = s;
		r=s;
	}
	
}

//遍历单链表 
void PrintList_L(LinkList L){
	LinkList p;
	p = L->next;
	
	while(p){
		cout<<p->data<<"\t";
		p = p->next;
	}
	cout<<endl;
}

//删除单链表结点 
bool DelList_L(LinkList L,int i){
	LinkList p,q;
	p = L;
	int m = 0;
	while(p->next && m < i-1){
		p = p->next;
		m++;
	}
	
	if(!(p->next) || m > i-1)
		return false;
	q = p->next;
	p->next = q->next;
	delete q;
	return true;
	
}


//插入结点 
bool InsertList_L(LinkList L,int i,int data){
	
	int m = 0;
	LinkList p,s;
	p = L;
	while(p && m < i-1){
		p = p->next;
		m++;
	}
	if(!p || m > i-1)
		return false;
	s = new LNode;
	s->data=data;
	s->next = p->next;
	p->next = s;
	
	return true;
}

//按值查找结点 
bool QueryList_v(LinkList L,int data,int &i){
	int n=0;
	LinkList p;
	p = L;
	while(p->next){
		n++;
		p=p->next;
		if(p->data==data){
			i = n;
			return true;
		} 
	}
	
	return false;
}

//按位置查找结点 
bool QueryList_id(LinkList L,int i,int &data){
	
	int n = 1;
	LinkList p;
	p=L;
	
	while(p->next && n <= i){
		
		p = p->next;
		if(n == i){
			
			data = p->data;
			return true;
		}
		n++;
	}
	
	return false;

}

int main(){
	
	int choose = -1,i=0,data=0;
	LinkList L;
	if(!InitList_L(L)){
		cout<<"单链表初始化失败!"<<endl;
		choose = 0;
	}
	cout<<"0.退出"<<endl;
	cout<<"1.头插法"<<endl;
	cout<<"2.尾插法"<<endl;
	cout<<"3.单链表遍历"<<endl;
	cout<<"4.删除元素"<<endl;
	cout<<"5.添加元素"<<endl;
	cout<<"6.按值查找"<<endl;
	cout<<"7.按位元素"<<endl;
	while(choose != 0){
		cout<<"请输入选择的序号：";
		cin>>choose;
		switch(choose){
			case 1:
				CreateList_H(L);
				cout<<"插入成功！"<<endl;
				break;
			case 2:
				CreateList_R(L);
				cout<<"插入成功！"<<endl;
				break;
			case 3:
				cout<<"单链表输出："<<endl; 
				PrintList_L(L);
				break;
			case 4:
				cout<<"请输入要删除的位置i:"<<endl;
				cin>>i;
				if(DelList_L(L,i)){
					cout<<"删除成功！"<<endl; 
				} else{
					cout<<"删除失败！"<<endl; 
				}
				break;
			case 5:
				cout<<"请输入要插入元素的位置i和数据data:"<<endl;
				cin>>i>>data;
				if(InsertList_L(L,i,data)){
					cout<<"添加成功！"<<endl; 
				}else{
					cout<<"添加失败！"<<endl; 
				}
				break;
			case 6:
				cout<<"请输入要查找的元素data:"<<endl;
				cin>>data;
				if(QueryList_v(L,data,i)){
					cout<<"查找成功！"<<endl;
					cout<<"第"<<i<<"位"<<endl; 
				}else{
					cout<<"查找失败！"<<endl;
				}
				break; 
			case 7:
				cout<<"请输入要查找的位置i:"<<endl;
				cin>>i;
				if(QueryList_id(L,i,data)){
					cout<<"查找成功!"<<endl;
					cout<<"data:"<<data<<endl;
				}else{
					cout<<"查找失败!"<<endl;
				}
				break;	 
		}
	}
	
	
}