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与之对应