数据结构与算法之----线性表

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

1.1 顺序表的创建和遍历

#include "stdafx.h"
#include<iostream>
#include<string.h>
using namespace std;
struct Sqlist
{
	int *data;
	int length;
	int maxsize;
	Sqlist():length(0){}
};
void ListInsert(Sqlist &L,int i,int e)
{
	if(L.length==L.maxsize ||(i<0||i>L.length))//判断是否已满 或者i不在范围之内,但是要考虑到在末尾插入的情况
	{
		cout<<"out of range"<<endl;
		return;
	}
	for(int a=L.length;a>i;a--)
	{
		L.data[a]=L.data[a-1];
	}
	L.data[a]=e;
	L.length++;
}
void PrintList(Sqlist &L)
{
	for(int i=0;i<L.length;i++)
	{
		cout<<L.data[i];
	}
	cout<<'\n';
}
int _tmain(int argc, _TCHAR* argv[])
{
	Sqlist L;
	cout<<"请输入顺序表长度"<<endl;
	cin>>L.maxsize;
	L.data=new int[L.maxsize]();

	for(int i=0;i<5;i++)
	{
		int e;
		cin>>e;
		ListInsert(L,i,e);
	}
	PrintList(L);

}

输出：

请输入顺序表长度
10
8 7 6 5 4
87654
Press any key to continue

思想：

（1）注意在插入的时候，位置的选择，只能是在[0,length]上，否则会造成空隙，不好操作。

（2）这种游标方式，比书上的看起来更加方便，从尾部开始，用前面的值覆盖后面的值

（3）要注意判断是否满了的情况

（4）插入之后length++

1.2顺序表的删除

void DeleteList(Sqlist &L,int i,int &e)
{
	if(i<0 || i>=L.length)		
	{
		cout<<"out of range"<<endl;
		return;
	}
	else
	{
		e=L.data[i];
		for(int a=i;a<L.length-1;a++)
			L.data[a]=L.data[a+1];
		L.length--;  //千万不要忘了使 length-1，否则会出问题，因为原来数组末尾中的元素是没有删除的
	}

}

思想：

（1）千万不要忘记length--

（2）从i开始，利用后面的值覆盖前面的值

2、线性表的链式存储结构

2.1、线性表的整表创建、遍历、整表删除

#include "stdafx.h"
#include<iostream>
#include<string.h>
using namespace std;
struct Node
{
	int data;
	Node *next;
	Node():next(NULL),data(0){}
};
void CreateList(Node *L)//整表创建
{
	int a;
	while(1)//不要忘了这个1，这里的插入法无需用递归，因为不需要子操作就能完成
	{			
		cin>>a;
		if(a==8)return;
		Node *p=new Node();//前插法
		p->data=a;
		p->next=L->next;
		L->next=p;
	}

}

void PrintList(const Node *L)
{
	Node *p=L->next;//指向第一个
	while(p)
	{
		cout<<p->data;
		p=p->next;
	}
	cout<<'\n';
	
}

void EmptyList(Node *L)
{
	if(L->next)EmptyList(L->next);
	cout<<L->data;
	delete L;
}
int _tmain(int argc, _TCHAR* argv[])
{
	Node *L=new Node();
	CreateList(L);
	PrintList(L);
	EmptyList(L);
	return 0;

}

输出：

3 7 6 5 4 8
45673
376540Press any key to continue

思想：

（1）首先要创建表头，为了跟后面节点风格统一，头结点也用new来创建，那么整个链表就都可以用指针来传递，方便后面的删除递归操作。

（2）整表创建，这里可以用前插，或者后插法，利用while（1）循环来控制插入个数

（3）整表遍历，同样用while（not null），遍历链表即可。

（4）整表删除，用递归的方式，递归体为，若还有子节点，那么先删除子节点，再删除自己，注意这个是并列的操作，是一起完成的。递归出口，显然就是没有子节点了。

（5）while(p)和while(p->next)的区别是 前者最后p指向的是空的，而对于后者，指向的是最后一个元素。所以后者对于插入而言是不错的

2.2、链表的插入、删除操作

插入

void ListInsert(Node *L,int i,int e)
{
	Node *p=L;
	int j=0;
	while(j<i && p->next!=NULL)//同样要考虑在第0个和最后一个后面插入的情况，因此，指针指向插入前的位置
	{
		p=p->next;
		j++;
	}
	if(j==i)//若i在长度范围内，那么执行插入操作，这里的j相当于一个计数器，而且是在链表长度范围内的，因为有P的判断控制
	{
		Node *node=new Node;
		node->data=e;
		node->next=p->next;
		p->next=node;

	}
	else
		cout<<"out of range"<<endl;


}

思想：

（1）对于链表的操作，进行遍历的时候，一定要用另外一个指针来遍历，也就是说，不要改变原来指针的位置。

（2）while的判断，一般要判断其下一个是否为空，所以用p-next进行判断最好，即进行了判断，而且指针最后停在了有值的位置。不会溢出

删除

void ListDelete(Node *L,int i)
{
	Node *p=L;
	int j=0;
	while(j<i && p->next!=NULL)
	{
		p=p->next;
		j++;
	}
	if(j==i && p->next!=NULL)//这个就是和插入 遍历之后的一点小区别，因为插入可以在最末尾，空的位置插入，但是不能删除空的位置
	{
		Node *node=p->next;
		p->next=node->next;
		delete node;
	}
	else
		cout<<"out of range"<<endl;
}

输出：

3 7 6 5 4 8
45673


删除之后为
4573
37540Press any key to continue

思想：

（1）遍历方式和插入完全一样，都需要找到插入位置的前一个

（2）删除操作唯一不同的时候，是需要先判断定位的下一个是否是空的，为空的话是不需要删除的，否则会出问题，而对于插入，当是空的时候是可以插入的。

 

3、循环链表

要将一个链表编程循环链表，可以这么做：

（1）存储头指针

（2）遍历链表，指向队尾，将尾部的next指向头指针，返回队尾，下次访问的时候，第一个就是访问尾部，通过尾部，也可以访问头指针，形成了循环链表

（3）这种结构的好处就是，可以轻松将两个这样的循环链表连接成一个循环链表，只需要做一些简单的指针修改即可，不需要再遍历一个链表。

 

4、双向链表

（1）就是设置两个指针地域，一个指向前驱prior 一个指向next

（2）头指针的前驱为尾指针，尾指针的后继为前指针

（3）这样就形成了双向链表。

（4）有时间要尝试构造下，应该不难