‘壹’ 链式结构是什么
链式结构是为了解决线性结构中间插入数据速度不友好而提出的解决方法，对初始化的数据添加next属性，使得它指向下一个节点，这样需要添加数据或者删除数据（完全删除，非重置为None）只需要将链式结构打断并重新连接即可实现，不过需要牺牲线性结构的快速查询性能。
链式结构特点：
1、比顺序存储结构的存储密度小(链式存储结构中每个结点都由数据域与指针域两部分组成，相比顺序存储结构增加了存储空间)。
2、逻辑上相邻的节点物理上不必相邻。
3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。
4、查找节点时链式存储要比顺序存储慢。
5、每个节点是由数据域和指针域组成。
6、由于簇是随机分配的，这也使数据删除后覆盖几率降低，恢复可能提高。
7、它不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点，但也同时失去了顺序表可随机存取的优点。
‘贰’ 线性表的链式存储结构定义及基本操作
是这个效果吗
‘叁’ 如何用C语言实现简单的链式存储结构
使用结构体：
typedef struct node{
int data;
struct node* next;
}Node;
就可以实现，以上是一个单链表的节点元素，每个节点的next指向下一个节点，就可以实现链式存储了。遇到其他类似的问题，可以根据需要设置相应的指针域。
‘肆’ 线性表链式存储结构的基本操作算法实现
这是我学数据结构时亲手码的，好用的话记得给分。。。。。
#include<iostream>
using
namespace
std;
//线性表的单链表存储表示
struct
LNode
{
int
data;
struct
LNode
*next;
};
//逆序创建链表
void
CreateList(LNode
*L,int
a[],int
n)
{
LNode
*s;
L->next
=
NULL;
for(int
i=n-1;i>=0;--i)
{
s=
new
LNode;
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
//显示链表
void
display(LNode
*L)
{
LNode
*p;
p=L->next;
while(p)
{
cout<<p->data<<"
";
p=p->next;
}
}
//插入结点操作
void
ListInsert(LNode
*L,int
d,
LNode
*s)
{
LNode
*p;
int
i=1;
p=L->next;
while(i<d-1)
{
p=p->next;
i++;
}
s->next=p->next;
p->next=s;
}
//删除节点操作
void
ListDelete(LNode
*L,int
d,int
&e)
{
LNode
*p,*q;
int
i=0;
p=L->next
;
while(i<d-1)
{
q=p;
p=p->next;
i++;
}
e=p->data;
q->next=p->next;
delete
p;
}
//查找元素
LNode*
LocalElem(LNode
*L,int
e)
{
LNode
*p;
p=L->next;
while(p&&p->data!=e)
p=p->next;
return
p;
}
//逆置单链表
void
InvertLinkedList(LNode
*L)
{
LNode
*p,*s;
p=L->next;
L->next=NULL;
while(p)
{
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
int
main()
{
LNode
*H;
int
n;
cout<<"please
enter
the
length
of
the
list:
";
cin>>n;
int
*A=new
int[n];
int
i;
H=new
LNode;
H->next=NULL;
cout<<"please
enter
"<<n<<"
number
of
the
list:"<<endl;
for(i=0;i<n;i++)
cin>>A[i];
CreateList(H,A,n);
cout<<"show
the
members
of
the
list:
";
display(H);
cout<<endl;
int
d;
cout<<"please
enter
the
address
of
the
add
member:
";
cin>>d;
LNode
*s;
s=
new
LNode;//初始化局部变量s
cout<<"please
enter
the
data
of
the
add
member:
";
cin>>s->data;
ListInsert(H,d,
s);
display(H);
cout<<endl;
int
p;
cout<<"please
enter
the
address
of
the
delete
member:
";
cin>>p;
int
c=0;
int
&e=c;//非常量引用的初始值必须为左值!!!
ListDelete(H,p,e);
display(H);
cout<<endl;
int
g;
cout<<"please
enter
the
member
that
you
want
to
find:
";
cin>>g;
cout<<"the
local
of
the
member
is:
"<<LocalElem(H,g);
cout<<endl;
InvertLinkedList(H);
cout<<"the
invertlinklist
is:
";
display(H);
cout<<endl;
return
0;
}
花时间好好看看，一定要看懂
‘伍’ 分别就栈的顺序存储结构和链式存储结构实现栈的各种基本操作。
顺序存储结构
#include<iostream>
typedef char ElemType;
#define MaxSize 100
using namespace std;
typedef struct
{
ElemType data[MaxSize];
int top;
}sqStack;
void InitStack(sqStack *&s);//初始化栈
void ClearStack(sqStack *&s);//摧毁栈
int StackLength(sqStack *s);//返回栈的长度
bool StackEmpty(sqStack *s);//判断栈是否为空
int Push(sqStack *&s,ElemType e);//进栈
int Pop(sqStack *&s,ElemType &e);//出栈
int GetTop(sqStack *s,ElemType &e);//取栈顶元素
void DispStack(sqStack *s);//显示栈中元素值
int main()
{
return 0;
}
void InitStack(sqStack *&s)//初始化栈
{
s=new sqStack;
s->top=-1;
}
void ClearStack(sqStack *&s)//摧毁栈
{
delete s;
}
int StackLength(sqStack *s)//返回栈的长度
{
return (s->top+1);
}
bool StackEmpty(sqStack *s)//判断栈是否为空
{
return (s->top==-1);
}
int Push(sqStack *&s,ElemType e)//进栈
{
if(s->top==MaxSize-1)
return 0;
s->top++;
s->data[s->top]=e;
return 1;
}
int Pop(sqStack *&s,ElemType &e)//出栈
{
if(s->top==-1)
return 0;
e=s->data[s->top];
s->top--;
return 1;
}
int GetTop(sqStack *s,ElemType &e)//取栈顶元素
{
if(s->top==-1)
return 0;
e=s->data[s->top];
return 1;
}
void DispStack(sqStack *s)//显示栈中元素值
{
for(int i=s->top;i>=0;i--)
cout<<s->data[i]<<" ";
cout<<endl;
}
链式存储结构
typedef char ElemType;
typedef struct linknode
{
ElemType data;
struct linknode *next;
}LiStack;
void InitStack(LiStack *&s);//初始化栈
void ClearStack(LiStack *&s);//摧毁栈
int StackLength(LiStack *s);//返回栈的长度
bool StackEmpty(LiStack *s);//判断栈是否为空
void Push(LiStack *&s,ElemType e);//进栈
int Pop(LiStack *&s,ElemType &e);//出栈
int GetTop(LiStack *s,ElemType &e);//取栈顶元素
void DispStack(LiStack *s);//显示栈中元素值
int main()
{
return 0;
}
void InitStack(LiStack *&s)//初始化栈
{
s=new LiStack;
s->next=NULL;
}
void ClearStack(LiStack *&s)//摧毁栈
{
for(LiStack *p=s->next;p;p=p->next)
{
delete s;
s=p;
p=p->next;
}
delete s;
}
int StackLength(LiStack *s)//返回栈的长度
{
int i=0;
for(LiStack *p=s->next;p;p=p->next)
i++;
return i;
}
bool StackEmpty(LiStack *s)//判断栈是否为空
{
return (s->next==NULL);
}
void Push(LiStack *&s,ElemType e)//进栈
{
LiStack *p=new LiStack;
p->data=e;
p->next=s->next;
s->next=p;
}
int Pop(LiStack *&s,ElemType &e)//出栈
{
LiStack *p;
if(s->next==NULL)
return 0;
p=s->next;
e=p->data;
s->next=p->next;
delete p;
return 1;
}
int GetTop(LiStack *s,ElemType &e)//取栈顶元素
{
if(s->next==NULL)
return 0;
e=s->next->data;
return 1;
}
void DispStack(LiStack *s)//显示栈中元素值
{
LiStack *p=s->next;
for(;p;p=p->next)
cout<<p->data<<" ";
cout<<endl;
}
‘陆’ 线性表链式存储结构的基本操作算法实现
这是我学数据结构时亲手码的，好用的话记得给分。。。。。
#include<iostream>
using namespace std;
//线性表的单链表存储表示
struct LNode
{
int data;
struct LNode *next;
};
//逆序创建链表
void CreateList(LNode *L,int a[],int n)
{
LNode *s;
L->next = NULL;
for(int i=n-1;i>=0;--i)
{
s= new LNode;
s->data=a[i];
s->next=L->next;
L->next=s;
}
}
//显示链表
void display(LNode *L)
{
LNode *p;
p=L->next;
while(p)
{
cout<<p->data<<" ";
p=p->next;
}
}
//插入结点操作
void ListInsert(LNode *L,int d, LNode *s)
{
LNode *p;
int i=1;
p=L->next;
while(i<d-1)
{
p=p->next;
i++;
}
s->next=p->next;
p->next=s;
}
//删除节点操作
void ListDelete(LNode *L,int d,int &e)
{
LNode *p,*q;
int i=0;
p=L->next ;
while(i<d-1)
{
q=p;
p=p->next;
i++;
}
e=p->data;
q->next=p->next;
delete p;
}
//查找元素
LNode* LocalElem(LNode *L,int e)
{
LNode *p;
p=L->next;
while(p&&p->data!=e) p=p->next;
return p;
}
//逆置单链表
void InvertLinkedList(LNode *L)
{
LNode *p,*s;
p=L->next;
L->next=NULL;
while(p)
{
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
int main()
{
LNode *H;
int n;
cout<<"please enter the length of the list: ";
cin>>n;
int *A=new int[n];
int i;
H=new LNode;
H->next=NULL;
cout<<"please enter "<<n<<" number of the list:"<<endl;
for(i=0;i<n;i++)
cin>>A[i];
CreateList(H,A,n);
cout<<"show the members of the list: ";
display(H);
cout<<endl;
int d;
cout<<"please enter the address of the add member: ";
cin>>d;
LNode *s;
s= new LNode;//初始化局部变量s
cout<<"please enter the data of the add member: ";
cin>>s->data;
ListInsert(H,d, s);
display(H);
cout<<endl;
int p;
cout<<"please enter the address of the delete member: ";
cin>>p;
int c=0;
int &e=c;//非常量引用的初始值必须为左值!!!
ListDelete(H,p,e);
display(H);
cout<<endl;
int g;
cout<<"please enter the member that you want to find: ";
cin>>g;
cout<<"the local of the member is: "<<LocalElem(H,g);
cout<<endl;
InvertLinkedList(H);
cout<<"the invertlinklist is: ";
display(H);
cout<<endl;
return 0;
}
花时间好好看看，一定要看懂
‘柒’ 线性表的链式存储结构的实现
不错耶是我想问的 分数给我吧
‘捌’ 计算机有哪些存储结构
在计算机中存储和组织数据的方式被称之为数据结构，链表和数组是较为常见的两种结构。
1、数组
数组就像一个个紧挨着的小格子，每一个格子都有它们自己的序号，这个序号被称之为“索引”。与生活中不太相同的是，平时计数习惯以“1”开始，而在计算机中，“0”是开头的第一个数字。
数组中的数据，在计算机的存储器中，也是按顺序存储在连续的位置中。当我们寻找需要的数据时，通过格子中的索引，便可以找到数据。
2、链表
链表的存储方式有些像地址和住宅的关系，地址可以写在一张纸上，但是这并不代表住宅也紧密相邻。链表中的数据在计算机中也是分散地存储在各个地方，但是链表里面除了存储数据，还存储了下一个数据的地址，以便于找到下一个数据。
与数组不同的是，链表储存数据不像数组一样，需要提前设定大小，就像火车的车厢长度是随着乘客的数量而增加的。
(8)链式存储结构和实现扩展阅读
数据的链式存储结构可用链接表来表示。
其中data表示值域，用来存储节点的数值部分。Pl，p2，…，Pill(1n≥1)均为指针域，每个指针域为其对应的后继元素或前驱元素所在结点(以后简称为后继结点或前驱结点)的存储位置。
通过结点的指针域(又称为链域)可以访问到对应的后继结点或前驱结点，若一个结点中的某个指针域不需要指向其他结点，则令它的值为空（NULL）。
在数据的顺序存储中，由于每个元素的存储位置都可以通过简单计算得到，所以访问元素的时间都相同；而在数据的链接存储中。
由于每个元素的存储位置保存在它的前驱或后继结点中，所以只有当访问到其前驱结点或后继结点后才能够按指针访问到，访问任一元素的时间与该元素结点在链式存储结构中的位置有关。
‘玖’ 数据结构（顺序和链式存储结构：对于这两种存储结构，都是通过编程实现的，但是是怎样和计算机内存关联）
这两种存储结构与内存没有直接的关系，是指的文件在存储介质上的存储形式。而顺序和链式，是为了如何方便查找数据进行修改而产生的两种思想。比如：链式存储结构，在计算机中用一组任意的存储单元存储线性表的数据元素（这组存储单元可以是连续的，也可以是不连续的)，它不要求逻辑上相邻的元素在物理位置上也相邻，因此它没有顺序存储结构所具有的弱点，但也同时失去了顺序表可随机存取的优点；相同空间内假设全存满的话顺序比链式存储更多，逻辑上相邻的节点物理上不必相邻，插入、删除灵活，不必移动节点，只要改变节点中的指针，但查找结点时链式存储要比顺序存储慢。这如同我们的整车库房，是按来车顺序存放呢，还是按同一种类型的车放在一起呢。
内存只是一个临时存放数据的地方，它的速度与CPU相近，只是在进行硬盘或U盘、光盘等数据操作时才会用到这两种思想。
‘拾’ 如何用C语言实现简单的链式存储结构
使用结构体：
typedefstructnode{
intdata;
structnode*next;
}Node;就可以实现，以上是一个单链表的节点元素，每个节点的next指向下一个节点，就可以实现链式存储了。遇到其他类似的问题，可以根据需要设置相应的指针域。