c語言隊列插入怎麼刪除

㈠ c語言隊列的插入與刪除

#include<stdio.h>
#include<stdlib.h>
#defineMAXQSIZE100//最大隊列長度
#defineOK1
#defineERROR0
#defineOVERFLOW-2
typedefstruct
{
	int*base;
	intfront;
	intrear;//尾指針，若隊列不空，指向隊列尾元素的下一個位置
}SqQueue;

voidInitQueue(SqQueue*Q)
{
	Q->front=Q->rear=0;
	if(Q->base==NULL){
		Q->base=(int*)malloc(sizeof(int)*MAXQSIZE);
	}
}

voidDesQueue(SqQueue*Q){
	free(Q->base);
	Q->base=NULL;
	Q->front=Q->rear=0;
}

intQueueLength(SqQueue*Q)
{
	if(Q->base==NULL)returnERROR;
	return(Q->rear-Q->front+MAXQSIZE)%MAXQSIZE;
}

voiddisplay(SqQueue*Q)
{
	inti;
	if(Q->base==NULL){
		printf("
ERROR");
		return;
	}
	for(i=Q->front;i!=Q->rear;i++){
		i=i%MAXQSIZE;
		printf("%3d",Q->base[i]);
	}
	printf("
");
}

intInQueue(SqQueue*Q,inte)
{
	if(Q->base==NULL)returnERROR;
	if((Q->rear+1)%MAXQSIZE==Q->front)
		returnOVERFLOW;
	Q->base[Q->rear]=e;
	Q->rear=(Q->rear+1)%MAXQSIZE;
	returnOK;
}

intDeQueue(SqQueue*Q,intm)
{
	inti=0;
	if(Q->base==NULL)returnERROR;
	if(Q->front==Q->rear)
		returnERROR;
	while(i!=m&&Q->front!=Q->rear)
	{
		printf("
%dDeleted
",Q->base[Q->front]);
		Q->front=(Q->front+1)%MAXQSIZE;
		i++;
	}
	if(i!=m){
		printf("
ERROR");
		returnERROR;
	}
	returnOK;
}

voidmain()
{
	intm,n,d,i;
	SqQueueQ={0,0,0};
	InitQueue(&Q);
	printf("請輸入要插入的元素個數：");
	scanf("%d",&m);
	printf("要插入的元素:");
	for(i=1;i<=m;i++)
	{
		scanf("%d",&n);
		InQueue(&Q,n);
	}
	printf("插入元素後,隊列中的元素為:");
	display(&Q);
	printf("隊列長度為:");
	printf("%d
",QueueLength(&Q));
	printf("輸入要刪除的元素個數:");
	scanf("%d",&d);
	DeQueue(&Q,d);
	printf("
刪除元素後，隊列中元素為:");
	display(&Q);
	printf("
");
	DesQueue(&Q);
}

㈡ c語言隊列如何刪除任意元素

如果是數組形式存儲的隊列，將後續元素前移一個單元，並將隊列計數減1；
如果是單向鏈表形式存儲的隊列，需要得到要刪除元素前一個元素的指針，提取要刪除元素指針，將前一個元素的後繼指針修改成要刪除元素的後繼指針內容，然後利用前面提取的要刪除元素指針將該元素刪除。

㈢ 不會做啊，求高手幫忙，用c語言建立鏈隊列,顯示每個結點,並進行插入,刪除處理

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

/*****************************/

typedef struct student
{
int number;
char name[20];
int subject[5];
float avg;
struct STU *next;
}STU,*PSTU;

/*****************************/
void initial_stu(PSTU pstu, int number, char *name, int *subject, float avg, struct STU *next)
{
int i;
(*pstu).number =number;
(*pstu).avg=avg;
(*pstu).next=next;
for(i=0;i<20;i++) { (*pstu).name[i] = name[i]; }
for(i=0;i<5;i++) { (*pstu).subject[i] = subject[i]; }

return;
}

/*****************************/

/*****************************/
void print_stu(STU stu)
{
int i;
printf("\nnumber = %d",stu.number);
printf("\nname = %s",stu.name);
printf("\nsubject =");
for(i=0;i<5;i++) { printf(" %d",stu.subject[i]); }
printf("\navg = %f",stu.avg);
printf("\nnext = %d\n",stu.next);
return;
}

/*****************************/

void print_stu_number(STU stu)
{
int i;
printf("\nnumber = %d",stu.number);
printf("\nname = %s",stu.name);
return;
}

/*****************************/

void creat_link(PSTU *pstu,STU stu)
{
int i;
*pstu = (STU *)malloc(sizeof(STU));

(**pstu).number = stu.number;
(**pstu).avg = stu.avg;
(**pstu).next = stu.next;
for(i=0;i<20;i++) { (**pstu).name[i] = stu.name[i]; }
for(i=0;i<5;i++) { (**pstu).subject[i] = stu.subject[i]; }

return;
}

/*****************************/

void append_link(PSTU pstu, STU stu)
{
int i;
PSTU pstu_tmp=pstu;

while((*pstu_tmp).next!=NULL)
{
pstu_tmp=(*pstu_tmp).next;
}

(*pstu_tmp).next = (STU *) malloc(sizeof(STU));
pstu_tmp=(*pstu_tmp).next;

(*pstu_tmp).number = stu.number;
(*pstu_tmp).avg = stu.avg;
(*pstu_tmp).next = stu.next;
for(i=0;i<20;i++) { (*pstu_tmp).name[i] = stu.name[i]; }
for(i=0;i<5;i++) { (*pstu_tmp).subject[i] = stu.subject[i]; }

return;
}

/*****************************/

void print_link(PSTU pstu)
{
int i;
PSTU pstu_tmp=pstu;

while(pstu_tmp!=NULL)
{
print_stu(*pstu_tmp);
pstu_tmp=(*pstu_tmp).next;
}

return;
}

/*****************************/

/*****************************/

void print_link_number(PSTU pstu)
{
int i;
PSTU pstu_tmp=pstu;

while(pstu_tmp!=NULL)
{
print_stu_number(*pstu_tmp);
pstu_tmp=(*pstu_tmp).next;
}

return;
}

/*****************************/

/*****************************/

void sort_by_number(PSTU *pstu_ptr, int rise1_fall2)
/** rise1_fall2=1 : sort_rise; rise1_fall2=2 : sort_fall; **/
{
int min;
int flag=1;
PSTU pstu = *pstu_ptr;
PSTU pstu_last = pstu;
PSTU pstu_min = pstu;
PSTU pstu_min_last = pstu;

PSTU pstu_tmp1;
PSTU pstu_tmp2;

min = (*pstu).number;

/** To find the min data element **/
while(pstu!=NULL && (*pstu).next!=NULL)
{
if(
((rise1_fall2==1)&&min>(*((*pstu).next)).number ) ||
((rise1_fall2==2)&&min<(*((*pstu).next)).number )
)

{
pstu_min = (*pstu).next;
min = (*((*pstu).next)).number;
pstu_min_last = pstu_last;
}

pstu=(*pstu).next;
pstu_last = pstu;
}
/*---------------------------------*/

/** Make sure that, the first element has the min number **/
pstu = *pstu_ptr;
if(
( (rise1_fall2==1)&&(*pstu).number>min ) ||
( (rise1_fall2==2)&&(*pstu).number<min )
)
{
pstu_tmp1 = (*pstu).next;
(*pstu).next = (*pstu_min).next;
(*pstu_min).next = pstu_tmp1;

pstu_tmp2 = *pstu_ptr;
*pstu_ptr = (*pstu_min_last).next;
(*pstu_min_last).next = pstu_tmp2;
}
/*---------------------------------*/

while(flag==1)
{
pstu = (**pstu_ptr).next;
pstu_last = *pstu_ptr;
flag = 0;

/*************/
while(pstu!=NULL&&(*pstu).next!=NULL)
{

if(
( (rise1_fall2==1)&&(*pstu).number>(*((*pstu).next)).number ) ||
( (rise1_fall2==2)&&(*pstu).number<(*((*pstu).next)).number )
)
{
flag = 1;

(*pstu_last).next = (*pstu).next;
(*pstu).next = (*((*pstu).next)).next;
(*((*pstu_last).next)).next = pstu;

pstu = (*pstu_last).next;
}

pstu_last = pstu;
pstu=(*pstu).next;
}
/*************/

}

return;
}

/*****************************/
main()
{
STU stu1, stu2, stu3, stu4, stu5, stu6, stu7, stu8, stu9, stu10;
PSTU STU_LINK;
int subject1[5] = {1,1,1,1,1};
int subject2[5] = {2,2,2,2,2};
int subject3[5] = {3,3,3,3,3};
int subject4[5] = {4,4,4,4,4};
int subject5[5] = {5,5,5,5,5};
int subject6[5] = {6,6,6,6,6};
int subject7[5] = {7,7,7,7,7};
int subject8[5] = {8,8,8,8,8};
int subject9[5] = {9,9,9,9,9};
int subject10[5] = {10,10,10,10,10};

initial_stu(&stu1, 5, "liming_1",subject1, 1.11, NULL);
initial_stu(&stu2, 6, "liming_2",subject2, 2.22, NULL);
initial_stu(&stu3, 3, "liming_3",subject3, 3.33, NULL);
initial_stu(&stu4, 2, "liming_4",subject4, 4.44, NULL);
initial_stu(&stu5, 4, "liming_5",subject5, 5.55, NULL);
initial_stu(&stu6, 7, "liming_6",subject6, 6.66, NULL);
initial_stu(&stu7, 1, "liming_7",subject7, 7.77, NULL);
initial_stu(&stu8, 8, "liming_8",subject8, 8.88, NULL);
initial_stu(&stu9, 10, "liming_9",subject9, 9.99, NULL);
initial_stu(&stu10, 9, "liming_10",subject10, 10.00, NULL);

/*
print_stu(stu1);
print_stu(stu2);
*/

creat_link(&STU_LINK,stu1);
append_link(STU_LINK,stu2);
append_link(STU_LINK,stu3);
append_link(STU_LINK,stu4);
append_link(STU_LINK,stu5);
append_link(STU_LINK,stu6);
append_link(STU_LINK,stu7);
append_link(STU_LINK,stu8);
append_link(STU_LINK,stu9);
append_link(STU_LINK,stu10);

printf("\n=====================================");
printf("\nLet us print the whole link :\n");
print_link(STU_LINK);

printf("\n=====================================");
printf("\nLet us print the sorted link :\n");

/** rise1_fall2=1 : sort_rise; rise1_fall2=2 : sort_fall; **/
sort_by_number(&STU_LINK,1);
print_link_number(STU_LINK);

printf("\n=====================================");

/** rise1_fall2=1 : sort_rise; rise1_fall2=2 : sort_fall; **/
sort_by_number(&STU_LINK,2);
print_link_number(STU_LINK);

/* */
getch();
}

㈣ C語言求完善數組的插入和刪除

C語言中的數組本質上是在計算機內存中分配的連續空間。
如果需要對元素進行插入和刪除，並不能直接將內存中為該數組分配的空間進行插入/新增和刪除，而是只能通過數據復制的方式將本來不在這個位置的元素進行移動，看起來像是元素的前移和後移。
舉個例子吧：整型數組(1, 2, 3, 4, 5)，如果要把2刪除，那麼可以將3，4，5分別向前移動，變成(1, 3, 4, 5, 5)。由於數組長度分配以後不會變化，因此最後一個多餘的5實際上並不能刪掉，它只是表示無意義的位置。因此對於編程人員來講，需要另一個參數來記錄這個數組中你認為有用的元素是前多少個。
值得注意的是，如果數組長度不足以保存新的元素時，是無法動態地增加數組長度的。如果非要這么做，必須要在數組分配時保證數組大小足夠大。這也就是一些新手經常將數組長度設置為1000，10000的原因。
回到這個問題：

// 預定義的數組，長度為20int array[20] = {0};// 數組當前有效長度int arrayLen = 0; // 如果不是全局數組，則需要將數組指針和數組長度指針傳入進行修改void insertArray(int newElement, int index){ // 這里沒有做數組長度的檢驗，你需要自己完成 int i; for (i = arrayLen++; i > index; ) array[i--] = array[i - 1]; // 後移 array[index] = newElement;} void deleteArrayElement(int index){ for ( ; index < arrayLen; ) array[index++] = array[index + 1]; // 前移。要刪除的位置會被直接覆蓋 arrayLen--;}

㈤ 我想要c語言，隊列方面最基礎的知識，基本操作

隊列是一種特殊的線性表，它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。 在隊列這種數據結構中，最先插入在元素將是最先被刪除；反之最後插入的元素將最後被刪除，因此隊列又稱為「先進先出」（FIFO—first in first out）的線性表。 隊列空的條件：front=rear 隊列滿的條件： rear = MAXSIZE 隊列可以用數組Q[1…m]來存儲，數組的上界m即是隊列所容許的最大容量。在隊列的運算中需設兩個指針：head，隊頭指針，指向實際隊頭元素的前一個位置；tail，隊尾指針，指向實際隊尾元素所在的位置。一般情況下，兩個指針的初值設為0，這時隊列為空，沒有元素。圖1 ( a)畫出了一個由6個元素構成的隊列，數組定義Q[1…10]。Q(i) i=3,4,5,6,7,8頭指針head＝2，尾指針tail＝8。隊列中擁有的元素個數為:L=tail-head現要讓排頭的元素出隊，則需將頭指針加1。即head=head+1這時頭指針向上移動一個位置，指向Q(3)，表示Q(3)已出隊。見圖1 (b)。如果想讓一個新元素入隊，則需尾指針向上移動一個位置。即tail=tail+1這時Q(9)入隊，見圖1 (c)。當隊尾已經處理在最上面時，即tail=10，如果還要執行入隊操作，則要發生"上溢"，但實際上隊列中還有三個空位置，所以這種溢出稱為"假溢出"。 克服假溢出的方法有兩種。一種是將隊列中的所有元素均向低地址區移動，顯然這種方法是很浪費時間的；另一種方法是將數組存儲區看成是一個首尾相接的環形區域。當存放到n地址後，下一個地址就"翻轉"為1。在結構上採用這種技巧來存儲的隊列稱為循環隊列。 隊列和棧一樣只允許在斷點處插入和刪除元素。 循環隊的入隊演算法如下： 1、tail=tail+1； 2、若tail=n+1，則tail=1； 3、若head=tail尾指針與頭指針重合了，表示元素已裝滿隊列，則作上溢出錯處理； 4、否則，Q(tail)=X，結束（X為新入出元素）。 隊列和棧一樣，有著非常廣泛的應用。

具體網上查:
http://ke..com/view/38959.htm?fr=ala0_1_1

㈥ C語言中，隊列是什麼意思，有什麼用途

隊列是一種特殊的線性表。

隊列一種可以實現「先進先出」的存儲結構，即「一端入，一端出」，隊首(front)出隊，隊尾(rear)入隊，若front指向隊首，則rear指向隊尾最後一個有效元素的下一個元素；若rear指向隊尾，則front指向隊首第一個有效元素的下一個元素。

隊列特殊之處在於它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作，和棧一樣，隊列是一種操作受限制的線性表。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。

(6)c語言隊列插入怎麼刪除擴展閱讀

循環隊列各個參數的含義

1、隊列初始化front和rear的值都是零,初始化時隊列就是空的。

2、隊列非空front代表隊列的第一個元素rear代表了最後一個有效元素的下一個元素。

3、隊列空front和rear的值相等，但是不一定是零。

㈦ c語言隊列操作

pq->rear->next
=
pnew這個代碼從隊列的尾部增加新節點，
然後pq->rear
=
pnew更新隊列尾部指針。隊列的數據結構形式就是由一個頭front指針，一個尾rear指針來表徵，items的設計是用空間換時間，涉及隊列大小的操作會非常方便。
隊列的特徵是先進先出，你給出的鏈式實現，其實就跟一個鏈表一樣，鏈表的添加刪除如果能理解了，隊列只是鏈表的元素增加/刪除
按先進先出特點的一種實現。
但對於隊列來說，實現方式不是重點，先進先出的性質才是重點，這在實際應用中很多，比如排隊叫號。

㈧ C語言 數據結構 循環隊列插入操作

#include<stdio.h>
#include<malloc.h>

struct link_cqueue
{
int data;
struct link_cqueue *next;
};

//初始化循環鏈隊列
struct link_cqueue *init_link_cqueue()
{
struct link_cqueue *rear;
rear=NULL; /*隊尾指針設置為空*/
return rear;
}

//（1）插入（即入隊）演算法：
struct link_cqueue *EnCQueue(struct link_cqueue *rear, int x)
{ //設循環鏈隊列的隊尾指針為rear,x為待插入的元素
struct link_cqueue *p;
p=(struct link_cqueue *)malloc(sizeof(struct link_cqueue));
p->data=x;
if(rear==NULL) //如為空隊，建立循環鏈隊列的第一個結點
{
rear=p;
rear->next=p; //鏈接成循環鏈表
}
else //否則在隊尾插入p結點
{
p->next=rear->next;
rear->next=p;
rear=p;
}
return rear;
}
//（2）刪除（即出隊）演算法：
struct link_cqueue *DeCQueue(struct link_cqueue *rear)
{ //設循環鏈隊列的隊尾指針為rear
if (rear==NULL) //空隊
printf("隊列為空無法刪除！\n");
else if(rear->next==rear) //隊中只有一個結點
rear=NULL;
else
rear->next=rear->next->next; //rear->next指向的結點為循環鏈隊列的隊頭結點
return rear;
}

//循環隊列的輸出
void print_link_cqueue(struct link_cqueue *rear)
{
struct link_cqueue *p;

if(!rear)
printf("隊列為空！\n");
else
{
printf("%5d",rear->next->data);
p=rear->next;
while(p!=rear)
{
printf("%5d",p->next->data);
p=p->next;
}
}
printf("\n");
}

main()
{
struct link_cqueue *rear;
int x;
int c;
rear=init_link_cqueue();
do
{
printf("請選擇入隊或出隊操作：1：入隊；2：出隊；3：輸出！\n");
scanf("%d",&c);

if(c==1)
{
printf("請輸入要入隊的元素：");
scanf("%d",&x);
rear=EnCQueue(rear,x);
}
else if(c==2)
{
rear=DeCQueue(rear);
}
else if(c==3)
print_link_cqueue(rear);
else
printf("選擇錯誤，請重新選擇");
}while(1);
}

㈨ c語言隊列插入元素操作

把q->rear改為rear

q->rear是只想隊列
而M-1代表元素個數
只能用rear與之對應