【数据结构与算法】链表

#include<iostream>
#include<cstdlib>
#include<string>
#include<string.h>
#include<algorithm>
#include<vector>
using namespace std;

struct ListNode{
	int value;
	ListNode *p_Next
}; 
void AddToTail(ListNode** pHead, int value){
	ListNode* pNew = new ListNode();
	pNew->value =value;
	pNew->p_Next =NULL;
	
	if(*pHead==NULL){
		*pHead =pNew;
	}
	else{
		ListNode* pNode = *pHead;
		while(pNode->p_Next != NULL)
			pNode=pNode->p_Next;
			
		pNode->p_Next =pNew;
	}
}

int main(){
	//freopen("1.a","r",stdin);
	//freopen("2.a","w",stdout);
	
	/*
	链表中每一个元素存有两个值，一个值是指向下一个元素的指针，另一个值是数据
	链表的第一个元素称为对头，最后一个元素称为队尾，存储链表时只需要记住对头元素的地址（指针）即可
	在链表中查找，访问一个元素的复杂度是O(n)
	如果已经定位好了需要插入或删除的元素，插入删除是O(1)
	链表支持：查找第i个元素，删除第i个元素，在位置i插入一个元素
	
	双向链表：在链表基础上，记录指向队尾的尾指针，此外每个元素多记录一个指向前一个元素的指针 
	*/
	
	
	return 0;
}

#include<iostream>
#include<list>
using namespace std;


/*
链表由一系列的结点组成，结点包含两个域，一个数据域，一个指针域
链表内存：
	非连续，添加删除元素，时间复杂度都是常数项，不需要移动元素，比数组添加删除效率高

链表需要额外的空间保持结点关系，前驱后继 前一个结点的指针next指向下一个结点的地址 
链表最后的结点中的指针(next) 指向为空 
*/ 


/*
push_back(elem);    //在容器尾部加入一个元素 
pop_back();			//删除容器最后一个元素 
push_front(elem);
pop_front();
insert(pos,elem);		//在pos位置插入elem元素的拷贝，返回新数据的位置 
insert(pos,n,elem);		//在pos位置插入n个elem数据，无返回值 
insert(pos,beg,end);		//在pos位置插入[beg，end)区间的数据，无返回值 
clear();
erase(beg,end);			//删除[beg，end)区间的数据，返回下一个数据的位置 
erase(pos);				//删除pos位置的数据，返回下一个数据的位置 
remove(elem);			//删除容器中 所有 与elem值相匹配的元素 

size
empty
resize(num) 
resiz(num,elem) 
*/

void test1()
{
	list<int> l;
	list<int> l2(10,10);		//(10 个 10)
	list<int> l3(l2);
	list<int> l4(l2.begin(),l2.end());
	
	for(list<int>::iterator i=l4.begin();i!=l4.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	
	l.push_back(100);
	l.push_back(200);
	l.insert(l.begin(),300);
	l.insert(l.end(),400);
	
	list<int>::iterator it=l.begin();
	it++;
	it++;
	l.insert(++l.begin(),500);		//++可以，但l.begin+2之类就不可以 ，这里的第一个参数是const_iterator 
	l.insert(it,1000);		//注意，这里的it用的begin和现在的begin不一样 
	for(list<int>::iterator i=l.begin();i!=l.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	
	l.pop_back();
	l.pop_front();
	l.erase(l.begin(),--l.end());
	for(list<int>::iterator i=l.begin();i!=l.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	l.push_back(233);
	l.push_back(200);
	l.remove(200);
	for(list<int>::iterator i=l.begin();i!=l.end();i++)
		cout<<*i<<" ";
	cout<<endl;
}

//assign,swap,=
void test2(){
	list<int> l;
	l.assign(2,10);
	list<int> l2;
	l2.push_back(3);
	l2.push_back(24);
	l2.push_back(1);
	l2.push_back(1);
	l2.push_back(9);
	list<int> l3;
	l3=l; 
	
	l2.reverse();
	for(list<int>::iterator i=l2.begin();i!=l2.end();i++)
		cout<<*i<<" ";
	cout<<endl;\
	l2.reverse();
	for(list<int>::iterator i=l2.begin();i!=l2.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	l2.sort();
	for(list<int>::iterator i=l2.begin();i!=l2.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	
}
/*
reverse();			//反转列表
sort();			//list排序 
*/

void test3(){
	list<int> l;
	int a[5]={2,3,4,5,6};
	l.assign(&a[1],&a[3]);      //取地址，则属于beg到end，结果是3,4
	l.assign(a[1],a[3]);      //不取地址，则属于n个elem，结果是5,5,5, 
	for(list<int>::iterator i=l.begin();i!=l.end();i++)
		cout<<*i<<" ";
	cout<<endl;
}

//排序，默认从小到大
bool count(int x,int y){
	return x>y;
}
void test4(){
	list<int> l;
	int a[12]={2,3,4,5,6,6,3,24,7,1,3,2};
	l.assign(&a[1],&a[9]);
	for(list<int>::iterator i=l.begin();i!=l.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	l.sort(count);		//********* 
	for(list<int>::iterator i=l.begin();i!=l.end();i++)
		cout<<*i<<" ";
	cout<<endl;
	//从大到小排序
	//对对象排序可以参考这个 
	
} 

//算法里提供的sort   只支持可随机访问的容器 
//list不支持随机访问，所以不能+5，+3什么的 
//对象排序 
int main(){
	
	
	test4();
	return 0;
}