链表面试题（上）

SListNode.h

#ifndef _SLISTNODE_H_
#define _SLISTNODE_H_
#include<stdio.h>
#include<assert.h>
#include<string.h>
#include<malloc.h>
#include<windows.h>

typedef int DataType;

typedef struct SListNode 
{ 
	struct SListNode* _next; 
	DataType _data; 
}SListNode;

SListNode* Init();
SListNode* BuySListNode(DataType x); 
void SListPrint(SListNode* pHead); 
void SListDestory(SListNode** ppHead); 

void SListPushBack(SListNode** ppHead, DataType x); 
void SListPopBack(SListNode** ppHead); 
void SListPushFront(SListNode** ppHead, DataType x); 
void SListPopFront(SListNode** ppHead); 
SListNode* SListFind(SListNode* pHead, DataType x); 
void SListInsert(SListNode** ppHead, SListNode* pos, DataType x); 
void SListErase(SListNode** ppHead, SListNode* pos); 

//test*************
void test1();
void test2();
void test3();
void testAddDel();
void testJosephCircle();
void testSListReverse();
void testSListBubbleSort();
void testSListMerge();
void testSListFindMidNode();
void testSListFindTailKNode();
//********************

//链表面试题
void SLitsPrintTailToHead(SListNode* pHead) ;
void SListPrintTailToHeadR(SListNode* pHead) ;

void SListDelNonTailNode(SListNode* pos) ;
void SListInsertFrontNode(SListNode* pos, DataType x) ;
SListNode* SListJosephCircle(SListNode* pHead, int k) ;
SListNode* SListReverse(SListNode* list) ;
void SListBubbleSort(SListNode* list) ;
// 升序 
SListNode* SListMerge(SListNode* list1, SListNode* list2) ;
SListNode* SListFindMidNode(SListNode* list) ;
SListNode* SListFindTailKNode(SListNode* list, size_t k) ;

#endif

SListNode.c

#include"SListNode.h"

//初始化
SListNode* Init(){
	SListNode* head = (SListNode *)malloc(sizeof(SListNode));
	head->_next=NULL;
	return head;
}

//创建一个结点
SListNode* BuySListNode(DataType x){
	SListNode *node = (SListNode *)malloc(sizeof(SListNode));
	node->_data=x;
	node->_next=NULL;
	return node;
}

//打印单链表
void SListPrint(SListNode* pHead){

	SListNode* cur;
	assert(pHead);
	cur = pHead->_next;
	while(cur){
		printf("%d ",cur->_data);
		cur=cur->_next;
	}
	printf("
");
}

//销毁
void SListDestory(SListNode** ppHead){
	SListNode *cur,*t;
	assert(ppHead);
	cur = *ppHead;
	while(cur){
		t = cur->_next;
		free(cur);
		cur = t;
	}
}

//尾插；
void SListPushBack(SListNode **ppHead, DataType x){
	
	SListNode *newNode = BuySListNode(x);
	SListNode *cur;
	assert(ppHead);
	cur=*ppHead;
	while(cur->_next){
		cur=cur->_next;
	}
	cur->_next=newNode;
}

//尾出
void SListPopBack(SListNode** ppHead){
	SListNode *cur,*pr;
	if((*ppHead)->_next==NULL){
		printf("表空
");
		return;
	}
	pr=cur=*ppHead;
	assert(ppHead);
	while(cur->_next){
		pr = cur;
		cur=cur->_next;
	}
	free(cur);
	pr->_next=NULL;
}
//头入
void SListPushFront(SListNode** ppHead, DataType x){
	SListNode *head,*newNode;
	assert(ppHead);
	head = *ppHead;
	newNode = BuySListNode(x);
	newNode->_next = head->_next;
	head->_next=newNode;

}
//头出
void SListPopFront(SListNode** ppHead){
	SListNode *head,*temp;
	assert(ppHead);
	if((*ppHead)->_next==NULL){
		printf("空表
");
		return;
	}

	temp = head = *ppHead;
	temp = temp->_next;
	head->_next = temp->_next;
	free(temp);
}
//查找值为x的节点
SListNode* SListFind(SListNode* pHead, DataType x){
	SListNode* cur;
	assert(pHead);
	cur = pHead;
	while(cur){
		if(cur->_data==x){
			return cur;
		}
		cur = cur->_next;
	}
	return NULL;
}
//在pos节点前插入一个值为x的节点
void SListInsert(SListNode** ppHead, SListNode* pos, DataType x){
	SListNode *cur,*pr,*newNode;
	newNode = BuySListNode(x);
	assert(ppHead);
	assert(pos);
	pr = cur = *ppHead;
	while(cur&&cur!=pos){
		pr = cur;
		cur = cur->_next;
	}
	if(cur){
		newNode->_next = cur;
		pr->_next = newNode;
	}
}
//删除指定节点
void SListErase(SListNode** ppHead, SListNode* pos){
	SListNode *cur,*pr;
	assert(ppHead);
	assert(pos);
	pr = cur = *ppHead;
	while(cur&&cur!=pos){
		pr = cur;
		cur = cur->_next;
	}
	pr->_next = cur->_next;
	free(cur);
}

viewtest.c

#include"SListNode.h"

//从尾到头打印单链表 （非递归）
void SLitsPrintTailToHead(SListNode* pHead){
	SListNode *cur,*tail;
	assert(pHead);
	cur = pHead;
	tail = (SListNode*)malloc(sizeof(SListNode));
	tail = NULL;
	while(tail != pHead->_next){
		cur = pHead;
		while(cur->_next!=tail){
			cur=cur->_next;
		}
		printf("%d ",cur->_data);
		tail = cur;
	}
	printf("
");
}

//从尾到头打印单链表 （递归）
void SListPrintTailToHeadR(SListNode* pHead){
	if(pHead==NULL)
		return;
	SListPrintTailToHeadR((pHead)->_next);
	printf("%d ",(pHead)->_data);
}

//删除一个无头单链表的非尾节点（不能遍历链表） 
void SListDelNonTailNode(SListNode* pos) {
	SListNode *cur;
	assert(pos&&pos->_next);
	cur=pos->_next;
	pos->_data = cur->_data;
	pos->_next = cur->_next;
	free(cur);
	cur = NULL;
}

//在无头单链表的一个节点前插入一个节点（不能遍历链表） 
void SListInsertFrontNode(SListNode* pos, DataType x){
	SListNode *newNode;
	assert(pos);
	newNode = BuySListNode(pos->_data);
	newNode->_next = pos->_next;
	pos->_next = newNode;
	pos->_data = x;
}

//打印环形链表
void printCList(SListNode* phead){
	SListNode* cur = phead;
	cur = cur->_next;
	printf("%d ",phead->_data);
	while(cur!=phead){
		printf("%d ",cur->_data);
		cur = cur->_next;
	}
	printf("
");

}


//单链表实现约瑟夫环(JosephCircle) 
SListNode* SListJosephCircle(SListNode* pHead, int k) {
	int i, j, flag=1;
	SListNode *cur, *k_cur;
	assert(pHead);
	cur = pHead;
	while(cur->_next){
		cur = cur->_next;
	}
	cur->_next = pHead->_next; //链接为环
	cur = cur->_next;
	i = k;
	j = 1;

	while(cur!=cur->_next){
		j++;
		if(j==k){
			k_cur = cur->_next;
			cur->_next = k_cur->_next;
			free(k_cur);
			k_cur = NULL;
			j = 1;
			printCList(cur);
		}
		cur = cur->_next;
	}
	return cur;
}

//逆置/反转单链表 
SListNode* SListReverse(SListNode* list) {
	SListNode *cur, *tail=NULL;
	DataType tmp;
	assert(list);
	cur = list->_next;
	while(list->_next!=tail){
		cur = list->_next;
		while(cur->_next!=tail){
			tmp = cur->_data;
			cur->_data=cur->_next->_data;
			cur->_next->_data=tmp;
			cur = cur->_next;
		}
		tail =cur;
	}
	return list;
}

//单链表排序（冒泡排序&快速排序） 
void SListBubbleSort(SListNode* list){
	int flag;
	SListNode *cur, *tail = NULL;
	DataType tmp;
	assert(list);
	cur = list->_next;
	while(list->_next!=tail){
		flag = 0;
		cur = list->_next;
		while(cur->_next!=tail){
			if(cur->_data>cur->_next->_data){
				tmp = cur->_data;
				cur->_data = cur->_next->_data;
				cur->_next->_data = tmp;
				flag = 1;
			}
			cur = cur->_next;
		}
		if(flag==0)
			return ;
		tail = cur;
	}
}

//void quicksort(SListNode* list){
//
//}


// 并归升序 
SListNode* SListMerge(SListNode* list1, SListNode* list2){
	SListNode* cur1=list1->_next, *cur2=list2->_next;
	SListNode* newList = Init();
	assert(list1&&list2);
	while(cur1&&cur2){
		if(cur1->_data>cur2->_data){
			SListPushBack(&newList,cur2->_data);
			cur2=cur2->_next;
		}
		else{
			SListPushBack(&newList,cur1->_data);
			cur1=cur1->_next;
		}
	}
	while(cur1){
		SListPushBack(&newList,cur1->_data);
		cur1=cur1->_next;
	}
	while(cur2){
		SListPushBack(&newList,cur2->_data);
		cur2=cur2->_next;
	}
	return newList;
}

//找到中间结点
SListNode* SListFindMidNode(SListNode* list) {
	SListNode *fastnode=list->_next;
	SListNode *slownode=list->_next;
	assert(list);
	while(fastnode&&fastnode->_next){
		fastnode = fastnode->_next->_next;
		slownode = slownode->_next;
	}
	return slownode;
}
//找到倒数第k个结点
SListNode* SListFindTailKNode(SListNode* list, size_t k){
	SListNode* fast = list->_next;
	SListNode* slow = list->_next;
	assert(list);
	while(fast&&k--)
		fast=fast->_next;
	while(fast){
		fast=fast->_next;
		slow=slow->_next;
	}
	return slow;
}

//从尾到头打印单链表
void test3(){
	SListNode *list=Init();
	SListPushBack(&list,1);
	SListPushBack(&list,2);
	SListPushBack(&list,3);
	SListPushBack(&list,4);
	SListPushBack(&list,5);
	SListPrint(list);
	SLitsPrintTailToHead(list);
	SListPrintTailToHeadR(list->_next);
}	

//无头节点的增加删除
void testAddDel(){
	SListNode *node;
	SListNode *list=Init();
	SListPushBack(&list,1);
	SListPushBack(&list,2);
	SListPushBack(&list,3);
	SListPushBack(&list,4);
	SListPushBack(&list,5);
	SListPrint(list);
	node = SListFind(list,3);
	SListInsertFrontNode(node,6);	//在3的节点前插入6
	SListPrint(list);
	node = SListFind(list,4);		//删除节点为4的节点
	SListDelNonTailNode(node);
	SListPrint(list);
}

//测试约瑟夫环
void testJosephCircle(){
	SListNode *list=Init();
	SListPushBack(&list,1);
	SListPushBack(&list,2);
	SListPushBack(&list,3);
	SListPushBack(&list,4);
	SListPushBack(&list,5);
	SListPushBack(&list,6);
	SListPushBack(&list,7);
	SListPushBack(&list,8);
	SListPushBack(&list,9);
	SListPushBack(&list,0);
	SListPrint(list);
	SListJosephCircle(list,3);
}

//测试单链表逆置
void testSListReverse(){
	SListNode *list=Init();
	SListPushBack(&list,1);
	SListPushBack(&list,2);
	SListPushBack(&list,3);
	SListPushBack(&list,4);
	SListPushBack(&list,5);
	SListPushBack(&list,6);
	SListPrint(list);
	list = SListReverse(list);
	SListPrint(list);
}

void testSListBubbleSort(){
	SListNode *list=Init();
	SListPushBack(&list,5);
	SListPushBack(&list,2);
	SListPushBack(&list,1);
	SListPushBack(&list,7);
	SListPushBack(&list,4);
	SListPushBack(&list,6);
	SListPrint(list);
	SListBubbleSort(list);
	SListPrint(list);
}


void testSListMerge(){
	SListNode *list1=Init();
	SListNode *list2=Init();
	SListNode *list=Init();
	SListPushBack(&list1,1);
	SListPushBack(&list1,3);
	SListPushBack(&list1,7);
	SListPushBack(&list1,8);
	SListPushBack(&list1,9);
	SListPushBack(&list2,2);
	SListPushBack(&list2,3);
	SListPushBack(&list2,6);
	list=SListMerge(list1,list2);
	SListPrint(list);
}

void testSListFindMidNode(){
	SListNode *list=Init();
	SListPushBack(&list,1);
	SListPushBack(&list,2);
	SListPushBack(&list,3);
	SListPushBack(&list,4);
	SListPushBack(&list,5);
	SListPushBack(&list,6);
	SListPushBack(&list,7);
	SListPrint(list);
	printf("%d 
",SListFindMidNode(list)->_data);
}

void testSListFindTailKNode(){
	SListNode *list=Init();
	SListPushBack(&list,1);
	SListPushBack(&list,2);
	SListPushBack(&list,3);
	SListPushBack(&list,4);
	SListPushBack(&list,5);
	SListPushBack(&list,6);
	SListPushBack(&list,7);
	SListPrint(list);
	printf("%d 
",SListFindTailKNode(list, 2)->_data);
}

main.c

#include"SListNode.h"

int main(){
//	testAddDel();
//	testJosephCircle();
//	testSListReverse();
//	testSListBubbleSort();
//	testSListMerge();
//	testSListFindMidNode();
	testSListFindTailKNode();

	system("pause");
	return 0;
}