练习题及解题思路
#include <stdio.h>
#include "string.h"
#include "ctype.h"
#include "stdlib.h"
#include "math.h"
#include "time.h"
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 20 //存储空间初始分配量
typedef int Status;//Status 是函数的类型，其值是函数结果状态代码l，如OK等
typedef int ElemType;//ElemType 类型根据实际情况而定，这里假设为int
//定义结点
typedef struct Node{
ElemType data;
struct Node *prior;
struct Node *next;
}Node;
//类型重定义
typedef struct Node * LinkList;//初始化链表
Status InitList(LinkList *L){
*L = (LinkList)malloc(sizeof(Node));
if (*L == NULL) return ERROR;
(*L)->next = NULL;
return OK;
}
//链表插入
Status ListInsert(LinkList *L, int i, ElemType e){
if (i<1) return ERROR;
LinkList p,temp;
p = *L;
for (int j=1; j<i; j++) {
p = p->next;
}
if (p == NULL) return ERROR;
temp = malloc(sizeof(Node));
temp->data = e;
temp->next = p->next;
p->next = temp;
return OK;
}
//遍历
Status ListTraverse(LinkList L)
{
LinkList p = L->next;
while(p)
{
printf("%d ",p->data);
p = p->next;
}
printf("\n");
return OK;
}题目验证：
int main(int argc, const char * argv[]) {
Status iStatus;
LinkList La,Lb,Lc,L;
InitList(&La);
InitList(&Lb); 题目1：
1、将2个递增的有序链表合并为一个有序链表；要求结果链表任然使用两个链表的存储空间，不另外占用其他的存储空间。表中不允许有重复的数据
分析：
关键词：递增有序链表，不允许有重复数据，保留递增关系（后插法），不占用额外的存储空间意思不能开辟新结点
思路：
（1）、假设合并的链表为La 和 Lb，合并后的新表使用头指针Lc（Lc的表头结点设为La的表头结点）指向。pa 和 pb分别是La 和 Lb的工作指针，初始化为相应链表的首原结点
（2）、从首元结点开始，当连个链表La 和 Lb均未到达表尾结点时，依次摘取其中值较小的结点（哪个链表中的小取哪个保证递增顺序），并将其插入Lc 后面。
（3）、如果两个表中的值相等的时候，只摘取La 表中的元素，删除Lb 中的元素（防止出现野指针，同时防止出现相同的数据）。
（4）、当一个表达到表尾结点为空时，非空表的剩余元素直接连接在 Lc 表最后（也就是其中一个表遍历并取完值了之后，另一个还没完，就直接把非空的链表剩下的元素全部连接到Lc后面）。
（5）、最后释放链表lb 的头结点（将Lb释放，防止出现野指针，此时的Lb已经不完整同时留着也无意义）。
void MergeList(LinkList *La, LinkList *Lb, LinkList *Lc){
// 1、
LinkList pa = (*La)->next;
LinkList pb = (*Lb)->next;
LinkList pc = *Lc = *La;
LinkList temp;
while (pa && pb ) {
// 取较小者（相同的取La的，释放Lb的）链接到pc 后面，对应指针后移，pc也后移
if (pa->data > pb->data) {
pc->next = pb;
pc = pc->next;
pb = pb->next;
}else if(pa->data == pb->data){
pc->next = pa;
pc = pc->next;
pa = pa->next;
temp = pb;
pb = pb->next;
free(temp);
}else{
pc->next = pa;
pc = pc->next;
pa = pa->next;
}
}
// 4、将非空的链表剩余元素全部连接到Lc表的最后
pc->next = pa?pa:pb;
free(*Lb);
}验证：
printf("******题目1:********\n");
//设计2个递增链表La,Lb
for(int j = 10;j>=0;j-=2)
{
iStatus = ListInsert(&La, 1, j);
}
printf("La:\n");
ListTraverse(La);
for(int j = 11;j>0;j-=2)
{
iStatus = ListInsert(&Lb, 1, j);
}
printf("Lb:\n");
ListTraverse(Lb);
MergeList(&La, &Lb, &Lc);
printf("Lc:\n");
ListTraverse(Lc);
//**************************************************
La:
0 2 4 6 8 10
Lb:
1 3 5 7 9 11
Lc:
0 1 2 3 4 5 6 7 8 9 10 11
题目2：
2、已知连个链表A和B分别标识两个集合。设计一个算法，用于求出A与B的交集，并存储在A链表中;
例如：
La = {2,4,6,8}; Lb = {4,6,8,10};
Lc = {4,6,8}
分析：
依次摘取2个表中相等的元素重新进行链接，删除其他不相等的元素。
思路：
（1）、假设待合并的链表为La 和 Lb，合并后的新表使用头指针Lc （Lc的表头结点设为La的表头结点）指向。pa 和 pb 分别是La，Lb 的工作指针。初始化为相应链表的首元结点
（2）、从首元结点开始比较，当两个链表La 表 和Lb 均为到达表尾结点时
（3）、如果两个表的数据相等，只摘取La 表中的元素，连接到Lc 表的后面，删除Lb 表中的元素。同时pa、pb、pc指针均向后移。
（4）、如果两个表的数据不相等，判断哪个表中的数据小删除那个表中的数据同时对应表的指针向后移
（5）、当链表La 和 Lb有一个先到达表尾结点为空时，依次删除非空表中的所有元素。
（6）、最后释放链表 Lb的头结点
void Intersection(LinkList *La, LinkList *Lb, LinkList *Lc){
// pc 指向Lc 的头结点，用La的头结点作为Lc的头结点
LinkList pa,pb,pc,temp;
pa = (*La)->next;
pb = (*Lb)->next;
pc = *Lc = *La;
while (pa && pb) {
// 相等，将La中的元素连接到Lc中，然后删除Lb中对应的元素，同时pa、pb、pc都向后移
if (pa->data == pb->data) {
pc->next = pa;
pc = pc->next;
pa = pa->next;
temp = pb;
pb = pb->next;
free(temp);
}else if (pa->data < pb->data){
temp = pa;
pa = pa->next;
free(temp);
}else{
//删除较小值Lb中的元素
temp = pb;
pb = pb->next;
free(temp);
}
}
// 依次删除非空链表中剩余的所有元素
while (pa) {
temp = pa;
pa = pa->next;
free(temp);
}
while (pb) {
temp = pb;
pb = pb->next;
free(temp);
}
// Lc的尾结点的 next指向NULL
pc->next = NULL;
free(*Lb);
}验证
printf("******题目2:********\n");
ListInsert(&La, 1, 8);
ListInsert(&La, 1, 6);
ListInsert(&La, 1, 4);
ListInsert(&La, 1, 2);
printf("La:\n");
ListTraverse(La);
ListInsert(&Lb, 1, 10);
ListInsert(&Lb, 1, 8);
ListInsert(&Lb, 1, 6);
ListInsert(&Lb, 1, 4);
printf("Lb:\n");
ListTraverse(Lb);
Intersection(&La, &Lb, &Lc);
printf("Lc:\n");
ListTraverse(Lc);
//****************************************
La:
2 4 6 8
Lb:
4 6 8 10
Lc:
4 6 8 题目3:
3、设计一个算法，将链表中d所有的连接方向“原地旋转”，即要求仅仅利用原表的存储空间。换句话说，要求算法空间复杂度为O(1);
例如：L = {0,2,4,6,8,10},L逆转后：L = {10,8,6,4,2};
分析：
（1）、不能开辟新的空间，只能改变指针的指向。
（2）、可以考虑逐个摘取结点，利用前插法创建链表的思想，将结点依次插到头结点的后面。
（3）、因为先插入的结点为表尾，最后插入的结点为表头，即可实现链表的逆转；
思路：
（1）、利用原有的头结点*L，p为工作指针，初始时p 指向首元结点。
（2）、因为摘取的结点依次向前插入，为确保链表尾部为空，初始时将头结点的指针域置空
（3）、从前向后遍历链表，依次摘取结点，在摘取接结点前需要用指针temp 记录后继结点，以防止链接后丢失后继结点；
（4）、将摘取的结点插入到头结点之后，最后p指向新的待处理结点temp(p=temp);
void Inverse(LinkList *L){
LinkList p,temp;
p = (*L)->next;
(*L)->next = NULL;
while (p) {
// temp指向p的后继结点，防止丢失
temp = p->next;
// p 指向的结点 后继为之前的首元结点，前驱是头结点（也就是插入到头结点之后，头插法）
p->next = (*L)->next;
(*L)->next = p;
// p向后移动 p = p->next;
p = temp;
}
}
题目4：
4、设计一个算法，删除递增有序链表中值大于等于mink 且小于等于maxk（mink，maxk是给定的连个参数，其值可以和表中的元素相同，也可以不同）的所有元素；
分析：
递增有序链表，找到对应的上下边界，将其中的值全部删除掉即可。
思路：
（1）、用指针p 指向链表头结点，temp 用来指向要删除的结点。
（2）、遍历去查看p 的后继结点，通过p 的后继结点的值判断是否是要删除的结点。
（3）、如果是要删除的结点，就把p 的后继结点删除，后继指向下下一个结点。不移动p（以后后继已经变了）继续遍历。
（4）、如果p 后继结点不是要删除的结点，将p 后移。继续遍历
void DeleteMinMax(LinkList *L, int mink, int maxk){
LinkList p,temp;
p = (*L);
// 遍历是用p->next完成
while (p->next) {
temp = p->next;
if (temp->data >= mink && temp->data <= maxk) {
p->next = temp->next;
free(temp);
}else
p = p->next;
}
}验证
printf("******题目3:********\n");
InitList(&L);
for(int j = 10;j>=0;j-=2)
{
iStatus = ListInsert(&L, 1, j);
}
printf("L逆转前:\n");
ListTraverse(L);
Inverse(&L);
printf("L逆转后:\n");
ListTraverse(L);
//******************************************
L逆转前:
0 2 4 6 8 10
L逆转后:
10 8 6 4 2 0 题目5：
5、设将n(n>1)个整数存放到一维数组R 中，试设计一个在时间和空间复杂度都尽可能高效的算法；将R 中保存的序列循环左移p 个位置（0<p<n）个位置，即将R 中的数据由（x0，x1,...,xn-1）变换成（xp,xp+1,...,xn-1,x0,x1,...,xp-1）;
例如：pre[10] = {0,1,2,3,4,5,6,7,8,9},
n = 10,p = 3;
pre[10] = {3,4,5,6,7,8,9,0,1,2}
思路：
（1）、先将n个数据原地逆置 （9，8，7，6，5，4，3，2，1，0）
（2）、将n个数据拆解成 [9,8,7,6,5,4,3] [2,1,0];
（3）、将前n-p 个数据和后p 个数据分别原地逆置；[3,4,5,6,7,8,9] [0,1,2]
复杂度分析：
时间复杂度：O(n);
空间复杂度：O(1);
void Reverse(int *pre,int left ,int right){
int i=left,j=right,temp;
// 数组逆置
while (i < j) {
temp = pre[i];
pre[i] = pre[j];
pre[j] = temp;
i++;
j--;
}
}
void LeftShift(int *pre,int n,int p){
if (p>0 && p<n) {
Reverse(pre, 0, n-1);
Reverse(pre, 0, n-p-1);
Reverse(pre, n-p, n-1);
}
}验证
printf("******题目4:********\n");
InitList(&L);
for(int j = 10;j>=0;j-=2)
{
iStatus = ListInsert(&L, 1, j);
}
printf("L链表:\n");
ListTraverse(L);
DeleteMinMax(&L, 4, 10);
printf("删除链表mink与maxk之间结点的链表:\n");
ListTraverse(L);
//*************************************
L链表:
0 2 4 6 8 10
删除链表mink与maxk之间结点的链表:
0 2 验证
int pre[10] = {0,1,2,3,4,5,6,7,8,9};
LeftShift(pre, 10, 3);
for (int i=0; i < 10; i++) {
printf("%d ",pre[i]);
}
printf("\n");
//******************************************
3 4 5 6 7 8 9 0 1 2 题目6：
6、已知一个整数序列A= (a0,a1,a2,...,an-1),其中(0<= ai <=n),(0<= i <=n).若存在ap1 = ap2 = ... = apm = x,且m>n/2(0<=pk<n,1<=k<=m),则称x 为 A的主元素。例如，A = (0,5,5,3,5,7,5,5),则5是主元素；若B=(0,5,5,3,5,1,5,7),则B中没有主元素。假设A 中的n个元素保存在一个一维数组中，请设计一个尽可能高效的算法，找出数组元素中的主元素，若存在主元素则输出该元素，否者输出-1。
分析：
主元素，是数组中的出现次数超过一半的元素。
当数组中存在主元素时，所有非主元素的个数和必然少于数组总数的一半。
用主元素的总数 - 非主元素的总数 > 1;
思路：
（1）、选取候选主元素，从前向后依次扫描数组中的每个整数。假定第一个整数位主元素，将其保存在key 中，计数为1，若遇到下一个整数仍然等于key，则计数加1.否者计数减1，当计数减到0时，将遇到的下一个整数保存到key中，计数重新标记为1。开始新一轮计数（继续向后依次比较，直到全部数组元素扫码完毕）。
（2）、判断key中的元素是否是真正的主元素，再次扫描数组。统计key中元素出现的次数，若大于n/2。则是主元素，z否则序列中没有主元素。
复杂度分析：
时间复杂度O(n);
空间复杂度O(1);
int MainElement(int *A, int n){
//目标: 求整数序列A中的主元素;
//count 用来计数
int count = 1;
//key 用来保存候选主元素, 初始A[0]
int key = A[0];
//(1) 扫描数组,选取候选主元素
for (int i = 1; i < n; i++) {
//(2) 如果A[i]元素值 == key ,则候选主元素计数加1;
if (A[i] == key) {
count++;
}else{
//(3) 当前元素A[i] 非候选主元素,计数减1;
if(count >0){
count--;
}else{
//(4) 如果count 等于0,则更换候选主元素,重新计数
key = A[i];
count = 1;
}
}
}
//如果count >0
if (count >0){
//(5)统计候选主元素的实际出现次数
for (int i = count = 0; i < n; i++)
if (A[i] == key) count++;
}
//(6)判断count>n/2, 确认key是不是主元素
if (count > n/2) return key;
else return -1; //不存在主元素
}验证
printf("******题目6:********\n");
int A[] = {0,5,5,3,5,7,5,5};
int B[] = {0,5,5,3,5,1,5,7};
int C[] = {0,1,2,3,4,5,6,7};
int value = MainElement(A, 8);
printf("数组A 主元素为: %d\n",value);
value = MainElement(B, 8);
printf("数组B 主元素为(-1表示数组没有主元素): %d\n",value);
value = MainElement(C, 8);
printf("数组C 主元素为(-1表示数组没有主元素): %d\n",value);
//*************************************************************
数组A 主元素为: 5
数组B 主元素为(-1表示数组没有主元素): -1
数组C 主元素为(-1表示数组没有主元素): -1题目7:
7、用单链表保存m 个整数，结点的结构为（data，link），且|data|<=n(n为正整数)。现在要求设计一个时间复杂度尽可能高效的算法，对于链表中的data 绝对值相等的结点，仅保留第一次出现的结点，删除其余绝对值相等的结点。
例如：
链表 A= {21,-15,15,-7,15}
删除后 A= {21，-15，-7}
分析
要求设计的是时间复杂度尽量高效，所以可以考虑用空间换时间的方法。
申请一个空间大小为n+1（0 号单元不使用）的辅助数组。
保存链表中已出现的数值，通过对链表进行一趟扫描来完成删除
思路：
（1）、申请大小为n+1的辅助数组t 并赋值初值为0；
（2）、从首元结点开始遍历链表，依次检查t[abs(data)] 也就是t[|data|] 的值，若[|data|] 为0，即结点首次出现，则保留该结点，并置t[|data|] = 1,若t[|data|] 不为0，则将该结点从链表中删除
复杂度分析:
时间复杂度: O(m),对长度为m的链表进行一趟遍历,则算法时间复杂度为O(m);
空间复杂度: O(n)
void DeleteEqualNode(LinkList *L,int n){
//目标: 删除单链表中绝对值相等的结点;
//1. 开辟辅助数组p.
int *p = alloca(sizeof(int)*n);
LinkList r = *L;
//2.数组元素初始值置空
for (int i = 0; i < n; i++) {
*(p+i) = 0;
}
//3.指针temp 指向首元结点
LinkList temp = (*L)->next;
//4.遍历链表,直到temp = NULL;
while (temp!= NULL) {
//5.如果该绝对值已经在结点上出现过,则删除该结点
if (p[abs(temp->data)] == 1) {
//临时指针指向temp->next
r->next = temp->next;
//删除temp指向的结点
free(temp);
//temp 指向删除结点下一个结点
temp = r->next;
}else
{
//6. 未出现过的结点,则将数组中对应位置置为1;
p[abs(temp->data)] = 1;
r = temp;
//继续向后遍历结点
temp = temp->next;
}
}
}验证
//21,-15,15,-7,15
printf("******题目7:********\n");
InitList(&L);
ListInsert(&L, 1, 21);
ListInsert(&L, 1, -15);
ListInsert(&L, 1, 15);
ListInsert(&L, 1, -7);
ListInsert(&L, 1, 15);
DeleteEqualNode(&L, 21);
ListTraverse(L);
//***************************************
15 -7 21 