链表常见的面试题

最新推荐文章于 2024-05-02 17:23:00 发布
最新推荐文章于 2024-05-02 17:23:00 发布
阅读量144 收藏
点赞数
分类专栏： 作业
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ximmown/article/details/79899792
版权
逆序打印单链表. 
void LinkListReversePrint(LinkNode* head); 



不允许遍历链表, 在 pos之前插入 
void LinkListInsertBefore(LinkNode** head, LinkNode* pos, LinkType value); 


LinkNode* JosephCycle(LinkNode* head, size_t food); 


单链表逆置 
void LinkListReverse(LinkNode** head); 
void LinkListReverse2(LinkNode** head); 


单链表的冒泡排序 
void LinkListBubbleSort(LinkNode* head); 


 将两个有序链表, 合并成一个有序链表 
LinkNode* LinkListMerge(LinkNode* head1, LinkNode* head2); 


LinkNode* FindMidNode(LinkNode* head); 

找到倒数第 K 个节点. 
LinkNode* FindLastKNode(LinkNode* head, size_t K); 

删除倒数第K个节点 
void EraseLastKNode(LinkNode** head, size_t K); 


判定单链表是否带环. 如果带环返回1 
LinkNode* HasCycle(LinkNode* head); 


如果链表带环, 求出环的长度 

size_t GetCycleLen(LinkNode* head); 

如果链表带环, 求出环的入口 
LinkNode* GetCycleEntry(LinkNode* head); 


判定两个链表是否相交, 并求出交点 

LinkNode* HasCross(LinkNode* head1, LinkNode* head2);

以下是头文件，承接上一个博客的功能

#pragma once
typedef char LinkNodeType;
typedef struct LinkNode{
	LinkNodeType data;
	struct LinkNode *next;
}LinkNode;

typedef struct LinkList{
	LinkNode *head;
	LinkNode *tail;
}LinkList;

typedef LinkNode *PLinkNode;

void PrintChar(LinkNode *head,const char *msg);

LinkNode* CreateNode(LinkNodeType value);

void LinkListInit(LinkNode** head);

void LinkListPushBack(LinkNode** head,LinkNodeType value);

void LinkListPopBack(LinkNode **head);

void DestoryNode(LinkNode *node);

void LinkListPushFront(LinkNode **head,LinkNodeType value);

void LinkListPopFront(LinkNode **head);

LinkNode* LinkListFind(LinkNode *head,LinkNodeType to_find);

void LinkListInsertBefore(LinkNode** head,LinkNode *pos,LinkNodeType value);

void LinkListErase(LinkNode **head,LinkNode *pos);

void LinkListErase2(LinkNode **head,LinkNode *pos);

void LinkListRemove(LinkNode **head,LinkNodeType to_delete);

void LinkListRemoveAll(LinkNode **head,LinkNodeType value);

int LinkListEmpty(LinkNode *head);

size_t LinkListSize(LinkNode *head);

void LinkListReversePrint(LinkNode *head);

void LinkListInsertBefore2(LinkNode **head,LinkNode *pos,LinkNodeType value);

LinkNode* JosephCycle(LinkNode *head,size_t food);

void LinkListReverse(LinkNode **head);

void LinkListReverse2(LinkNode **head);

void LinkListBubbleSort(LinkNode* head);

LinkNode* LinkListMerge(LinkNode *head1,LinkNode *head2); 

LinkNode* FindMidNode(LinkNode *head);

LinkNode*  FindLastKNode(LinkNode *head,size_t k);

void EraseLastKNode(LinkNode **head,size_t k);

int HasCycle(LinkNode* head);

size_t GetCycleLen(LinkNode *head);

LinkNode* MeetNode(LinkNode *head);

LinkNode* GetCycleEntry(LinkNode *head);

size_t HasCross(LinkNode *head1,LinkNode *head2);

再往下是功能实现：

#include<stdio.h>
#include"LinkList.h"
#include<stdlib.h>
#define TestHeader printf("\n=========%s========\n",__FUNCTION__)
void LinkListInit(LinkNode** head){
	*head = NULL;
}

void PrintChar(LinkNode *head,const char *msg){
	printf("[%s]\n",msg);
	LinkNode *cur = head;//TODO
	for(;cur !=NULL;cur=cur->next)
	{
		printf("[%c]|%p  ",cur->data,cur);
	}		
	printf("\n");
}

LinkNode* CreateNode(LinkNodeType value)
{
	LinkNode *new_node=(LinkNode*)malloc(sizeof(LinkNode));
	new_node->data=value;
	new_node->next=NULL;
}

void DestoryNode(LinkNode *node){
	free(node);
}

void LinkListPushBack(LinkNode **head,LinkNodeType value){
	if(head==NULL){
		return;
	}
	if(*head == NULL){
		*head=CreateNode(value);
		return;
	}
	LinkNode *cur=*head;
	while(cur->next != NULL){
		cur = cur->next;
	}
	LinkNode *new_node = CreateNode(value);
	cur->next=new_node;
}

void LinkListPopBack(LinkNode **head){
	if(head==NULL){
		return;
	}
	if(*head==NULL){
		return;
	}
	if((*head)->next == NULL){
		DestoryNode(*head);
		return;
	}
	LinkNode *cur=*head;
	LinkNode *pre=NULL;
	while(cur->next != NULL){
		pre=cur;
		cur=cur->next;
	}
	pre->next=NULL;
	DestoryNode(cur);
	return;
}

void LinkListPushFront(LinkNode **head,LinkNodeType value){
	if(head==NULL){
		return;
	}
	if(*head==NULL){//emptylist
		LinkListPushBack(head,value);
	}
	LinkNode *new_node=CreateNode(value);
	new_node->next=*head;
	*head=new_node;
	}

void LinkListPopFront(LinkNode **head){
	if(head==NULL){
		return;
	}
	if(*head==NULL){
		return;
	}
	LinkNode *to_delete=*head;
	*head=(*head)->next;
	DestoryNode(to_delete);
	}

LinkNode* LinkListFind(LinkNode *head,LinkNodeType to_find){
	if(head==NULL){
		return NULL;
	}
	LinkNode *cur=head;
	while(cur->next != NULL){
		if(cur->data == to_find){
			break;
			return NULL;
		}
		cur=cur->next;
	}
	return cur;
}

void LinkListInsertAfter(LinkNode **head,LinkNode *pos,LinkNodeType value){
	if(*head==NULL){
		return;
	}	
	if(pos==NULL){
		return;//inlegal input
	}
	LinkNode *new_node=CreateNode(value);
	new_node->next=pos->next;
	pos->next=new_node;
}

void LinkListInsertBefore(LinkNode **head,LinkNode *pos,LinkNodeType value){
	if(*head == NULL){
		return;
	}
	if(pos == NULL){
		return;
	}
	if(*head == pos){
		LinkListPushFront(head,value);
		return;
	}
	LinkNode *cur=*head;
	for(;cur->next != NULL;cur = cur->next){
		if(cur == pos){
			break;
		}
		if(cur == NULL){
			return;
		}//pos not in list
	}
	LinkListInsertAfter(head,cur,value);
	return;
}

void LinkListErase(LinkNode **head,LinkNode *pos){
	if(*head == NULL || pos==NULL){
		return;
	}
	if(head == NULL){
		return;
	}
	LinkNode *cur = *head;
	LinkNode *pre =NULL;
	LinkNode *to_erase = NULL;
	for(;cur!= NULL;pre = cur,cur= cur->next){
		if(cur == pos){
			break;
		}
		if(cur == NULL){
			return;
		}
	}
	to_erase=cur;
	pre->next=to_erase->next;;
	DestoryNode(to_erase);
	return;
}

void LinkListErase2(LinkNode **head,LinkNode *pos){
	if(pos==NULL || head==NULL){
		return;
	}
	if(*head== NULL){
		return;
	}
	if(pos->next == NULL){
		LinkListErase(head,pos);
		return;
	}
	pos->data=pos->next->data;
	LinkNode *to_erase = pos->next;
	pos->next=to_erase->next;
	DestoryNode(to_erase);
	return;
}

void LinkListRemove(LinkNode **head,LinkNodeType to_delete){
	if(head==NULL){
		return;
	}
	if(*head == NULL){
		return;
	}
	if((*head)->data == to_delete){
		LinkNode *to_delete = *head;
		(*head)=(*head)->next;
		DestoryNode(to_delete);
		return;
	}
	LinkNode *cur = *head;
	for(;cur->next!=NULL;cur=cur->next){
		if(cur->data == to_delete){
			LinkNode *to_delete=cur;
			cur->next=to_delete->next;
			DestoryNode(to_delete);
			return;
		}
	}
	return;
}

void LinkListRemoveAll(LinkNode **head,LinkNodeType value){
	if(head == NULL){
		return;
	}
	if(*head == NULL){
		return;
	}
	LinkNode *cur = *head;
	for(;cur->next!=NULL;cur=cur->next){
		if(cur->data == value){
			LinkListRemove(head,value);
		}
	}
	return;
}

int LinkListEmpty(LinkNode *head){
	return head==NULL?1:0;	
}

size_t LinkListSize(LinkNode *head){
	if(head == NULL){
		return 0;
	}
	size_t count=1;
	LinkNode *cur=head;
	for(;cur->next != NULL;cur= cur->next){
		count++;
	}
	return count;
}

void LinkListReversePrint(LinkNode *head){
	if(head == NULL){
		return;
	}
	LinkListReversePrint(head->next);
	printf("[%c]%p",head->data,head);
}

void LinkListInsertBefore2(LinkNode **head,LinkNode *pos,LinkNodeType value){
	if(*head == NULL || pos == NULL){
		return;
	}
	LinkNode *new_node=CreateNode(pos->data);
	LinkNode *after_new_node=pos->next;
	pos->next=new_node;
	new_node->next=after_new_node;
	pos->data=value;
	return;
}

LinkNode* JosephCycle(LinkNode *head,size_t food){
	if(head == NULL){
		return;
	}
	if(head->next == head ){
		return;
	}
	LinkNode *cur =head;
	while(cur->next != cur){
		int i=1;
		for(;i<food;++i){
			cur=cur->next;	
		}
		printf("%c\n",cur->data);
		cur->data=cur->next->data;
		LinkNode *to_delete=cur->next;
		cur->next=to_delete->next;
		DestoryNode(to_delete);
	}
	return cur;
}

void LinkListReverse(LinkNode **head){
	if(*head == NULL){
		return;
	}
	if(head == NULL){
		return;
	}
	if((*head)->next == NULL){
		return;
	}
	LinkNode *pre=*head;
	LinkNode *cur=pre->next;
	pre->next=NULL;
	while(cur !=  NULL){
		LinkNode *next =cur->next;
		cur->next=pre;
		pre=cur;
		cur=next;
	}
	*head=pre;
	return;
}

void LinkListReverse2(LinkNode **head){
	if(*head == NULL){
		return;
	}
	if(head == NULL){
		return;
	}
	if((*head)->next == NULL){
		return;
	}
	LinkNode *cur=*head;
	while(cur->next!=NULL){
		LinkNode *to_move=cur->next;
		cur->next=to_move->next;
		to_move->next=*head;
		*head=to_move;
	}
	return;
}

void LinkListBubbleSort(LinkNode *head){
	if (head == NULL){
		return;
	}
	if(head->next == NULL){
		return;
	}
	LinkNode *count=head;
	LinkNode *tail=NULL;
	for(;count!=NULL;count=count->next){
		LinkNode *cur=head;
		for(;cur->next !=tail;cur=cur->next){
			if((cur->data) > (cur->next->data)){
			int tmp=cur->next->data;
				cur->next->data=cur->data;
				cur->data=tmp;
			}
		}
	tail=cur;
	}
	return;
}

LinkNode* LinkListMerge(LinkNode *head1,LinkNode *head2){
	if(head1 == NULL){return head2;}
	if(head2 == NULL){return head1;}
	LinkNode *cur1=head1;
	LinkNode *cur2=head2;
	LinkNode *new_head=NULL;
	LinkNode *new_tail=NULL;
	while(cur1!=NULL && cur2!=NULL){
		if(cur1->data < cur2->data){
			if(new_tail==NULL){
				new_head=cur1;
				new_tail=cur1;
				cur1=cur1->next;
			}
			else{
				new_tail->next=cur1;
				new_tail=new_tail->next;
				cur1=cur1->next;
			}
		}
		else{
			if(new_tail==NULL){
				new_head=cur2;
				new_tail=cur2;
				cur2=cur2->next;
			}
			else{
				new_tail->next=cur2;
				new_tail=new_tail->next;
				cur2=cur2->next;
			}
		}
	}
	if(cur1 !=NULL){
		new_tail->next=cur1;
	}
	else{
		new_tail->next=cur2;
	}
	return new_head;
}

LinkNode* FindMidNode(LinkNode *head){
	if(head == NULL){
		return;
	}
	LinkNode *slow=head;
	LinkNode *fast=head;
	while(fast != NULL && fast->next !=NULL){
		slow=slow->next;
		fast=fast->next->next;
	}
	return slow;
}

LinkNode* FindLastKNode(LinkNode *head,size_t k){
	if(head == NULL){
		return;
	}
	LinkNode *fast=head;
	LinkNode *slow=head;
	int i=0;
	for(;i<k;++i){
		if(fast==NULL){
			break;
		}
		fast=fast->next;
	}
	if(i!=k){
		return NULL;
	}
	while(fast!=NULL){
		fast=fast->next;
		slow=slow->next;
	}
	return slow;
}

void EraseLastKNode(LinkNode **head,size_t k){
	if(*head == NULL){
		return;
	}
	if(head==NULL){
		return;
	}
	size_t len=LinkListSize(*head);
	if(k==len){
		LinkListPopFront(head);
		return;
	}
	LinkNode *pre=*head;
	int i=0;
	for(;i<len-1-k;++i){
		pre=pre->next;
	}
	LinkNode *to_delete=pre->next;
	pre->next=to_delete->next;
	DestoryNode(to_delete);
	return;
}

int HasCycle(LinkNode* head){
	if(head == NULL){
		return;
	}
	LinkNode *slow=head;
	LinkNode *fast=head;
	while(fast!= NULL && fast->next != NULL){
		fast=fast->next->next;
		slow=slow->next;
	if(slow == fast ){
		return 1;
		}
	}
	return 0;
}

LinkNode *MeetNode(LinkNode* head){
	if(head == NULL){
		return;
	}
	LinkNode *slow=head;
	LinkNode *fast=head;
	while(fast!= NULL && fast->next != NULL){
		fast=fast->next->next;
		slow=slow->next;
	if(slow == fast ){
		return slow;
		}
	}
	return NULL;
}

size_t GetCycleLen(LinkNode *head){
	if(head == NULL){
		return 0;
	}
	LinkNode *meet_node=MeetNode(head);
	if(meet_node == NULL){
		return 0;
	}
	size_t count=0;
	LinkNode *cur=meet_node->next;
	while(cur!=meet_node){
		cur=cur->next;
		count++;
	}
	return count;
}

void TestGetCycleLen(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'2');
	LinkListPushBack(&head,'3');
	LinkListPushBack(&head,'4');
	LinkListPushBack(&head,'5');
	LinkNode *pos_end=LinkListFind(head,'5');
	pos_end->next=head->next->next;
	int ret=GetCycleLen(head);
	printf("the len is %d\n",ret);
}

LinkNode* GetCycleEntry(LinkNode *head){
	if(head==NULL){
		return NULL;
	}
	int judge;
	judge=HasCycle(head);
	if(judge != 1){
		return NULL;
	}
	LinkNode *meet_node=MeetNode(head);
	LinkNode *fast=meet_node;
	LinkNode *slow=head;
	while(slow != fast){
		slow=slow->next;
		fast=fast->next;
	}
	return slow;
}

void TestGetCycleEntry(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'2');
	LinkListPushBack(&head,'3');
	LinkListPushBack(&head,'4');
	LinkListPushBack(&head,'5');
	LinkNode *pos_end=LinkListFind(head,'5');
	pos_end->next=head->next->next;
	LinkNode *entry=GetCycleEntry(head);
	printf("[%c]|%p",entry->data,entry);
}

LinkNode* HasCross(LinkNode *head1,LinkNode *head2){
	if(head1 == NULL || head2 ==NULL){
		return 0;
	}
	LinkNode *cur1=head1;
	LinkNode *cur2=head2;
	while(1){
		if(cur1->data == cur2->data){
			break;
		}
		cur1=cur1->next;
		cur2=cur2->next;
		if(cur1== NULL || cur2== NULL ){
			return NULL;
		}
	}
	return cur1;
}

void TestHasCross(){
	
	TestHeader;
	LinkNode *head1;
	LinkListInit(&head1);
	LinkListPushBack(&head1,'1');
	LinkListPushBack(&head1,'2');
	LinkListPushBack(&head1,'3');
	LinkListPushBack(&head1,'7');
	LinkListPushBack(&head1,'8');
	
	LinkNode *head2;
	LinkListInit(&head2);
	LinkListPushBack(&head2,'4');
	LinkListPushBack(&head2,'5');
	LinkListPushBack(&head2,'6');
	LinkListPushBack(&head2,'7');
	LinkListPushBack(&head2,'8');

	LinkNode *cross=HasCross(head1,head2);
	printf("[%c]|%p\n",cross->data,cross);
}

void TestHasCycle(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'2');
	LinkListPushBack(&head,'3');
	LinkListPushBack(&head,'4');
	LinkListPushBack(&head,'5');
	LinkNode *pos_end=LinkListFind(head,'5');
	pos_end->next=head;
	int i=HasCycle(head);
	printf("%d\n",i);
}

void TestEraseLastKNode(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'2');
	LinkListPushBack(&head,'3');
	LinkListPushBack(&head,'4');
	LinkListPushBack(&head,'5');
	EraseLastKNode(&head,2);
	PrintChar(head,"\n");
}

void TestLastKNode(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'2');
	LinkListPushBack(&head,'3');
	LinkListPushBack(&head,'4');
	LinkListPushBack(&head,'5');
	LinkNode *LastKNode=FindLastKNode(head,1);
	printf("[%c]|%p\n",LastKNode->data,LastKNode);
}

void TestMidNode(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'3');
	LinkListPushBack(&head,'5');
	LinkListPushBack(&head,'7');
	LinkNode *mid_node=FindMidNode(head);
	printf("[%c]|%p",mid_node->data,mid_node);
}

void TestMerge(){
	TestHeader;
	LinkNode *head1;
	LinkListInit(&head1);
	LinkListPushBack(&head1,'1');
	LinkListPushBack(&head1,'3');
	LinkListPushBack(&head1,'5');
	LinkListPushBack(&head1,'7');
	
	LinkNode *head2;
	LinkListInit(&head2);
	LinkListPushBack(&head2,'2');
	LinkListPushBack(&head2,'4');
	LinkListPushBack(&head2,'6');
	LinkListPushBack(&head2,'8');
	
	LinkNode *new_list=LinkListMerge(head1,head2);
	PrintChar(new_list,"\n");
}

void TestBubbleSort(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'1');
	LinkListPushBack(&head,'2');
	LinkListPushBack(&head,'4');
	LinkListPushBack(&head,'3');
	LinkListBubbleSort(head);
	PrintChar(head,"\n");	
}

void TestReverse2(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListReverse2(&head);
	PrintChar(head,"\n");
}

void TestReverse(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListReverse(&head);
	PrintChar(head,"\n");
}

void TestJosephCycle(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);	
	LinkNode *a=CreateNode('a');
	LinkNode *b=CreateNode('b');
	LinkNode *c=CreateNode('c');
	LinkNode *d=CreateNode('d');
	head=a;
	a->next=b;
	b->next=c;
	c->next=d;
	d->next=a;
	LinkNode *ret=JosephCycle(head,2);
	printf("%p",ret);
}

void TestInsertBefore2(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode *pos=head->next->next->next;
	LinkListInsertBefore2(&head,pos,'x');
	PrintChar(head,"\n");
}

void TestReversePrint(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListReversePrint(head);
	printf("\n");
}

void TestSize(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'d');
	int len=LinkListSize(head);
	printf("the size is %d\n",len);
}

void TestEmpty(){	
	TestHeader;
	LinkNode *head;
	int ret=LinkListEmpty(head);
	printf("result is :%d\n",ret);
}

void TestRemoveAll(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'d');
	LinkListRemoveAll(&head,'a');
	PrintChar(head,"\n");
}

void TestRemove(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListRemove(&head,'b');
	PrintChar(head,"\n");
}

void TestErase2(){
	
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode *pos = head->next->next;
	LinkListErase2(&head,pos);
	PrintChar(head,"\n");
}

void TestErase(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode *pos = head->next->next;
	LinkListErase(&head,pos);
	PrintChar(head,"\n");
}

void TestInsertBefore(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode *pos=head->next;
	LinkListInsertBefore(&head,pos,'H');
	PrintChar(head,"\n");
}

void TestInsertAfter(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode *pos=head->next;
	LinkListInsertAfter(&head,pos,'o');
	PrintChar(head,"\n");
}

void TestFind(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);	
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkNode *dest=LinkListFind(head,'c');
	PrintChar(head,"\n");
	printf("the address of c is[%p]\n",dest);
	
	
}

void TestPopFront(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPopFront(&head);
	LinkListPopFront(&head);
	PrintChar(head,"\n");
}

void TestPushFront(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPushFront(&head,'x');
	LinkListPushFront(&head,'y');
	PrintChar(head,"\n");
}

void TestPopBack(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	LinkListPopBack(&head);
	LinkListPopBack(&head);
	PrintChar(head,"\n");
}

void TestPushBack(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
	LinkListPushBack(&head,'a');
	LinkListPushBack(&head,'b');
	LinkListPushBack(&head,'c');
	LinkListPushBack(&head,'d');
	PrintChar(head,"\n");
}

void TestInit(){
	TestHeader;
	LinkNode *head;
	LinkListInit(&head);
}

void main(){
	TestInit();
	TestPushBack();
	TestPopBack();
	TestPushFront();
	TestPopFront();
	TestFind();
	TestInsertAfter();
	TestErase();
	TestErase2();
	TestRemove();
	TestRemoveAll();
	TestEmpty();
	TestSize();
	TestReversePrint();
	TestInsertBefore2();
	TestJosephCycle();
	TestReverse();
	TestReverse2();
	TestBubbleSort();
	TestMerge();
	TestMidNode();
	TestLastKNode();
	TestEraseLastKNode();
	TestHasCycle();
	TestGetCycleLen();
	TestGetCycleEntry();
	TestHasCross();
}

ximmown
关注
专栏目录
数据结构_链表2（单向无头结点链表常见问题）
Cherubim1的博客
04-18 661
总结一些常见的链表问题。以下例子都是单向无头结点链表，部分带环。1.从尾到头打印链表元素    即逆序打印链表，可以创建一个新的链表，每次找出原来链表的最后一个元素头插到新链表里，再打印出新链表，但是这种办法太麻烦而且效率低。还可以采用递归的思路，在打印当前元素之前递归调用打印函数，递归出口为指针为NULL，每调用一次，传进来的参数就往链表下一个元素移动。下图为3个元素时例子：71 void Li...
链表reverse
qq_38035641的博客
05-21 423
很普通的单向链表转置，主要方法是利用NODE *pCur指向待改变方向的节点，利用NODE *pRev指向待改变方向节点的上一个节点（如果是第一个节点，即头节点，因为转置后该节点变为尾节点，则此时为NULL）,在循环中创建一个中间变量NODE* pTmp，利用中间变量 tmp 存储 cur指针变量存储的节点地址，然后改变cur指向下一个节点，再将tmp指针指向的节点的pNext = pRev，此时...
【剑指offer】链表相关-删除value值节点
水滴石穿
03-03 1248
#include #include #include struct ListNode { int m_nValue; ListNode * m_pNext; }; ListNode * CreateLink(int a[],int k) { ListNode * Head=NULL,*q=NULL; for(int i=0;i<k;i++) { ListNode * pNew=
链表常见面试题分析
GG_Bruse的博客
11-04 7168
接下来我们会从易到难，逐步讲解有关链表的常见面试，部分题目来自Leetcode和牛客
链表常见面试题
艾小方的博客
10-25 1060
链表面试题 文章目录链表面试题前言一、 删除链表中等于给定值 val 的所有节点。二、反转一个单链表。三、给定一个带有头结点 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。四、输入一个链表，输出该链表中倒数第k个结点。五、 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。六、 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 。七、 链表的回文结构。八、 两个链表相交问题九、 链
链表常见面试题( 建议收藏！！)
一朵花花
08-31 3761
链表面试题????1.删除链表中等于给定值 val 的所有节点2.二级目录3.三级目录 1.删除链表中等于给定值 val 的所有节点 题目： 题目链接： https://leetcode-cn.com/problems/remove-linked-list-elements/. 思考： 用tmp记录当前节点，若tmp 的下一个节点不为空且下一个节点的节点值等于给定的 val，则需要删除tmp的下一个节点 2.二级目录 3.三级目录 ...
链表经典面试题
最新发布
GOATLong的博客
05-02 2561
1.删除链表中等于给定值的所有结点1.删除链表中等于给定值的所有结点2.反转一个单链表这里我们需要在原链表中进行操作我们定义三个指针如下图所示：接下来就是改变l2指针的next指向l1之后l1指针走到l2，l2走到l3，l3走到l2的next，不断循环一直到l2为空指针这里有一个小细节如下图。
数据结构|链表常见面试题
yurensan的博客
09-08 291
以下是链表中常见面试题 单链表实现约瑟夫环 反转单链表 K个节点为一组反转链表 返回链表中间（1/2）节点（扩展返回链表1/K节点） 单链表排序（冒泡排序&快速排序） 查找单链表的中间节点，要求只能遍历一次链表 查找单链表的倒数第K个节点，要求只能遍历一次链表 删除单链表的倒数第K个节点 判断单链表是否有环，如果有环，求环的入口节点 判断两个链表是否相交，若相交，求交点（假设链表不带环） 判断两个链表是否相交，若相交，求交点（假设链表可能带环） 求两个已排序单链表中相同的数据 合并两个有序链表，合
【初阶数据结构】——链表常见面试题剖析
m0_70980326的博客
01-09 1387
几道链表相关的经典面试题解析
链表常见面试题( 建议收藏！！)，2024年最新中高级java面试题及答案大全
2401_84006689的博客
04-17 878
看完上述知识点如果你深感Java基础不够扎实，或者刷题刷的不够、知识不全面小编专门为你量身定制了一套针对知识面不够，也莫慌！还有一整套的，可以瞬间查漏补缺全都是一丢一丢的收集整理纯手打出来的。
链表面试题_链表_面试题_cow3cm_数据结构_
09-30
链表是一种基础且重要的数据结构，在计算机科学特别是数据结构...同时，熟悉常见的链表面试题，有助于提升解决实际问题的能力。通过深入学习和实践，我们可以掌握如何有效地利用链表这一数据结构来优化算法和程序设计。
《数据结构》十道链表经典面试题多种方法深度解析
m0_62171658的博客
03-20 6769
《数据结构》十道链表经典面试题多种方法深度解析，配有图解深度挖掘各种细节问题，打好根基，为冲击金丹期做准备。
链表之十大经典面试题
weixin_64702703的博客
04-06 1598
快速学习链表面试题
一文搞定链表常见面试题
weixin_41318622的博客
05-27 372
链表问题是常见的面试题，字节跳动，阿里云等大型互联网公司都会通过该类型题来判断面试者的算法基础能力，在校招的过程中，我遇到了不少关于链表的问题，因此在此进行总结。
单向链表常见面试题~真题为例
qq_45058113的博客
03-27 1160
求单链表中节点的个数 查找单链表中的倒数第k个节点（新浪面试） 单链表的反转（腾讯面试） 从尾到头打印单链表（百度 要求：反向遍历，Stack栈） 合并两个有序的单链表，合并之后的链表依然有序 ...
JAVA接口练习题
热门推荐
ximmown的博客
04-07 1万+
1.说出下面程序的执行结果: interface InterfaceA {  （public abstract）String S = "good ";  void f(); } abstract class ClassA {  abstract void g(); } class ClassB extends ClassA implements InterfaceA { //B是A的子类和接口A的...
JAVA-异常处理及toString的覆写
ximmown的博客
04-14 1288
1、要求: 1).Person类有name,age,salary属性，要求实现至少两个构造方法，并且属性私有，提供对应的getter、setter。 2).覆写toString方法，要求在System.out.println()函数中传递Person对象能打印出三个属性值而不是对象地址。 3).覆写equals方法，要求两个Person类对象的值相同时返回true。 import javax.xm...
JAVA-多线程同步的两大方式+对象锁和全局锁+wait()&notify()
ximmown的博客
05-12 940
1、synchronize：同步代码块，同步方法    同步代码块：必须设置锁定的对象，一般使用this    如synchronized（this）{...} //表示为该程序的逻辑上锁。    同步方法：public synchronized void sale（）{...}    由于必须同步进行，所以执行速度回很慢    P.S：synchronized （this）和非static 的s...
JAVA-在JAVA中实现双向链表的增删查改
ximmown的博客
04-16 922
在这个链表中，函数具有的功能有:尾插一个新的链表环节，删除指定下标的环节，根据内容查改内容是否存在于链表当中，根据内容返回下标，指定下标的改值，获取指定下标的值，获取链表长度和清空链表。该代码中重点在于区分java和C中对于链表的定义和节点插入的定义，其余基本差不多，概念也相差无几package linkList; interface Link{ void add(Object obj);...
C++链表反转面试题与答案详解
首先，针对链表反转问题，它是一个经典的面试题目，涉及基础的数据结构操作。在单向链表中，要实现反转，可以采用迭代或递归的方法。迭代方法通过设置两个指针，一个pre指向前一个节点，一个cur指向当前节点，同时...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值