① 如何用C語言實現簡單的鏈式存儲結構
使用結構體：
typedefstructnode{
intdata;
structnode*next;
}Node;就可以實現，以上是一個單鏈表的節點元素，每個節點的next指向下一個節點，就可以實現鏈式存儲了。遇到其他類似的問題，可以根據需要設置相應的指針域。
② 我想問問數據的存儲結構有哪幾種
數據的存儲結構包括順序存儲和鏈式存儲。
數據元素之間的關系有兩種不同的表示方法：順序映象和非順序映象，並由此得到兩種不同的存儲結構：順序存儲結構和鏈式存儲結構。數據的存儲結構是爛沒指數據的邏輯結構在計算機中的表示。順序存儲方法它是把邏輯上相鄰的結點存儲在物理位置相鄰的存儲單元里，結點間的邏輯關系由存儲單元的鄰接關系來體現，由此得到的存儲輪畝表示稱為順序存儲結構。順序存儲結構是一種最基本的存儲表示方法，通常藉助於程序設計語言中的數組來實現。鏈接存儲方法它不要求邏輯上相鄰的結點在物理位置上亦相鄰，結點間的邏輯關系是由附加的指針欄位表示的。由此得到的存儲表示稱為鏈式存儲結構，鏈式存儲結構通常藉助於程序設計語言中的指針類型來實現。
更多關於數據的存儲結構有哪幾種，飢桐納進入：https://m.abcgonglue.com/ask/d88e681615832640.html?zd查看更多內容
③ 編程實現以鄰接表或鄰接矩陣為存儲結構，圖的廣度和深度優先搜索
/*******************************************
圖的遍歷演示
以鄰接多重表為存儲結構,實現連通無向圖的深度優先和廣度優先遍歷.
以用戶指定的結點為起點,分別輸出每種遍歷下的結點訪問序列和相應生成樹的邊集.
*******************************************/
#include<iostream>
# include <string.h>
# include <malloc.h>
# include <conio.h>
using namespace std;
int visited[30];
# define MAX_VERTEX_NUM 30
# define OK 1
//typedef int VertexType;
typedef int InfoType;
typedef struct ArcNode //弧
{
int adjvex;
struct ArcNode *nextarc;
}ArcNode;
typedef struct VNode//表頭
{
int data;
ArcNode *firstarc;
}VNode,AdjList[MAX_VERTEX_NUM];
typedef struct//圖
{
AdjList vertices;
int vexnum,arcnum;
int kind;
}ALGraph;
void CreateDG(ALGraph &G)
{
int k,i,v1;
cout<<endl<<"請輸入結點個數: ";
cin>>G.vexnum;
cout<<"請輸入弧的個數: ";
cin>>G.arcnum;
for(i=1;i<=G.vexnum;i++)//初使化表頭
{
G.vertices[i].data=i;
G.vertices[i].firstarc=NULL;
}
for(k=1;k<=G.vexnum;k++) //輸入邊
{
int v2;
cout<<"請輸入與結點"<<k<<"相鄰的邊數:";
cin>>v2;
cout<<"請輸入與第"<<k<<"個結點相連的結點編號: ";
cin>>v1;
ArcNode *p;
p=(ArcNode*)malloc(sizeof(ArcNode));
if(!p) exit(-1);
p->adjvex=v1;
p->nextarc=NULL;
G.vertices[k].firstarc=p;
for(int i=1;i<v2;i++)
{
int m;
cout<<"請輸入與第"<<k<<"個結點相連的結點編號: ";
cin>>m;
ArcNode *q;
q=(ArcNode *)malloc(sizeof(ArcNode));//動態指針
if(!q) exit(-1);
q->adjvex=m; //頂點給P
q->nextarc=NULL;
p->nextarc=q;
p=q;
//free(q);
}
//free(p);
}
}
void DFS (ALGraph G,int v )//深度搜索
{
visited[v]=1;
cout<<G.vertices[v].data<<" ";
ArcNode *x;
x=(ArcNode*)malloc(sizeof(ArcNode));
if(!x) exit(-1);
x=G.vertices[v].firstarc;
int w;
for (;x;x=x->nextarc)
{ w=x->adjvex;
if(visited[w]==0)
DFS(G,w);
}
}
void DFSB (ALGraph G,int v)//深度搜索的邊集
{
visited[v]=1;
ArcNode *y;
y=(ArcNode*)malloc(sizeof(ArcNode));
if(!y) exit(-1);
y=G.vertices[v].firstarc;
int u=G.vertices[v].data;
int w;
for(;y;y=y->nextarc)
{ w=y->adjvex;
if(visited[w]==0)
{
cout<<u<<"--->"<<w<<endl;
DFSB(G,w);
}
}
}
typedef struct QNode
{
int data;
QNode *next;
}QNode,*QueuePtr;
typedef struct
{
QueuePtr front;
QueuePtr rear;
}LinkQueue;
void InitQueue (LinkQueue &Q)//建立一個空隊列
{
Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode));
if(!Q.front) exit(-1);
Q.front->next=NULL;
}
void EnQueue (LinkQueue &Q,int e)//進隊
{
QNode *p;
p=(QNode*)malloc(sizeof(QNode));
if(!p) exit(-1);
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
//free(p);
}
int DeQueue (LinkQueue &Q,int &e)//出隊
{
if(Q.front==Q.rear)
return -1;
QNode *p;
p=(QNode*)malloc(sizeof(QNode));
if(!p) exit(-1);
p=Q.front->next;
e=p->data;
Q.front->next=p->next;
if(Q.rear==p)
Q.rear=Q.front;
free(p);
return e;
}
int QueueEmpty (LinkQueue Q)//判斷隊列是否為空
{
if(Q.front==Q.rear)
return 1;
return 0;
}
void BFS(ALGraph G,int v)//廣度搜索
{
int u;
LinkQueue Q;
InitQueue(Q);
if(visited[v]==0)
{
visited[v]=1;
cout<<G.vertices[v].data<<" ";
EnQueue(Q,v);
while(QueueEmpty(Q)!=1)
{
DeQueue(Q,u);
ArcNode *z;
z=(ArcNode*)malloc(sizeof(ArcNode));
if(!z) exit(-1);
z=G.vertices[u].firstarc;
/*
for(int w=z->adjvex;w>=0;w=z->nextarc->adjvex)
{
if(visited[w]==0)
{
visited[w]=1;
cout<<w<<" ";
EnQueue(Q,w);
}
}*/
int w;
for(;z;z=z->nextarc)
{ w=z->adjvex;
if(visited[w]==0)
{
visited[w]=1;
cout<<w<<" ";
EnQueue(Q,w);
}
}
}
}
}
void BFSB (ALGraph G,int v)//廣度搜索的邊集
{
int u;
LinkQueue Q;
InitQueue(Q);
if(visited[v]==0)
{
visited[v]=1;
EnQueue(Q,v);
while(QueueEmpty(Q)!=1)
{
DeQueue(Q,u);
ArcNode *r;
r=(ArcNode*)malloc(sizeof(ArcNode));
if(!r) exit(-1);
r=G.vertices[u].firstarc;
int w;
for(;r!=NULL;r=r->nextarc)
{ w=r->adjvex;
if(visited[w]==0)
{
visited[w]=1;
cout<<u<<"--->"<<w<<endl;
EnQueue(Q,w);
}
}
}
}
}
int main()
{
int i;
ALGraph G;
CreateDG(G);
int x;
cout<<"請輸入結點數:";
cin>>x;
cout<<"鄰接表為："<<endl;
for(int j=1;j<=x;j++)
{
cout<<G.vertices[j].data<<" ";
ArcNode *p;
p=(ArcNode*)malloc(sizeof(ArcNode));
if(!p) exit(-1);
p=G.vertices[j].firstarc;
while(p)
{
cout<<p->adjvex<<" ";
p=p->nextarc;
}
cout<<endl;
}
cout<<"請輸入第一個要訪問的結點序號："<<endl;
int n;
cin>>n;
for( i=0;i<30;i++)
visited[i]=0;
cout<<"廣度搜索："<<endl;
BFS(G,n);
for( i=0;i<30;i++)
visited[i]=0;
cout<<endl;
cout<<"邊集："<<endl;
BFSB(G,n);
for( i=0;i<30;i++)
visited[i]=0;
cout<<"深度搜索："<<endl;
DFS(G,n);
for( i=0;i<30;i++)
visited[i]=0;
cout<<endl;
cout<<"邊集："<<endl;
DFSB(G,n);
//system("pause");
return 0;
}
前幾天上機剛好做了這個,個人感覺很完美,盡管老師說用的是鄰接表而不是多重表,太簡單,但還不錯,界面輸入過程比較繁瑣,要嚴格按照提示來輸入,是無向圖,等級太低,沒辦法把執行結果粘出來,應該能看懂吧
④ 數據結構的存儲方式有哪幾種
數據結構的存儲方式有順序存儲方法、鏈接存儲方法、索引存儲方法和散列存儲方法這四種。
1、順序存儲方式：順序存儲方式就是在一塊連續的存儲區域一個接著一個的存放數據，把邏輯上相連的結點存儲在物理位置上相鄰的存儲單元里，結點間的邏輯關系由存儲單元的鄰接掛安息來體現。順序存儲方式也稱為順序存儲結構，一般採用數組或者結構數組來描述。
2、鏈接存儲方法：它比較靈活，其不要求邏輯上相鄰的結點在物理位置上相鄰，結點間的邏輯關系由附加的引用欄位表示。一個結點的引用欄位往往指導下一個結點的存放位置。鏈接存儲方式也稱為鏈接式存儲結構，一般在原數據項中增加應用類型來表示結點之間的位置關系。
3、索引存儲方法：除建立存儲結點信息外，還建立附加的索引表來標識結點的地址。它細分為兩類：稠密索引：每個結點在索引表中都有一個索引項，索引項的地址指示結點所在的的存儲位置；稀疏索引：一組結點在索引表中只對應一個索引項，索引項的地址指示一組結點的起始存儲位置。
4、散列存儲方法：就是根據結點的關鍵字直接計算出該結點的存儲地址。
(4)如何實現存儲結構擴展閱讀
順序存儲和鏈接存儲的基本原理
在順序存儲中，每個存儲空間含有所存元素本身的信息，元素之間的邏輯關系是通過數組下標位置簡單計算出來的線性表的順序存儲，若一個元素存儲在對應數組中的下標位置為i，則它的前驅元素在對應數組中的下標位置為i-1，它的後繼元素在對應數組中的下標位置為i+1。
在鏈式存儲結構中，存儲結點不僅含有所存元素本身的信息，還含有元素之間邏輯關系的信息。數據的鏈式存儲結構可用鏈接表來表示。其中data表示值域，用來存儲節點的數值部分。Pl，p2，…，Pill(1n≥1)均為指針域，每個指針域為其對應的後繼元素或前驅元素所在結點的存儲位置。
在數據的順序存儲中，由於每個元素的存儲位置都可以通過簡單計算得到，所以訪問元素的時間都相同；而在數據的鏈接存儲中，由於每個元素的存儲位置保存在它的前驅或後繼結點中，所以只有當訪問到其前驅結點或後繼結點後才能夠按指針訪問到，訪問任一元素的時間與該元素結點在鏈式存儲結構中的位置有關。
⑤ 如何用順序存儲結構實現隊列,使得進隊和出隊時不再移動其他元素
假設結構體如下：
struct{
\x05datatype data[max];
\x05int front,rear;
}sequeue;
front=rear=-1; //進行初始化
入隊操作應該是這樣的,首塵前先rear++；然後把數據插入,data[rear]=a; (假設a是數據）；
出對操作和入隊類似,首先front++,如果你不需要保存出隊的數據,那麼就可以了,如果要保存的話,就b=data[front];(b為保存的數派含清據老逗）
⑥ 簡述數據的邏輯結構和存儲結構的區別與聯系，它們如何影響演算法的設計與實現
數據結構的存儲結構是和相應的數據在內存中的物理地址之間的關系有關。而邏輯結構只是描述數據之間的關系（三大邏輯結構的一種）。舉例說，線性表（元素之間的邏輯關系是線性的）可以是順序存儲的方式，即所有元素相鄰存放，在物理地址上是連續的（存儲結構）；而對於鏈式存儲的線性表，他的所有元素之間不一定是線性相連的，可能是第一個結點（元素）的地址為0x123,而第二個元素又出現在物理地址0x100上。也就是說邏輯結構是線性的但是存儲結構不一定就是線性的了。
⑦ 如何根據一個數據的邏輯結構設計存儲結構
數據的邏輯結構是指數據元素之間的邏輯關系，即從邏輯關繫上描述數據。它與數據的存儲無關，是獨立於計算機的。數據的邏輯結構分為線性結構和非線性結構，線性表是典型的線性結構；集合、樹和圖是典型的非線性結構。
集合結構中的數據元素之間除了 「同屬於一個集合」的關系外，別無其他關系。
線性結構結構中的數據元素之間只存在一對一的關系。
樹形結構結構中的數據元素之間存在一對多的關系。
圖狀結構或網狀結構結構中的數據元素之間存在多對多的關系。
扎實的數據結構與演算法功底，能讓我們站在更高的角度去思考代碼、寫出性能更優的程序，能讓我們更快速地學習上手各種新技術（比如人工智慧、區塊鏈等），也能讓我們敲開更高級編程領域的大門。數據結構與演算法更是各大名企面試題中的常客，如果不想被行業拋棄、想進入更大的名企、在IT道路上走得更遠，掌握數據結構與演算法是非常有必要。
課程特色
1、MJ和名企演算法大咖董甫聳共同研發設計，確保課程的系統全面性、高含金量。
2、結合大量企業真實案例講解，由淺入深地帶著同學們敲出每個數據結構每個演算法的每一行代碼實現，一起感受數據結構與演算法的魅力。
3、全程直播授課，在線答疑，實時互動，讓學員不再有後顧之憂。
4、結識學習夥伴，相互監督，疑問解答，彼此分享，共同學習。
⑧ 編程實現線性表的鏈式存儲結構，即鏈表，實現鏈表的建立和輸出
程序代碼：
#include <stdio.h>
#include <malloc.h>
#include <string.h>
struct node
{
int num;
char name[10],Class[15];
struct node *next;
}*head,*p,*q;
int main()
{
int i,num;
char name[10],Class[15];
head=(struct node*)malloc(sizeof(struct node));
memset(name,'\0',sizeof(name));
memset(Class,'\0',sizeof(Class));
printf("信息輸入：\n");
scanf("%d%s%s",&num,name,Class);
head->num=num;
strcpy(head->name,name);
strcpy(head->Class,Class);
head->next=NULL;
for(i=0;i<5;i++)
{
memset(name,'\0',sizeof(name));
memset(Class,'\0',sizeof(Class));
scanf("%d%s%s",&num,name,Class);
p=(struct node*)malloc(sizeof(struct node));
p->num=num;
strcpy(p->name,name);
strcpy(p->Class,Class);
p->next=head;
head=p; //不帶頭結點的頭插法
}
printf("信息輸出：\n");
p=head;
while(p)
{
if(p->num<10) printf("0");
printf("%d %s %s\n",p->num,p->name,p->Class);
p=p->next;
}
p=head;
while(p) //釋放空間
{
q=p;
p=p->next;
free(q);
}
return 0;
}
輸入：
01 張三 初二（1）班
02 李四 初二（1）班
03 王五 初二（1）班
04 錢六 初二（1）班
05 孫七 初二（1）班
06 趙八 初二（1）班
輸出：
06 趙八 初二（1）班
05 孫七 初二（1）班
04 錢六 初二（1）班
03 王五 初二（1）班
02 李四 初二（1）班
01 張三 初二（1）班
⑨ 想問關系模型如何實現存儲結構
關系模型採用二維表的的形式表示實體和實體間聯系的存儲結構。關系模型中，欄位稱為屬性，欄位值稱為屬性值，記錄類型稱為關系模型。關系模式名是R，記錄稱為元組，元組的集合稱為關系或實例。
關系襪告實際上就是關系模式在某一時刻的狀態或內容。也就是說，關系模式是型，關系是它的值。關系模式是靜態的、穩定的，而關系是動態的、隨時告瞎明間不斷變化的，因為關系操作在不斷地更新著資料庫中的數據。但在實際當中，常常把關系模式和關系統稱為關系，讀者可以從上下文中加以區別。
關系模型允許設計者通過資料庫規范化的提煉，去建立一個信息的一致性的模型。訪問計劃和其他實現與操作細節由DBMS引擎來處理，而不應該反映在邏輯模型中。這與SQLDBMS普遍的實踐是對立的，在它們那裡性能調整經常需要改變邏輯模型。基本的關系建造塊是域或者叫數據類型。元組是屬神敬性的有序多重集（multiset），屬性是域和值的有序對。
更多關於關系模型如何實現存儲結構，進入：https://m.abcgonglue.com/ask/cc8a391615830497.html?zd查看更多內容
⑩ 二叉樹的二叉鏈表存儲結構如何實現
大概這個樣子，這個是我以前寫的二叉搜索樹：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct node
{
int data,rep;
struct node *left,*right;
} node;
node* insert(node *tree,int x);
int search(node *tree,int x);
node* del(node *tree,int x);
int main()
{
char str[20],ch;
int x;
struct node *tree = NULL;
gets(str);
while (strcmp(str,"quit"))
{
if (!strcmp(str,"insert"))
{
scanf("%d",&x);
tree = insert(tree,x);
}
else if (!strcmp(str,"delete"))
{
scanf("%d",&x);
tree = del(tree,x);
}
else if (!strcmp(str,"search"))
{
scanf("%d",&x);
if (search(tree,x))
puts("Found!");
else
puts("Not Found!");
}
else
puts("There is an error!");
ch = getchar();
gets(str);
}
return 0;
}
node* insert(node *tree,int x)
{
if (tree == NULL)
{
tree = (struct node *)malloc(sizeof(struct node *));
tree->data = x;
tree->rep = 1;
tree->left = (struct node *)malloc(sizeof(struct node *));
tree->right = (struct node *)malloc(sizeof(struct node *));
tree->left = NULL;
tree->right = NULL;
}
else if (tree->data == x)
tree->rep++;
else if (x < tree->data)
tree->left = insert(tree->left,x);
else if (x > tree->data)
tree->right = insert(tree->right,x);
return tree;
}
int search(node *tree,int x)
{
if (tree == NULL)
return 0;
else if (tree->data == x)
return 1;
else if (x < tree->data)
return search(tree->left,x);
else if (x > tree->data)
return search(tree->right,x);
}
node* del(node *tree,int x)
{
struct node *p,*q;
if (tree == NULL) {}
else if (x < tree->data)
tree->left = del(tree->left,x);
else if (x > tree->data)
tree->right = del(tree->right,x);
else if (tree->data == x)
{
if (tree->rep > 1)
tree->rep--;
else
{
if (tree->left == NULL)
return tree->right;
else if (tree->right == NULL)
return tree->left;
else
{
p = tree->left;
q = tree;
while (p->right)
{
q = p;
p = p->right;
}
tree->data = p->data;
tree->rep = p->rep;
q->right = p->left;
}
}
}
return tree;
}