链表代码题汇总

链表代码题汇总

单链表默认结构体

typedef struct LNode{
	int data;
	struct LNode *next;
}LNode, *LinkList;

1.设计一个递归算法，删除不带头节点的单链表L中所有值为x的结点

• 递归四部曲

1. 递归函数定义
2. 基础情况处理
3. 递归调用
4. 递归到当前层

void delX(LNode *&L, int x){
	if(L == null){
		return;
	}
	LNode *p;
	if(L->data == x){
		p = L;
		L = L->next;
		free(p);
		delX(L, x);
	}else{
		delX(L->next, x);
	}
}

2.删除带头结点单链表中所有值为x的结点

//法一：设置前驱指针
void delX(LNode *&L, int x){
	LNode *p=L->next,*pre=L,*q;
	while(p != null){
		if(p->data == x){
			q = p;
			pre->next = p->next;
			p = p->next
			free(q);
		}else{
			pre = p;
			p = p->next;
		}
	}
}

//法二：不设置前驱指针//
void delX(LNode *&L, int x){
	LNode *p = L, *q;
	while(p->next != null){
		if(p->next->data == x){
			q = p->next;
			p->next = q->next;
			free(q);
		}else{
			p = p->next;
		}
	}
}

3.删除带头节点单链表中第一个值为x的结点
思路：先找要删除结点的前一个结点，后删除要删除的结点

int delX(LNode *&L, int x){
	LNode *p=L, *q;
	while(p->next != null){
		if(p->next->data == x){
			break;
		}
		p = p->next;
	}
	if(p->next == null){
		return 0;
	}else{
		q = p->next;
		p->next = q->next;
		free(q);
		return 1;
	}
}

4.从尾到头反向输出单链表每个结点的值

• 递归四部曲

1. 递归函数定义
2. 基础情况处理
3. 递归调用
4. 递归到当前层

void print(LNode *L){
	if(L->next != null){
		print(L->next);
	}
	cout << L->data <<"";
}

5.编写算法将单链表原地逆置

void reserve(LNode *&L){
	LNode *p=L->next, *q;
	L->next = null;//
	while(p != null){
		q = p->next;
		p->next = L->next;
		L->next = p;
		p = q;
	}
}

6.从链表中删除给定值在s到t之间（不包含s和t）的所有元素

void delST(LNode *&L, int s, int t){
	LNode *p = L, *q;
	while(p->next != null){
		if(p->next->data > s && p->next->data < t){
			q = p->next;
			p->next = q->next;
			free(q);
		}else{
			p = p->next;
		}
	}
}

7.试编写在带头结点的单链表L中删除最小值点的高效算法（已知最小值唯一）
思路：先找最小元素的前一个结点，后删除最小元素

int delM(LNode *&L){
	LNode *p=L,*minp=L,*q;
	while(p->next != null){
		if(p->next->data < minp->next->data){
			minp = p;
		}
		p = p->next;
	}
	if(minp->next == null){
		return 0;
	}else{
		q = minp->next;
		minp->next = q->next;
		free(q)
		return 1;
	}
}

8.试编写在不带头结点的单链表L中删除最小值点的高效算法（已知最小值唯一）

void delM(LNode *L){
	LNode *p=L, *minp=L;
	while(p->next != null){
		if(p->data < minp->data){
			minp = p;
		}
		p = p->next;
	}
	if(minp == L){
		L = L->next;
		free(minp);
	}else{
		p = L;
		while(p->next != minp){
			p = p->next;
		}
		p->next = minp->next;
		free(minp);
	}
}

9.给定一个单链表，按递增排序输出单链表中各结点的数据元素，并释放节点所占空间

void print(LNode *&L){
	while(L->next != null){
		LNode *p=L,*minp=L,*q;
		while(p->next != null){
			if(p->next->data < minp->next->data){
				p = minp;
			}
			p = p->next;
		}
		cout << minp->next->data<<"";
		q = minp->next;
		minp->next = q->next;
		free(minp);
	}
}

10.将一个带头节点的单链表A分解成两个带头节点的单链表A和B，使A中含奇数位置元素，B中含偶数位置元素，且相对位置不变

LNode* div(LNode *&A){
	LNode *B = new LNode;
	B->next = null;
	LNode *p = A->next;
	LNode *ra = A, *rb = B;
	A->next = null;
	while(p != null){
		ra->next = p;
		ra = p;
		p = p->next;
		rb->next = p;
		rb = p;
		if(p != null){
			p = p->next;
		}
	}
	ra->next = null;
	return B;
}

12.删除递增链表中重复的元素

void del(LNode *&L){
	LNode *p = L->next, *q;
	if(p == null){
		return
	}
	while(p->next != null){
		q = p->next;
		if(p->data == q->data){
			p->next = q->next;
			free(q);
		}else{
			p = p->next;
		}
	}
}

15.A,B两个单链表递增有序，从A，B中找出公共元素产生单链表C，要求不破坏A，B结点

LNode *common(LNode *A, LNode *B){
	LNode *p = A->next;
	LNode *q = B->next;
	LNode *C = new LNode;
	LNode *r = C;
	while(p!=null && q!=null){
		if(p->data < q->data){
			p = p->next;
		}else if(q->data > p->data){
			q = q->data;
		}else{
			LNode *s = new LNode;
			s->data = p->data;
			r->next = s;
			r = s;//r始终保持再链表末尾位置
			p = p->next;
			q = q->next;
		}
	}
	r->next = null;
	return C;
}

21.有两个循环单链表，链表头指针分别为h1，h2，试编写函数将h2链表接到h1之后，要求链接后仍保持循环链表形式

void link(LNode *&h1, LNode *&h2){
	LNode *p = h1, *q = h2;
	while(p->next != h1){
		p = p->next;
	}
	while(q->next != h2){
		q = q->next;
	}
	p->next = h2;
	q->next = h1;
}