當前位置:首頁 » 存儲配置 » 鏈式存儲隊列

鏈式存儲隊列

發布時間: 2023-02-22 07:21:42

A. 數據結構隊列的鏈式存儲和鏈式存儲

頭文件:dynamicArray.h

頭文件:seqQueue.h

源文件:

seqQueue.c

源文件:dynamicArray.c

源文件:01隊列_順序存儲.c

列印結果:

頭文件:LinkQueue.h

源文件:LinkQueue.c

源文件:02隊列_鏈式存儲.c

列印結果:

列印結果:

B. 鏈式隊列存儲結構的定義及基本操作

鏈式隊列其實很簡單的。
其實就是一個鏈表,不過這個鏈表你只能從表尾插入,從表頭刪除。(單向隊列)
鏈表你肯定會吧,定義兩個指針,分別指向表頭和表尾,作為隊頭指針和隊尾指針。封裝起來。
這就是一個鏈式隊列了。
基本操作無非是入隊,出隊,刪除這些,跟基本鏈表操作一樣的。

C. 隊列在鏈式存儲上的操作包括:(6) 隊列置空操作CLEAR(Q)(7) 求隊列中元素個數的操作 CURRENT_SIZE(Q)

#include "stdio.h"
#include "stdlib.h"
#include "z.h"

//鏈隊列初始化
void initlinkqueue(LINKQUEUE *q)
{
q->front=(LINKQLIST *)malloc(sizeof(LINKQLIST));
(q->front)->next=NULL;
q->rear=q->front;
}

//判鏈隊列空
int emptylinkqueue(LINKQUEUE *q)
{
int v;
if(q->front==q->rear)
v=1;
else
v=0;
return v;
}

//讀鏈隊列隊首元素
DATATYPE1 getlinkfront(LINKQUEUE *q)
{
DATATYPE1 v;
if(emptylinkqueue(q))
v=NULL;
else
v=(q->front)->next->data;
return v;
}

//元素插入鏈隊列
void enlinkqueue(LINKQUEUE *q,DATATYPE1 x)
{
(q->rear)->next=(LINKQLIST *)malloc(sizeof(LINKQLIST));
q->rear=(q->rear)->next;
(q->rear)->data=x;
(q->rear)->next=NULL;
}

//從鏈隊列中刪除元素
DATATYPE1 dellinkqueue(LINKQUEUE *q)
{
LINKQLIST *p;
DATATYPE1 v;
if(emptylinkqueue(q))
{ printf("Queue is empty.\n");
v=NULL;}
else
{p=(q->front)->next;
(q->front)->next=p->next;
if(p->next==NULL)
q->rear=q->front;
v=p->data;
free(p);}%0

D. 鏈式隊列是什麼

隊列分為兩種,一種是線性的,另一種為非線性(鏈式)。前者在計算機中以相鄰順序存放(相當於是一條直線);後者通俗說是將直線首尾連起來,但存放是以指針方式存入的不是想念存放的。

數據結構的基本問題。隊列 是一種特殊的線性表,它只允許在表的前端(front)進行刪除操作,而在表的後端(rear)進行插入操作。進行插入操作的端稱為隊尾,進行刪除操作的端稱為隊頭。隊列中沒有元素時,稱為空隊列。一般隊列的存儲結構是順序存儲,當隊列的存儲結構是鏈式存儲結構時(即隊列中每個元素都包含一個指向其後繼的指針,最後一個元素指針為null),就是鏈式隊列,和鏈棧同理。

E. 採用鏈式存儲實現隊列的初始化、入隊、出隊操作

#include<stdio.h>
#include<stdlib.h>
#define OVERFLOW -2

typedef struct QNode{//創建隊成員
int data;//數據成員
struct 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 ( OVERFLOW);//開辟失敗則退出
Q.front ->next = NULL;
//return 1;
}

int EnQueue(LinkQueue &Q)//入隊操作
{
int e;
QueuePtr p;
printf("請輸入入隊元素:");
scanf("%d",&e);
p=(QueuePtr)malloc(sizeof(QNode));
if (p==NULL) exit (OVERFLOW);
p->data = e; p->next = NULL;
Q.rear->next=p;//把p插入隊尾
Q.rear=p;//把p變為隊尾
return 1;
}

int DeQueue(LinkQueue &Q)//出隊操作
{
QueuePtr p;
int e;
if ( Q.front == Q.rear){
printf("隊列為空\n");
return -1;
}
p=Q.front->next;//頭指針為空
e=p->data;
printf("%d 出對\n",e);
Q.front->next =p->next;//指針後移
if (Q.rear == p) Q.rear = Q.front;//如果p為隊尾
free(p);//釋放p
return 1;
}

void tip()
{
printf("*************\n");
printf("*輸入1 進隊 *\n");
printf("*輸入2 出對 *\n");
printf("*請選擇: *\n");
printf("*************\n");
}

int main()
{
int k;
LinkQueue Q;
InitQueue(Q);//初始化隊列
tip();
while(scanf("%d",&k),k)
{
switch(k)
{
case 1:
EnQueue(Q);
tip();
printf("操作完畢\n");
break;
case 2:
DeQueue(Q);
tip();
printf("操作完畢\n");
break;
}

}
return 0;
}

F. 試述隊列的鏈式存儲結構和順序存儲結構的優缺點

順序存儲結構是在內存中開辟一個連續的空間用來存儲數據,因此對於內存的需求和苛刻,必須是連續的空間.在數據查找(特別是不按照規律排列的數據),時間復雜度教少.效率高.鏈式存儲結構是採取連表指針來指示數據的存儲位置,這就可以是在內存中隨意的存儲,沒有必須連續儲存空間的要求,對於內存的要求相對教容易.但是要是是從小到大順序排列的數據,鏈式存儲結構的時間復雜度教小,效率高.但是要是不規則排布的數據一般時間復雜度較高,效率更低

G. 如何在鏈式存儲隊列多加一個輸出隊列的最後一個元素

jQuery 選擇器中 :last 表示最後一個元素,所以表示含有某類屬性的最後一個元素可用如下代碼表示
$("test-class:last") // 表示最後一個屬於test-class類的元素
示例如下:
創建Html元素
<div class="top">
<ul>
<li>list-1</li>
<li class="selected">list-2</li>
<li class="selected">list-3</li>
<li>list-4</li>
<li class="selected">list-5</li>
</ul>
<span>紅色列表項表示屬於selected類,彈出框顯示了最後一個屬於selected類的元素的內容</span>
</div>
設置css樣式
div.top{margin:50px;padding:10px;width:300px;height:250px;border:2px dashed #ebbcbe;}
li{padding:5px;}
li.selected{color:red;font-weight:bold;}
span{color:#999;}
編寫jquery代碼
$(function(){
$("ul").click(function() {
alert($("li.selected:last").text());
});
})
觀察顯示效果

H. 數據結構鏈式存儲隊列中刪除元素的演算法

給你一個全的吧
#include<iostream>
#include<stdlib.h>
using namespace std;
typedef struct LNode
{
int Data;
struct LNode *Next;
}LNode;

void CreateList(struct LNode *HeadList,int n,int a[])
{
int i;
struct LNode *p;
HeadList=(struct LNode*)malloc(sizeof(struct LNode));
HeadList->Next=NULL;
for(i=n;i>0;--i)
{
p=(struct LNode*)malloc(sizeof(struct LNode));
p->Data=a[i];
p->Next=HeadList->Next;
HeadList->Next=p;
}
}
void ListInsert(struct LNode *HeadList,int i,int newnode)
{
struct LNode *p=HeadList;
struct LNode *s;
int j=0;
while(p && j<i-1)
{
p=p->Next;
j++;
}
if(!p || j>i-1)
{
cout<<"位置小於1或大於表長";
return;
}
s=(struct LNode*)malloc(sizeof(struct LNode));
s->Data=newnode;
s->Next=p->Next;
p->Next=s;
}
void ListDelete(struct LNode *HeadList,int i)
{
struct LNode *p=HeadList;
struct LNode *s;
int j=0;
while(p->Next && j<i-1)
{
p=p->Next;
++j;
}
if(!(p->Next) || j>i-1)
{
cout<<"刪除位置不合理";
return;
}
s=p->Next;
p->Next=s->Next;
int number;
cin>>number;
s->Data=number;
cout<<"被刪除的結點是"<<s->Data;
free(s);
}
void ListDisp(struct LNode *HeadList)
{
struct LNode *p;
int i=0;
p=HeadList->Next;
while(p)
{
cout<<p->Data;
++i;
p=p->Next;
}
}
int getoptions()
{
int opt;
cout<<"1: 錄入鏈表"<<endl;
cout<<"2: 顯示鏈表"<<endl;
cout<<"3: 插入結點"<<endl;
cout<<"4: 刪除結點"<<endl;
cout<<"5: 退出"<<endl;
cout<<"輸入選項並按回車確認:";
cin>>opt;
return opt;
}
int main(int argc,char * argv[])
{
int opt;
int where;
int value;
int count;
int a[5]={2,4,6,8,10};
struct LNode *HeadList;
while(1)
{
opt=getoptions();
if(opt==1)
{
//cout<<"請輸入鏈表的初始結點數";
//cin>>count;
//cout<<"請輸入各個結點數值,每輸入一個按回車確認";
CreateList(HeadList,5,a);
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==2)
{
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==3)
{
ListDisp(HeadList);
cin>>where;
cout<<"請輸入要插入的數值";
cin>>value;
ListInsert(HeadList,where,value);
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==4)
{
ListDisp(HeadList);
cout<<"請輸入要刪除的位置";
cin>>where;
ListDelete(HeadList,where);
ListDisp(HeadList);
system("PAUSE");
continue;
}
if(opt==5)
{
return 0;
}
}
}
不好意思,我發完之後才看見是隊列,乍一看以為是鏈表,我發的這個是鏈表的,快下班了,明天上班再給你寫一個吧

I. 編寫鏈式存儲隊列基本操作函數

#include <iostream.h>
#include <stdlib.h>
#include <stdio.h>
#include <time.h>

class node{
public:
int data;
node *next;
};

node* create(int len)
{
int c=0,i=1,k=0,flag=-1;
node* l;
node* r;
node* s;
l=(node*)new node;
l->next=NULL;
r=l;
while(i<=len)
{
cout<<"請輸入第"<<i<<"個節點值"<<endl;
cin>>c;
s=(node*)new node;
s->data=c;
r->next=s;
r=s;
i++;
}
srand(time(NULL));
flag=rand()%2;
if(flag==0)
{
r->next=NULL;
cout<<"隨機無循環"<<endl;
return l;
}
else
{
srand(time(NULL));
k=1+rand()%len;
cout<<"循環到第"<<k<<"個節點"<<endl;
s=l;
for(int j=1;j<=k;j++)
s=s->next;
r->next=s;
return l;
}
}

bool j(node* l,int len)//通過函數判斷有無循環
{
for(int i=0;i<len;i++)
l=l->next;
if(l->next==NULL)return 0;
return 1;
}

void main()
{
node* l;
int len=0;
cout<<"請輸入鏈表長度:"<<endl;
cin>>len;
l=create(len);
if(j(l,len))cout<<"通過函數判斷為有循環"<<endl;
else cout<<"通過函數判斷為無循環"<<endl;
}

J. 鏈式存儲隊列的數據結構(邏輯結構+存儲結構)分析、鏈式存儲隊列的基本C語言結構體分析與定義

鏈式隊列

鏈式存儲結構的隊列稱作鏈式隊列。

鏈式隊列的隊頭指針指在隊列的當前隊頭結點位置,隊尾指針指在隊列的當前隊尾結點位置。不帶頭結點的鏈式隊列時可直接刪除隊頭指針所指的結點。

鏈式隊列中結點的結構體可定義如下:

typedef struct qnode

{

DataType datal;

Struct qnode *next;

}LQNode;

為了方便參數調用,通常把鏈式隊列的隊頭指針front和隊尾指針rear也定義為如下的結構體類型LQueue:

typedef struct

{

LQNode *front;

LQNode *rear;

}LQueue;

鏈式隊列操作的實現

(1) 初始化QueueInitiate(LQueue *Q)

void QueueInitiate(LQueue *Q)

{

Q->rear=NULL;

Q->front=NULL;

}

(2)非空否QueueNotEmpty(LQueue Q)

int QueueNotEmpty(LQueue Q)

/*判斷鏈式隊列Q非空否,非空返回1,否則返回0*/

{

if(Q.front==NULL)return 0;

else return 1;

}

(3)入隊列QueueAppend(LQueue *Q,DataType x)

int QueueAppend(LQueue *Q,DataType x)

/*把數據元素x插入鏈式隊列Q隊列的隊尾,入隊列成功返回1,否則返回0*/

{

LQNode *p;

if((p=(LQNode*)malloc(sizeof(LQNode)))==NULL)

{

printf(「內存不足無法插入!\n);

return 0;

}

p->data=x;

p->next=NULL;

if(Q->rear!=NULL)Q->rear->next=p;

Q->rear=p;

if(Q->front==NULL)Q->front=p;

return 1;

}

(4)出隊列QueueDelete(LQueue *Q,DataType *d)

int QueueDelete(LQueue *Q,DataType *d)

/*刪除鏈式隊列Q的隊頭數據元素值到d,出隊列成功返回1,否則返回0*/

{

LQNode *p;

if(Q->front==NULL)

{

printf(「隊列已空無數據元素出隊列!\n」);

return 0;

}

else

{

*d=Q->front->data;

p=Q->front;

Q->front=Q->front->next;

if(Q->front==NULL)Q->rear=NULL;

free(p);

return 1;

}

}

(5)取隊頭數據元素QueueGet(LQueue *Q,DataType *d)

int QueueGet(LQueue *Q,DataType *d)

/*取鏈式隊列Q的當前隊頭數據元素值到d,成功返回1,否則返回0*/

{

if(Q.front==NULL)

{

printf(「隊列已空無數據元素出隊列!\n);

return 0;

}

else

{

*d=Q.front->data;

return 1;

}

}

(6)撤銷動態申請空間Destory(LQueue *head)

int Destory(LQueue *head)

{

LQNode *p,*p1;

p=Q.front;

while(p!=NULL)

{

p1=p;

p=p->next;

free(p1);

}

}
幫你轉的,我覺得他描述的很清楚。希望對你有幫助。

熱點內容
安卓哪裡有李小龍 發布:2025-07-12 13:31:49 瀏覽:437
蘋果保存賬號密碼在哪裡找 發布:2025-07-12 13:31:07 瀏覽:98
東北大學c語言考試題 發布:2025-07-12 13:26:40 瀏覽:755
sha256在線加密 發布:2025-07-12 13:19:06 瀏覽:227
vbnet創建資料庫連接 發布:2025-07-12 13:15:34 瀏覽:232
為什麼社保卡在社康還要密碼 發布:2025-07-12 13:11:42 瀏覽:811
取隨機數php 發布:2025-07-12 12:58:16 瀏覽:840
如何配置組合音響 發布:2025-07-12 12:53:54 瀏覽:93
c語言冪計算 發布:2025-07-12 12:52:36 瀏覽:566
兔費WLAN密碼多少 發布:2025-07-12 12:50:59 瀏覽:861