数据结构与算法 入门学习 day1

数据结构的概念（逻辑结构与物理结构）

逻辑结构

彼此间的关系，应选择合适的结构。

1 集合结构

数据元素属于同一集合，彼此之间没有关系。

2 线性结构

数据元素彼此一一对应，呈现线的形状结构。

3 树形结构

数据元素存在层次关系，一上级对多下级。

4 图形结构

数据元素多对多，一种很灵活的逻辑结构。

物理结构（存储结构）

指数据的逻辑结构在计算机中的存储形式。

1.顺序存储结构

计算机开辟一段空间后，各数据元素按照定义时的顺序进行存储，逻辑结构与物理结构一致，不允许进行存储的改变。数组就是进行这种存储。

2.链式存储结构

为适应数据的变化与操作，数据元素被存储到任意单元中，存储关系与逻辑关系没有对应关系，比如说你用树、图、还是线性结构，你都可以用链式存储的方式，数据间的关联通过指针来实现。

算法的概念

时间复杂度

单纯的分支结构，即不包含循环结构的语句，其时间复杂度为O(1)。
常用时间复杂度从小到大顺序排列为：
O(1)<O(logn)<O(n)<O(nlogn)<O(n²)<O(n³)<O(2ⁿ)<O(n!)<O(nⁿ)

线性表

抽象数据类型的定义

数据成员：长度，头，尾
数据方法：
查找：
插入：
删除：
获取长度：
清空

1线性表的顺序存储结构：

一段连续地址，连续存取，每个数据占用固定的内存空间。

#include <iostream>
using namespace std;
class sxbb
{
private:
	int Maxsize;
	int Presize;
	int *Member;
public:
	void sxb_insert(int pos, const int& num);
	void sxb_delete(int pos, int *p);
	int sxb_search(const int& num);
	void sxb_show();
	sxbb(int size);
	~sxbb(){ delete[]Member; }
};
sxbb::sxbb(int size){
	Maxsize = size;
	Member = new int[size];
	Presize = 0;
}
void sxbb::sxb_insert(int pos, const int& num){
	if (Presize == Maxsize){
		cout << "Not enough space" << endl;
	}
	else if (pos > Presize + 1 || pos < 1)
	{
		cout << "Wrong position" << endl;
	}
	else{
		for (int i = Presize - 1; i >= pos - 1; i--)
			Member[i + 1] = Member[i];
		Member[pos - 1] = num;
		Presize++;
	}

}
void sxbb::sxb_delete(int pos, int* p){
	if (Presize == 0){
		cout << "No member can be deleted!" << endl;
	}
	else if (pos > Presize || pos<1){
		cout << "This Position is empty!" << endl;
	}
	else{
		*p = Member[pos - 1];
		for (int i = pos; i < Presize; i++)
			Member[i - 1] = Member[i];
		Presize--;

	}

}
int sxbb::sxb_search(const int& num){
	for (int i = 0; i < Presize; i++){
		if (Member[i] == num){
			return 1;
		}
	}
	return 0;
}
void sxbb::sxb_show(){
	for (int i = 0; i < Presize; i++)
	{
		cout << Member[i] << ' ';
	}
	cout << "顺序表数据如上所示" << endl;
	cout << "顺序表长度为" << Presize << endl;
}

2线性表的链式存储结构

#include <iostream>
using namespace std;
//复合式定义链表

//定义节点,首先声明Lb模板类
template<class T>
class Lb;

template<class T>
class LbNode{
public:
	friend class Lb<T>;//Lb为友元函数
	LbNode();
	LbNode(T data);
private:
	LbNode<T>* Next;//指向下一节点的指针
	T Data;//节点的数据
};

template<class T>
LbNode<T>::LbNode()
{
	Data = NULL;
	Next = NULL;
}
template<class T>
LbNode<T>::LbNode(T data){
	Data = data;
	Next = NULL;

}

//定义链表
template<class T>
class Lb{
public:
	void Lbinsert(T& node,int pos);//在第pos个节点后插入一个节点
	void Lbinserttail(const T&data);//在尾部插入
	void Lbdelete(int pos, T*p);//指定删除第pos个节点
	LbNode<T>* Lbgetpos(int pos);//取得第pos个节点的地址，默认头结点为0
	int Lbsearch(const T& data);//查找数据，返回pos
	void Lbgetdata(const LbNode<T>& node);//获取该节点的数据
	void Lbshow();
	Lb();
	~Lb();
private:
	LbNode<T>* Headptr;
	int Length;
};

template<class T>
Lb<T>::Lb()
{
	Headptr = new LbNode<T>;//初始化头指针
	Length = 0; 
}
//析构函数必须将每次动态创建的空间进行释放
template<class T>
Lb<T>::~Lb(){
	LbNode<T> *p = new LbNode<T>;
	p = Headptr;
	while (Length--)
	{
		delete p->Next;
	}
	delete p;
	delete Headptr;

}
//template<template T>
//void Lb<T>:: Lbcreate(){
//	cout << "请输入链表结点个数,并依次输入结点数据" << endl;
//	cin >> i;
//	for (int j = 1; j<i + 1; j++)
//	{
//		LbNode<T> p;
//		p->
//	}
//	
//}
template<class T>
void Lb<T>::Lbgetdata(const LbNode<T>& node){
	cout << node.Data<< endl;
}
template<class T>
LbNode<T>* Lb<T>::Lbgetpos(int pos){
	if (pos>Length  || pos < 0)
	{
		cout << "Out of range!" << endl;
	}
	int i = 0;
	LbNode<T>* p = Headptr;
	while (i < pos){
		p = p->Next;
		i++;
	}
	return p;
}
template<class T>
void Lb<T> ::Lbinsert(T& node, int pos)
{
	LbNode<T>* p;
	p = Lbgetpos(pos);
	LbNode<T>* tmp = new LbNode<T>;
	tmp->Data = node;
	tmp->Next = p->Next;
	p->Next = tmp;
	Length++;
}
template<class T>
void Lb<T> ::Lbinserttail(const T&data){
	LbNode<T>*p = Lbgetpos(Length);
	LbNode<T> *n=new LbNode<T>;
	n->Data = data;
	p->Next = n;
	n->Next = NULL;
	Length++;
}

template<class T>
void Lb<T> ::Lbshow(){
	LbNode<T> *p = new LbNode<T>;
	p = Headptr;
	int l = Length;
	while (l--)
	{
		p = p->Next;
		cout << p->Data << ' ';
	}
	cout << endl;
	p = NULL;
	delete p;
}
template<class T>
void Lb<T> ::Lbdelete(int pos, T*p){
	LbNode<T>*s = Lbgetpos(pos-1);
	LbNode<T>*tmp = s->Next;
	if (pos <=Length && pos>0){
		*p = tmp->Data;
		s->Next = s->Next->Next;
		tmp->Next = NULL;
	}
	Length--;
	delete tmp;
}
template<class T>
int Lb<T>::Lbsearch(const T& data){
	int i = 1;
	LbNode<T> *tmp = Headptr->Next;
	for (i = 1; i <= Length; i++)
	{
		
		if (tmp->Data == data){
			return i;
		}
		else tmp = tmp->Next;
	}

	return 0;

}