常见的c语言编程题,常见的C语言面试编程题（二）

以下是单向链表、双向链表，栈，队列的C语言的实现方法，只包含简单的插入删除操作

1，单向链表的插入，删除，逆序操作

#include

#include

typedef struct Node

{

int key;

struct Node* next;

}* node;

node newNode(int k)

{

node n=(node)malloc(sizeof(node));

n->key=k;

n->next=NULL;

return n;

}

void printlist(node n)

{

if(!n)

{

printf("n is NULL list/n");

}

while(n)

{

printf("%d",n->key);

printf(" ");

n=n->next;

}

printf("/n");

}

node newList()

{

int k;

node head=(node)malloc(sizeof(node));;

scanf("%d",&k);

if(k==0)

{

head=NULL;

return head;

}

else

{

node n=newNode(k);

head=n;

while(k)

{

scanf("%d",&k);

if(k!=0)

{

node n1=newNode(k);

n->next=n1;

n=n->next;

}

}

n->next=NULL;

return head;

}

}

node insertNode(node n,int p,int k)

{

node n1=newNode(k);

node head=(node)malloc(sizeof(node));

head=n;

if(head==NULL)

{

n1->next=head;

return n1;

}

else

{

if(p==1)

{

n1->next=head;

head=n1;

return head;

}

else

{

int i=2;

while(i!=p&&(n->next))

{

n=n->next;

i++;

}

if(n->next==NULL)

{

printf("the p can't be found/n");

return head;

}

else

{

n1->next=n->next;

n->next=n1;

return head;

}

}

}

}

node deleteNode(node n,int k)

{

node n1=(node)malloc(sizeof(node));

node head=(node)malloc(sizeof(node));

head=n;

if(head==NULL)

{

printf("list is NULL/n");

return head;

}

else

{

if(head->key==k)

{

head=head->next;

return head;

}

while(n->key!=k&&n->next)

{

n1=n;

n=n->next;

}

if(n==NULL)

{

printf("can't find the same value as k in this list/n");

return head;

}

else

{

n1->next=n->next;

n=NULL;

return head;

}

}

}

node reverse(node n)

{

node n1[10];

node head=(node)malloc(sizeof(node));

node n2=(node)malloc(sizeof(node));

head=n;

if(head==NULL)

{

return head;

}

else

{

int i=0;

while(head!=NULL)

{

n2=head;

head=head->next;

n2->next=NULL;

n1[i]=n2;

i++;

}

head=n1[i-1];

for(int j=i-1;j>0;j--)

{

n1[j]->next=n1[j-1];

}

return head;

}

}

int main()

{

node n=newList();

printlist(n);

//插入操作

int k,p;

scanf("%d,%d",&p,&k);

node nn=insertNode(n,p,k);

printlist(nn);

//删除操作

int q;

scanf("%d",&q);

node nd=deleteNode(nn,q);

printlist(nd);

//链表的倒置操作

node m=reverse(n);

printlist(m);

return 0;

}

2，双向链表的插入删除操作

#include

#include

typedef struct Node

{

int key;

struct Node* pre;

struct Node* next;

}* node;

node newNode(int i)

{

node n=(node)malloc(sizeof(node));

n->key=i;

n->pre=NULL;

n->next=NULL;

return n;

}

node newduplinklist()

{

int i;

scanf("%d",&i);

node n;

if(i==0)

{

n=NULL;

return n;

}

n=newNode(i);

node head=n;

int k=1;

while(k!=0)

{

scanf("%d",&k);

if(k!=0)

{

node n1=newNode(k);

n->next=n1;

n1->pre=n;

n=n1;

}

}

n->next=head;

head->pre=n;

return head;

}

int sizeduplinklist(node n)

{   if(n==NULL) return 0;

node head=n;

int i=1;

while(head->next!=n)

{

head=head->next;

i++;

}

return i;

}

void  print(node n)

{

if(n==NULL)

printf("此时链表为空!");

else

{

printf("输出链表:/n");

for(int i=0;i

{

printf("%-2d",n->key);

n=n->next;

}

printf("/n");

}

}

node insertNode(node n)

{

int p,k;

printf("插入位置p:/n");

scanf("%d,%d",&p,&k);

printf("/n");

if(p>sizeduplinklist(n))

{

printf("此位置超出链表的长度!/n");

return n;

}

else if(p<1)

{

printf("此位置不存在!/n");

return n;

}

else

{

node n1,head,m;

m=newNode(k);

head=n;

if(p==1)

{

m->pre=n->pre;

n->pre->next=m;

m->next=n;

n->pre=m;

return m;

}

else

{

int i=1;

while(i!=p)

{

n1=n;

n=n->next;

i++;

}

n1->next=m;

m->pre=n1;

m->next=n;

n->pre=m;

return head;

}

}

}

node delNode(node n)

{

int p;

printf("删除位置p:/n");

scanf("%d",&p);

printf("/n");

if(p>sizeduplinklist(n))

{

printf("此位置超出链表的长度!/n");

return n;

}

else if(p<1)

{

printf("此位置不存在!/n");

return n;

}

else

{

node n1,head;

if(p==1)

{   head=n->next;

n->pre->next=n->next;

n->next->pre=n->pre;

return head;

}

else

{

head=n;

int i=1;

while(i!=p)

{

n1=n;

n=n->next;

i++;

}

n1->next=n->next;

n->next->pre=n1;

return head;

}

}

}

int main()

{

node n=newduplinklist();

printf("%d/n",sizeduplinklist(n));

print(n);

node m=insertNode(n);

print(m);

node m1=delNode(m);

print(m1);

return 0;

}

3，栈操作，用数组实现的包含出栈，入栈的操作

#include

#include

typedef struct Sta

{

int a[20];

int num;

}* sta;

sta NullStack()

{

sta s=(sta)malloc(sizeof(sta));

s->num=0;

return s;

}

sta pushstack(sta s,int i)

{

s->a[s->num]=i;

s->num=s->num+1;

return s;

}

sta popstack(sta s)

{

if(s->num==0)

{

printf("stack is NULL/n");

return s;

}

s->num=s->num-1;

return s;

}

void printstack(sta s)

{

if(s->num==0)

{

printf("stack is NULL/n");

}

else

{

for(int i=s->num-1; i>=0;i--)

{

printf("%d/n",s->a[i]);

}

}

}

int main()

{

sta s=NullStack();

s=pushstack(s,1);

s=pushstack(s,2);

printstack(s);

s=popstack(s);

s=popstack(s);

printstack(s);

return 0;

}

4，队列操作，类似于栈，

#include

#include

typedef struct Que

{

int a[20];

int num;

}* que;

que NullQueue()

{

que q=(que)malloc(sizeof(que));

q->num=0;

return q;

}

que enq(que q,int i)

{

q->a[q->num]=i;

q->num=q->num+1;

return q;

}

que deq(que q)

{

if(q->num==0)

{

printf("queue is NULL/n");

return q;

}

for(int i=1;inum;i++)

{

q->a[i-1]=q->a[i];

}

q->num=q->num-1;

return q;

}

void printqueue(que q)

{

if(q->num==0)

{

printf("queue is NULL/n");

}

else

{

for(int i=q->num-1; i>=0;i--)

{

printf("%3d",q->a[i]);

}

}

}

int main()

{

que q=NullQueue();

q=enq(q,1);

q=enq(q,2);

q=enq(q,3);

q=enq(q,4);

printqueue(q);

printf("/n");

q=deq(q);

//printf("%d",s->a[0]);

//q=deq(q);

printqueue(q);

return 0;

}