《程序员面试宝典》练习

单链表排序、逆置、查找中间元素

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

//定义数据结构
typedef struct Node{
	int data;
	struct Node *next;
} Node,*P_Node;

//打印
void print(P_Node L){
	P_Node p = L->next;
	
	while(p){
		printf("%3d",p->data);
		p = p->next;
	}
	printf("\n");
} 

//初始化
void init(P_Node &L){
	L = (Node *)malloc(sizeof(Node));
	if(!L){
		printf("初始化失败！\n");
		exit(-1);
	}
	L->data = 0;
	L->next = NULL; 
	printf("初始化成功！\n");
} 

//创建单链表
void create(P_Node L){
	int data;
	P_Node r = L;
	while(true){
		scanf("%d",&data);
		if(data != 0){
			P_Node newNode = (P_Node)malloc(sizeof(Node));
			if(!newNode){
				printf("链表创建失败！\n");
				exit(-1);
			}
			newNode->data = data;
			newNode->next = r->next;
			r->next = newNode; 
			r = newNode;
			L->data++;
		}else{
			return ;
		}
	}
} 

//链表进行排序（冒泡） 
void sort(P_Node L){
	int i,j,tmp,n;
	P_Node p;
	n = L->data;
	for(i=1;i<n;i++){
		p = L->next;
		for(j=0;j<n-i;j++){
			if(p->data>p->next->data){
				tmp = p->data;
				p->data = p->next->data;
				p->next->data= tmp;
			}
			p = p->next;
		}
	}
} 
//单链表逆置
void reverse(P_Node L){
	P_Node preNode,curNode,nextNode;
	preNode = L->next;
	curNode = preNode->next;
	while(curNode){
		nextNode = curNode->next; //获取到当前节点的下一个节点 
		curNode->next = preNode;//当前节点的next指针由指向后一个改为指向前一个，目的是逆置 
		preNode = curNode;//前节点后移一位 
		curNode = nextNode;//当前节点后移一位，curNode为NULL时退出循环 也就是到了链表的尾部了 
	}
	L->next->next = NULL;//把第一个节点的next置为空  
	L->next = preNode;	//把头结点设置为preNode也就是逆置后的链表的第一个节点 
} 

//单链表只遍历一次，求出中间节点
void searchMind(P_Node L){
	P_Node p_slow,p_fast; //定义两个指针，慢指针一次走一步，快指针一次走两步，快指针走到尾部时，慢指针的位置即中间节点位置 
	p_slow = p_fast = L->next; //初始化慢指针和快指针为第一个节点位置 
	
	while(p_fast != NULL){
		p_fast = p_fast->next->next;
		p_slow = p_slow->next;
	} 
	printf("该链表的中间节点是：%3d\n",p_slow->data);
} 
int main(){
	P_Node L;
	init(L); //初始化 
	create(L);//创建 
	print(L); 
	//printf("此时链表长度：%3d\n",L->data);
	//printf("排序后：");
	//sort(L);//排序 
	//print(L); 
	//printf("逆置后："); 
	//reverse(L);//逆置 
	//print(L); 
	//searchMind(L);//遍历一次查找中间元素 
	
	printf("Hello world !\n");
	return 0;
} 

链队列的基本操作

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

//定义链式队列的结构体
typedef struct Node{
	int data;
	struct Node *next; 
}Node,*P_Node;

typedef struct Queen{
	struct Node *front;
	struct Node *rear;
} Queen,*P_Queen;

//打印
void print(P_Queen Q){
	P_Node p = Q->front->next;
	while(p){
		printf("%3d",p->data);
		p = p->next;
	}
	printf("\n");
} 
//初始化
void init(P_Queen Q){
	Q->front = Q->rear = (P_Node)malloc(sizeof(Node));
	if(Q->front == NULL){
		printf("初始化失败！\n");
		exit(-1);
	}
	Q->front->next = Q->rear->next = NULL;
	Q->front->data = 0;
	printf("初始化成功！\n");
} 
//入队
void inQueen(P_Queen Q, int data){
	P_Node p = (P_Node)malloc(sizeof(Node));
	if(p == NULL){
		printf("入队失败！\n");
		exit(-1);
	}
	p->data = data;
	p->next = NULL;
	Q->rear->next = p;
	Q->rear = p;
	Q->front->data ++; 
	printf("入队%3d\n",data);
} 
//出队
void outQueen(P_Queen Q){
	P_Node p; 
	if(Q->front == Q->rear){
		printf("队已空！\n");
		exit(-1);
	}
	p = Q->front->next;
	Q->front->next = p->next;
	printf("出队：%3d\n",p->data);
	if(p == Q->rear){
		Q->rear = Q->front;
	}
	free(p);
	Q->front->data--; 
} 

int main(){
	P_Queen Q;
	init(Q);
	inQueen(Q,1);
	inQueen(Q,2);
	inQueen(Q,3);
	print(Q); 
	outQueen(Q);
	outQueen(Q);
	print(Q);

	return 0;
}

链栈的基本操作

#include<stdio.h>
#include<stdlib.h>
//定义结构体
typedef struct Node{
	int data;
	struct Node *next;		
}Node,*P_Node;

typedef struct Stack{
	struct Node *top;
	struct Node *base;
}Stack,*P_Stack; 

//打印
void print(P_Stack S){
	P_Node p = S->top;
	while(p){
		printf("%3d",p->data);
		p = p->next;
	}
	printf("\n");
} 
//初始化
void init(P_Stack S){
	S->top = S->base = NULL;
	printf("初始化成功！\n");
} 
//入栈
void push(P_Stack S,int data){
	P_Node p = (P_Node)malloc(sizeof(Node));
	if(p == NULL){
		printf("进栈失败！\n");
	} 
	p->data = data;
	p->next = S->top; 
	S->top = p;
	printf("入栈%3d\n",data); 
} 
//出栈
void pop(P_Stack S){
	P_Node p;
	if(S->top ==S->base){
		printf("栈为空\n");
		exit(-1);	
	}
	p = S->top;
	S->top = p->next; 
	printf("出栈：%3d\n",p->data);
	free(p);
} 

int main(){
	P_Stack S;
	init(S);
	push(S,1);
	push(S,2);
	push(S,3);
	push(S,4);
	push(S,5);
	print(S);
	pop(S);
	pop(S);
	pop(S);
	print(S);
	
	return 0;	
}

双链表

#include<stdio.h>
#include<stdlib.h>
//定义结构体
typedef struct Node{
	int data;
	struct Node *next;	
	struct Node *pre;
} Node,*P_Node;

//打印
void print(P_Node L){
	P_Node p = L->next;
	while(p != NULL){
		printf("%3d",p->data);
		p = p->next;
	}	
	printf("\n");

} 

//初始化
void init(P_Node &L){
	L = (P_Node)malloc(sizeof(Node));
	if(L == NULL){
		printf("初始化失败！\n");
		exit(-1);
	} 
	L->data = 0;
	L->next = NULL;
 	
 	printf("初始化成功！\n"); 
} 
//创建双向链表
void create(P_Node L){
	int data;
	P_Node r,newNode;
	r = L;
	while(true){
		scanf("%3d",&data); 
		if(data != 0){
			newNode = (P_Node)malloc(sizeof(Node)); 
			if(newNode == NULL){
				printf("初始化失败！\n");
				exit(-1);
			}
			newNode->data = data;
			newNode->next = r->next;
			newNode->pre = r;
			r->next = newNode;
			r = newNode; 
			L->data++;
		}else{
			return ;
		}
	} 
} 
//获取链表长度
void getlength(P_Node L){
	printf("此时链表长度为：%3d\n",L->data);
} 
//在指定位置插入元素
void insert(P_Node L,int pos,int data){
	P_Node p,q;
	p = L;
	int i = 1;
	while(p && i<pos){
		p = p->next;
		i++;
	}
	if(p == NULL){
		printf("error pos !\n");
		exit(-1);
	}
	P_Node newNode = (P_Node)malloc(sizeof(Node));
	if(newNode == NULL){
		printf("插入节点失败！\n"); 
		exit(-1);
	} 
	newNode->data = data;
	newNode->next = p->next;
	newNode->pre = p;
	p->next->pre = newNode;
	p->next = newNode; 
	L->data++;
	printf("在第%3d个位置上插入元素:%3d\n",pos,data);
} 
//双链表删除指定位置的元素
void del(P_Node L,int pos){
	P_Node p,q;
	p = L;
	int i = 1;
	while(p && i<pos){
		p = p->next;
		i++;
	}
	if(p == NULL){
		printf("error pos !\n");
		exit(-1);
	} 
	q = p->next;
	p->next = q->next;
	q->next->pre = p;
	printf("删除第%3d个位置上的元素%3d\n",pos,q->data);
	free(q); 
	L->data--;

}
 
int main(){
	P_Node L;
	init(L);
	create(L);
	print(L);
 	getlength(L);
 	insert(L,3,0);
	print(L);
	getlength(L); 
	del(L,5);
	print(L);
	getlength(L);
	return 0;
}

约瑟夫环

#include<stdio.h>
#include<stdlib.h>
//定义结构体
typedef struct Node{
	int data;
	struct Node *next;
} Node,*P_Node;

//约瑟夫环（n为结点个数，m倍数，k开始位置） 
//思路：创建头结点->创建剩余的节点->移动到k位置上->移动到m-1位置上->出圈->循环 
void josephusRing(int n,int m,int k){ 
	P_Node curr,p,r;//curr为构建循环链表时的当前节点;p为进行判断时的当前节点;r为进行判断时的辅助节点;
	int i;
	//创建头结点即第一个节点 
	p = (P_Node)malloc(sizeof(Node));
	p->data = 1;
	p->next = p;//构建无头结点的循环链表 
	curr = p; //curr为构建链表时的当前节点 
	for(i=1;i<n;i++) {
		P_Node newNode = (P_Node)malloc(sizeof(Node)); 
		newNode->data = i+1;//尾插法 
		newNode->next = curr->next;
		curr->next = newNode;
		curr  = newNode; 
	}
	while(--k)r = p,p = p->next;//将指针p移动到k位置。p为循环链表创建时的第一个节点 
	while(n--){//对n个数依次进行判断 
		for(i=m-1;i--;r=p,p=p->next);//将指针r移动到m-1位置上准备删除。循环结束时指针p指向m位置上 
		r->next = p->next;//删除m位置上的节点
		printf("%d->",p->data);
		free(p);
		p = r->next;//指针p移动到m+1位置上的节点上，开始新一轮的判断 
	} 
} 
 
int main(){
	josephusRing(9,5,1); 
	printf("\n\n哈哈哈！约瑟夫环!\n");
	return 0;
}