王道数据结构代码题（C语言） 单链表部分

已于 2023-06-25 19:37:04 修改
阅读量234 收藏 1
点赞数
分类专栏： 王道数据结构代码题（C语言） 文章标签： 数据结构 c语言 算法
于 2023-06-13 10:49:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Cerulea_n/article/details/131183793
版权
单链表实现

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

#define TRUE 1
#define FALSE 0

typedef struct Node {
    int data;
    struct Node* next;
}Node;


Node* initList() {         // 创建单链表
    Node* L = (Node*)malloc(sizeof(Node));
    L -> data = 0;
    L -> next = NULL;
    return L;
}


void headInsert(Node* L, int data) {          //头插法
    Node* node = (Node*)malloc(sizeof(Node));
    node -> data = data;
    node -> next = L->next;
    L -> next = node;
    L -> data ++;
}


void tailInsert(Node* L, int data) {          //尾插法
    Node* node = L;
    for(int i = 0; i < L -> data; i++) {
        node = node->next;
    }
    Node* n = (Node*)malloc(sizeof(Node));
    n -> data = data;
    n -> next = NULL;
    node -> next = n;
    L -> data ++;
}


int delete(Node* L, int data) {      // 删除结点
    Node* preNode = L;
    Node* node = L -> next;
    while(node){
        if(node -> data == data) {
            preNode -> next = node->next;
            free(node);
            L -> data --;
            return TRUE;
        }
        preNode = node;
        node = node -> next;
    }
    return FALSE;
}


void printList(Node* L) {       // 打印链表
    Node* node = L -> next;
    while(node){
        printf("node = %d\n", node -> data);
        node = node -> next;
    }
}


int main() {
    Node* L = initList();    	// 创建单链表
    headInsert(L, 1);           // 头插法
    headInsert(L, 2);
    headInsert(L, 3);
    headInsert(L, 4);
    headInsert(L, 5);
    tailInsert(L, 6);           // 尾插法
    tailInsert(L, 7);
    printList(L);

    if (delete(L, 3)) {
        printf("success delete\n");
    }
    else {
        printf("fail delete\n");
    }
    printList(L);
    return 0;
}

1.

在这里插入图片描述

// 使用到c++内容

#include <stdio.h>
#include <stdlib.h>
typedef struct Link
{
	int value;
	Link *next;
}Link;

/*
     c++实现，其中Link *&P  在c++中可使用，C语言不可以
*/
void deleteX(Link *&p, int delNum) {//这里的第一个函数参数必须是引用值，不然会导致断链
	Link *pre;//定义一个指针，进行删除
	if (p == NULL){
        return;
	}
	if (p->value == delNum) {
		pre = p;
		p = p->next;
		free(pre);
		deleteX(p, delNum);
	}
	else
		deleteX(p->next, delNum);
}

Link *create() {
	Link *p, *rear, *head;
	head = (Link *)malloc(sizeof(Link));
	rear = (Link *)malloc(sizeof(Link));
	head = NULL;
	rear = NULL;
	int value;
	printf("请输入链表各节点的值，以9999结束：");
	scanf("%d", &value);
	while (value != 9999) {//依次创建节点
		p = (Link *)malloc(sizeof(Link));//创建一个新的节点
		p->value = value;
		p->next = NULL;
		if (head == NULL) {
			rear = p;
			head = p;
		}
		else {
			rear->next = p;
			rear = p;
		}
		scanf("%d", &value);
	}
	rear->next = NULL;
	return head;
}
Link *create2() {
	Link *p, *rear, *head;
	head = (Link *)malloc(sizeof(Link));
	head = NULL;
	int value;
	printf("请输入链表各节点的值，以9999结束：");
	scanf("%d", &value);
	while (value != 9999) {//依次创建节点
		p = (Link *)malloc(sizeof(Link));
		p->value = value;
		p->next = NULL;
		if (head == NULL) {
			head = p;
		}
		else {

			p->next = head->next;
			head->next = p;
		}

		scanf("%d", &value);
	}
	return head;
}
int main() {
	int delNum;
	Link *head, *q;
	head = create();
	q = head;
	printf("打印链表：");
	while (q != NULL) {
		printf("%d ", q->value);
		q = q->next;
	}
	q = head;
	printf("请输入想要删除的节点的值：");
	scanf("%d", &delNum);
	deleteX(q, delNum);
	printf("删除后链表：");
	while (q != NULL) {
		printf("%d ", q->value);
		q = q->next;
	}
	return 0;
}

2.在这里插入图片描述

// 使用到c++内容

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

typedef struct Link {
	int data;
	struct Link* next;
}Link;

/*

    // c++实现，其中Link *&P  在c++中可使用，C语言不可以

void deleteX(Link*& p,int delNum) {     //递归方法(c++实现)
    Link* q;
	if (p == NULL)
        return;
	if (p->data == delNum){
		q = p;
		p = p->next;
		free(q);
		deleteX(p, delNum);
	}
	else {
		deleteX(p->next, delNum);
	}
*/

//非递归，直接遍历
void deleteX(Link* p,int delNum) {
	Link *pre = p, *q = p->next, *r;
	while (q) {
		if (q -> data == delNum) {
			r = q;      //r指向待删除节点
			q = q->next;
			pre->next = q;  //删除节点
			free(r);   //释放节点
		}
		else {
			pre = q;
			q = q->next;
		}
	}
}


int main() {
	//创建节点
	Link *head = (Link*)malloc(sizeof(Link));    // 建立头结点
	Link *q = (Link*)malloc(sizeof(Link));       // 新结点
	q = head;
	head->next = NULL;

	int n,data,delNum;
	printf("请输入结点个数：");
	scanf("%d",&n);

	for (int i = 0; i < n; i++) {   // 尾插法
		printf("请输入第%d个结点值：",i+1);
		Link *p = (Link*)malloc(sizeof(Link));   // 新建结点
		scanf("%d",&data);
		p->data = data;          // 新结点加入元素
		head->next = p;
		head = p;

	}
	head->next = NULL;    //这里要将指针的next指向NULL，不然后面的判断会出问题，而且这也是应该养成的好习惯
	head = q;   //head回到头结点

	printf("当前链表值为：");
	while (head->next) {
		printf("%d ",head->next->data);
		head = head->next;
	}
	printf("\n");

	printf("请输入要删除的值：");
	scanf("%d",&delNum);

	head = q;//head回到头结点
	deleteX(head,delNum);  // 删除结点

	printf("删除后链表值为：");
	while (head->next) {
		printf("%d ", head->next->data);
		head = head->next;
	}
	return 0;
}

3.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void reverseOutput(Link *p) {
	if (p == NULL) return;
	else {
		reverseOutput(p->next);
		printf("%d ",p->data);
	}

}
int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q;
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;
        newP -> next = NULL;
        head -> next = newP;
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;
	head = q; // 最后head要指向头结点
	reverseOutput(head->next);
	return 0;
}

4.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void deleteMin(Link *p){
    Link *preMinp = p, *minP = p -> next;   // 记录最小值位置
    Link *preq = p -> next, *q = p ->next -> next, *f;
    while(q){
        if(q -> data < minP -> data){
            minP = q;
            preMinp = preq;
        }
        preq = q;
        q = q -> next;
    }
    f = minP;
    preMinp -> next = minP -> next;
    free(f);
}

int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点
	printf("打印链表：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
	}

	head = q;
	deleteMin(head);

	printf("\n");
	printf("删除后链表值为：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
    }
    return 0;
}

5.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;


void reverse1(Link *h){   // 方法1：修改指针指向逆置
    Link *pre = h, *p = h -> next, *q = h -> next, *r;
    while(p){
        r = p -> next;
        p -> next = pre;
        pre = p;
        p = r;
    }
    h -> next = pre;  // 头指针指向最后一个结点
    q -> next = r;    // 第一个结点指向NULL，否则为循环单链表
}


void reverse2(Link *h){   // 方法2;头插法逆置
    Link *L = h, *p = h -> next, *r;
    L -> next = NULL;
    while(p){
        r = p -> next;
        p -> next = L -> next;
        L -> next = p;
        p = r;
    }
    h =L;
}

int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点
	printf("打印链表：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
	}

	head = q;
	reverse1(head);

	printf("\n");
	printf("逆置后链表值为：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
    }
    return 0;
}

6.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void bubbleSort(Link *h) {//冒泡排序
	int flag = 0;//排序标志，产生过变动就置为1
	int count = 0;//记录链表长度
	Link *pre=h, *p = h->next,*r;
	while (p) {
		count++;
		p = p->next;
	}
	p = h->next;
	for (int i = 0; i < count;i++) {
		flag = 0;
		while (p->next) {//开始第i+1轮冒泡
			if (p->data > p->next->data) {//前者大于后者，则需要交换
				r = p->next->next;//r指向下一个节点，防止断链
				pre->next = p->next;
				p->next->next = p;
				pre = p->next;
				p->next = r;
				flag = 1;//有改动，flag置为1
			}
			else {
				pre = p;
				p = p->next;
			}
		}
		if (!flag) break;//若某一轮链表未作变换，则认定已经排好序，退出循环
		pre = h;//重新从头开始遍历
		p = h->next;
	}
}


int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点
	printf("打印链表：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
	}

	head = q;
	bubbleSort(head);

	printf("\n");
	printf("排序后链表值为：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
    }
    return 0;
}

7.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void deleteNum(Link *h, int min, int max) {
	Link *pre=h, *p = h->next,*r;
	while (p) {    // 符合条件，进行删除
		if(p -> data > min && p -> data < max){
            r = p -> next;
            pre -> next = p -> next;
            free(p);
            p = r;
		}
		else{
            pre = p;
            p = p -> next;
		}
	}
}


int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点


	printf("打印链表：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
	}
    printf("\n");

	int min, max;
	printf("请输入要删除的值的范围：\n");
	printf("min=");
	scanf("%d", &min);
	printf("max=");
	scanf("%d", &max);

	head = q;
	deleteNum(head, min, max);

	
	printf("删除后链表值为：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
    }
    return 0;
}

8.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *next;
}Link;

Link* createLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num==0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next;// head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}

		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

void findCommon(Link *h1, Link *h2) {
    Link *p = h1->next, *q = h2->next;
    int countP = 0, countQ = 0, gap;

	while(p){  // 统计元素个数
        countP++;
        p = p->next;
        }
    while(q){
        countQ++;
        q = q->next;
        }

    if(countP > countQ){    // 让p指向较长链表，q指向较短链表
        p = h1->next;
        q = h2->next;
        gap = countP - countQ;
    }
    else{
        p = h2->next;
        q = h1->next;
        gap = countQ - countP;
    }

    while(gap--){  // 较长链表先前进gap个位置
        p = p->next;
    }
    while(q != NULL){
        if(p->data == q->data){
            printf("%d ", p->data);
        }
        p = p->next;
        q = q->next;
    }
}


int main() {
	Link *h1, *h2;
	//Link *createLink(int);
	h1 = createLink(0);
	h2 = createLink(0);

	findCommon(h1,h2);

	return 0;
}

9.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void delete(Link *h) {
	Link *pre = h, *p = h->next, *min = h->next, *minPre = h;
	p = h->next;
	printf("输出顺序为：");
	while (h->next) {
        while (p) {
			if (p->data < min->data) {
				minPre = pre;
				min = p;
			}
			pre = p;
			p = p->next;
		}
		printf("%d ",min->data);
		minPre->next = min->next;
		free(min);
		pre = minPre = h;
		p = min = h->next;
	}
	printf("\n");
}


int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点


	printf("打印链表：");
	while(head -> next){
        printf("%d ", head ->next -> data);
        head = head -> next;
	}
    printf("\n");

    head = q;
	delete(head);

	printf("删除后链表值为：");
	while(head -> next){
        printf("%d ", head -> next -> data);
        head = head -> next;
    }
    return 0;
}

10.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void  dividel(Link *lb, Link *la){
    int flag = 0;  // 奇偶判定
    Link *l = la, *p = la->next, *rb = lb, *ra = l;
    l->next = NULL; // 原链表置空
    while(p){     // 尾插法
        if(!flag){  // 奇元素
            ra->next = p;
            ra = p;
            flag = 1;
        }
        else{     // 偶元素
            rb->next = p;
            rb = p;
            flag = 0;
        }
        p = p->next;
    }
    ra->next = NULL;
    rb->next = NULL;
}

int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点

		printf("打印链表：");
	while(head->next){
        printf("%d ", head ->next -> data);
        head = head -> next;
	}
    printf("\n");
    head = q;
    
    Link *b = (Link *)malloc(sizeof(Link));  // 创建链表b
    dividel(b, head);

	printf("打印链表A：");
	while(head->next){
        printf("%d ", head ->next -> data);
        head = head -> next;
	}
    printf("\n");


	printf("打印链表B：");
	while(b -> next){
        printf("%d ", b -> next -> data);
        b = b -> next;
    }
    return 0;
}

11.

在这里插入图片描述

12.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void  deleteRep(Link *h){
    Link *pre = h, *p = h->next, *r;
    while(p->next){
        if(p->data == p->next->data){
            r = p->next;
            pre->next = p->next;
            free(p);
            p = r;
            continue;
        }
        pre = p;
        p = p->next;
    }
}

int main() {
	int n,data;
	//创建链表
	printf("请输入创建结点个数：");
	scanf("%d", &n);
	Link *q; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* head = (Link*)malloc(sizeof(Link));
	head -> next = NULL;
	q = head;
	for(int i = 0; i < n; i++){
        Link *newP = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        newP -> data = data;   // 赋值给新结点
        newP -> next = NULL;
        head -> next = newP;    // 尾插法
        head = head -> next;    // head始终指向最新结点
	}
	head -> next = NULL;  // 尾插法最后置空
	head = q; // 最后head要指向头结点

		printf("打印链表：");
	while(head->next){
        printf("%d ", head ->next -> data);
        head = head -> next;
	}

    printf("\n");
    head = q;
    deleteRep(head);

	printf("去重后链表：");
	while(head->next){
        printf("%d ", head ->next -> data);
        head = head -> next;
	}
    return 0;
}

13.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void  merge(Link *ha, Link *hb){
    Link *l = ha, *pa = ha->next, *pb = hb->next, *ra, *rb;
    l->next = NULL;
    while(pa && pb){   // 头插法
        if(pa->data < pb->data){
            ra = pa->next;
            pa->next = l->next;
            l->next = pa;
            pa = ra;
        }
        else{
            rb = pb->next;
            pb->next = l->next;
            l->next = pb;
            pb = rb;
        }
    }
    while(pa){
        ra = pa->next;
        pa->next = l->next;
        l->next = pa;
        pa = ra;
    }
    while(pb){
        rb = pb->next;
        pb->next = l->next;
        l->next = pb;
        pb = rb;
    }
}

int main() {

    //创建链表A
	int nA,dataA;
	printf("请输入链表 A 创建结点个数：");
	scanf("%d", &nA);
	Link *qA; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headA = (Link*)malloc(sizeof(Link));
	headA -> next = NULL;
	qA = headA;
	for(int i = 0; i < nA; i++){
        Link *newPA = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataA);
        newPA -> data = dataA;   // 赋值给新结点
        newPA -> next = NULL;
        headA -> next = newPA;    // 尾插法
        headA = headA -> next;    // head始终指向最新结点
	}
	headA -> next = NULL;  // 尾插法最后置空
	headA = qA; // 最后head要指向头结点


	//创建链表B
	int nB,dataB;
	printf("请输入链表 B 创建结点个数：");
	scanf("%d", &nB);
	Link *qB; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headB = (Link*)malloc(sizeof(Link));
	headB -> next = NULL;
	qB = headB;
	for(int i = 0; i < nB; i++){
        Link *newPB = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataB);
        newPB -> data = dataB;   // 赋值给新结点
        newPB -> next = NULL;
        headB -> next = newPB;    // 尾插法
        headB = headB -> next;    // head始终指向最新结点
	}
	headB -> next = NULL;  // 尾插法最后置空
	headB = qB; // 最后head要指向头结点


    printf("打印链表A：");
	while(headA->next){
        printf("%d ", headA ->next -> data);
        headA = headA -> next;
	}

	printf("\n");
    printf("打印链表B：");
	while(headB->next){
        printf("%d ", headB ->next -> data);
        headB = headB -> next;
	}

    printf("\n");
    headA = qA;
    headB = qB;

    merge(headA, headB);

	printf("归并后链表：");
	while(headA->next){
        printf("%d ", headA ->next -> data);
        headA = headA -> next;
	}
    return 0;
}

14.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void linkCommon(Link *a, Link *b, Link *c ) {
	Link *lc = c,*la = a->next, *lb = b->next, *rc = lc;
	while (la) {
		while (lb) {
			if (la->data==lb->data) {//如果是公共元素
				Link *p = (Link*)malloc(sizeof(Link));
				p->data = la->data;
				rc->next = p;//采用尾插法
				rc = p;
				break;
			}
			lb = lb->next;
		}
		la = la->next;
		lb = b->next;
	}
	rc->next = NULL;//最后一个节点指针需要指向NULL。
}



int main() {

    //创建链表A
	int nA,dataA;
	printf("请输入链表 A 创建结点个数：");
	scanf("%d", &nA);
	Link *qA; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headA = (Link*)malloc(sizeof(Link));
	headA -> next = NULL;
	qA = headA;
	for(int i = 0; i < nA; i++){
        Link *newPA = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataA);
        newPA -> data = dataA;   // 赋值给新结点
        newPA -> next = NULL;
        headA -> next = newPA;    // 尾插法
        headA = headA -> next;    // head始终指向最新结点
	}
	headA -> next = NULL;  // 尾插法最后置空
	headA = qA; // 最后head要指向头结点


	//创建链表B
	int nB,dataB;
	printf("请输入链表 B 创建结点个数：");
	scanf("%d", &nB);
	Link *qB; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headB = (Link*)malloc(sizeof(Link));
	headB -> next = NULL;
	qB = headB;
	for(int i = 0; i < nB; i++){
        Link *newPB = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataB);
        newPB -> data = dataB;   // 赋值给新结点
        newPB -> next = NULL;
        headB -> next = newPB;    // 尾插法
        headB = headB -> next;    // head始终指向最新结点
	}
	headB -> next = NULL;  // 尾插法最后置空
	headB = qB; // 最后head要指向头结点

    //创建链表C
    Link *c = (Link*)malloc(sizeof(Link));
    c->next = NULL;

    printf("打印链表A：");
	while(headA->next){
        printf("%d ", headA ->next -> data);
        headA = headA -> next;
	}

	printf("\n");
    printf("打印链表B：");
	while(headB->next){
        printf("%d ", headB ->next -> data);
        headB = headB -> next;
	}

    printf("\n");
    headA = qA;
    headB = qB;
    linkCommon(headA, headB, c);

	printf("C链表为：");
	while(c->next){
        printf("%d ", c ->next -> data);
        c = c -> next;
	}
    return 0;
}

15.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void listCommon(Link *a, Link *b) {
	Link *pa = a->next, *pb = b->next, *r, *la = a;
	la->next = NULL;
	while (pa && pb) {
        if (pa->data == pb->data) {//如果是公共元素
            la->next = pa;  // 尾插法
            la = pa;
            pa = pa->next;
            pb = pb->next;
        }
        else{
            if(pa->data < pb->data){
                pa = pa->next;
            }
            else{
                pb = pb->next;
            }
        }
	}
	la->next = NULL;//最后一个节点指针需要指向NULL。
}



int main() {

    //创建链表A
	int nA,dataA;
	printf("请输入链表 A 创建结点个数：");
	scanf("%d", &nA);
	Link *qA; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headA = (Link*)malloc(sizeof(Link));
	headA -> next = NULL;
	qA = headA;
	for(int i = 0; i < nA; i++){
        Link *newPA = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataA);
        newPA -> data = dataA;   // 赋值给新结点
        newPA -> next = NULL;
        headA -> next = newPA;    // 尾插法
        headA = headA -> next;    // head始终指向最新结点
	}
	headA -> next = NULL;  // 尾插法最后置空
	headA = qA; // 最后head要指向头结点


	//创建链表B
	int nB,dataB;
	printf("请输入链表 B 创建结点个数：");
	scanf("%d", &nB);
	Link *qB; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headB = (Link*)malloc(sizeof(Link));
	headB -> next = NULL;
	qB = headB;
	for(int i = 0; i < nB; i++){
        Link *newPB = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataB);
        newPB -> data = dataB;   // 赋值给新结点
        newPB -> next = NULL;
        headB -> next = newPB;    // 尾插法
        headB = headB -> next;    // head始终指向最新结点
	}
	headB -> next = NULL;  // 尾插法最后置空
	headB = qB; // 最后head要指向头结点


    printf("打印链表A：");
	while(headA->next){
        printf("%d ", headA ->next -> data);
        headA = headA -> next;
	}

	printf("\n");
    printf("打印链表B：");
	while(headB->next){
        printf("%d ", headB ->next -> data);
        headB = headB -> next;
	}

    printf("\n");
    headA = qA;
    headB = qB;
    listCommon(headA, headB);

	printf("合并后链表为：");
	while(headA->next){
        printf("%d ", headA ->next -> data);
        headA = headA -> next;
	}
    return 0;
}

16.

在这里插入图片描述

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

typedef struct Link
{
	int data;
	struct Link *next;
}Link;

void subList(Link *a, Link *b) {
	Link *pa = a->next, *pb = b->next, *r, *la = a;
	while (pa && pb) {
        if (pa->data == pb->data) {//如果是公共元素
            pa = pa->next;
            pb = pb->next;
        }
        else{
            pb = b->next;
            la = la->next;
            pa = la->next;
        }
	}
	if(pb == NULL){
        printf("True");  // 链表B是链表A的子列
	}
	else{
        printf("False"); // 链表B不是链表A的子列
	}
}



int main() {

    //创建链表A
	int nA,dataA;
	printf("请输入链表 A 创建结点个数：");
	scanf("%d", &nA);
	Link *qA; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headA = (Link*)malloc(sizeof(Link));
	headA -> next = NULL;
	qA = headA;
	for(int i = 0; i < nA; i++){
        Link *newPA = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataA);
        newPA -> data = dataA;   // 赋值给新结点
        newPA -> next = NULL;
        headA -> next = newPA;    // 尾插法
        headA = headA -> next;    // head始终指向最新结点
	}
	headA -> next = NULL;  // 尾插法最后置空
	headA = qA; // 最后head要指向头结点


	//创建链表B
	int nB,dataB;
	printf("请输入链表 B 创建结点个数：");
	scanf("%d", &nB);
	Link *qB; // 工作指针，记录头结点位置，最后head需要指向头结点
	Link* headB = (Link*)malloc(sizeof(Link));
	headB -> next = NULL;
	qB = headB;
	for(int i = 0; i < nB; i++){
        Link *newPB = (Link *)malloc(sizeof(Link));  // 创建新结点
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &dataB);
        newPB -> data = dataB;   // 赋值给新结点
        newPB -> next = NULL;
        headB -> next = newPB;    // 尾插法
        headB = headB -> next;    // head始终指向最新结点
	}
	headB -> next = NULL;  // 尾插法最后置空
	headB = qB; // 最后head要指向头结点


    printf("打印链表A：");
	while(headA->next){
        printf("%d ", headA ->next -> data);
        headA = headA -> next;
	}

	printf("\n");
    printf("打印链表B：");
	while(headB->next){
        printf("%d ", headB ->next -> data);
        headB = headB -> next;
	}

    printf("\n");
    headA = qA;
    headB = qB;
    subList(headA, headB);


    return 0;
}

17.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *pre;
	struct Link *next;
}Link;

Link *createDoubleLoopLink() {
	int n, data;
	Link *head = (Link*)malloc(sizeof(Link));
	head->next = NULL;
	head->pre = NULL;
	Link *p = head;
	printf("请输入结点个数：");
	scanf("%d", &n);
	for(int i = 0; i < n; i++){
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        Link *newP = (Link*)malloc(sizeof(Link));
        newP->data = data;
        newP->pre = p;
        p->next = newP;
        p = newP;
	}
	p->next = head;
	head->pre = p;

	return head;
}


Link *isSymmetry(Link *h){
    Link *pre = h->pre, *next = h->next;

    while(pre != next && pre->pre != next){
        if(pre->data != next->data){
            printf("该双链表不对称");
            break;
        }
        else{
            pre = pre->pre;
            next = next->next;
        }
    }
    if(pre == next || pre->pre == next){
        printf("该双链表对称");
    }
}


int main() {
    Link *head;
    Link *createDoubleLoopLink();
    head = createDoubleLoopLink();

    isSymmetry(head);
    return 0;
}

18.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *next;
}Link;

Link *createSinLoopLink() {   // 创建循环单链表
	int n, data;
	Link *head = (Link*)malloc(sizeof(Link));
	head->next = NULL;
	Link *p = head;
	printf("请输入结点个数：");
	scanf("%d", &n);
	for(int i = 0; i < n; i++){
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        Link *newP = (Link*)malloc(sizeof(Link));
        newP->data = data;
        p->next = newP;
        p = newP;
	}
	p->next = head;
	return head;
}


void linkTwoLists(Link *h1, Link *h2){
    Link *p1 = h1->next, *p2 = h2->next;
    while(p1->next != h1){      // 判断p1->next是否等于h1，进而判断是否到达尾结点
        p1 = p1->next;
    }
    p1->next = p2;
    while(p2->next != h2){
        p2 = p2->next;
    }
    p2->next = h1;
    free(h2);
}


int main() {
    Link *h1, *h2, *p;
    Link *createSinLoopLink();
    h1 = createSinLoopLink();
    h2 = createSinLoopLink();

    linkTwoLists(h1, h2);

    p = h1->next;
    printf("新循环链表为：");
    while(p != h1){
        printf("%d ", p->data);
        p = p->next;
    }
    return 0;
}

19.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *next;
}Link;

Link *createSinLoopLink() {   // 创建循环单链表
	int n, data;
	Link *head = (Link*)malloc(sizeof(Link));
	head->next = NULL;
	Link *p = head;
	printf("请输入结点个数：");
	scanf("%d", &n);
	for(int i = 0; i < n; i++){
        printf("请输入第%d个结点的值：", i + 1);
        scanf("%d", &data);
        Link *newP = (Link*)malloc(sizeof(Link));
        newP->data = data;
        p->next = newP;
        p = newP;
	}
	p->next = head;
	return head;
}

void DeleteLink(Link *h){
    Link *pre = h, *minpre = h, *p = h->next, *min = h->next, *r;
    while(h->next != h){
        while(p != h){   // 寻找最小值
            if(min->data > p->data){
                minpre = pre;
                min = p;
            }
            pre = p;
            p = p->next;
        }
        printf("%d ", min->data);

        r = min->next;
        minpre->next = min->next;  // 删除当前最小值
        free(min);

        p = h->next;  // 重新遍历
        pre = h;
        minpre = h;
        min = h->next;
    }
    free(h); // 释放头结点
}


int main() {
    Link *head;
    Link *createSinLoopLink();
    head = createSinLoopLink();

    DeleteLink(head);
    return 0;
}

20.

在这里插入图片描述

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

typedef struct Link
{
    int data;
    int freq;
	struct Link *next;
	struct Link *pre;
}Link;

void locate(Link *h,int num) {
	int flag = 0;  //找到标志
	Link *pre = h, *p = h->next, *t, *preQ = h, *q;
	while (p) {
		if (p->data==num) {//如果找到
			flag = 1;//表示找到
			p->freq++;
			t = p;    //保存该结点
			if (p->next) {
				pre->next = p->next;//取出该结点
				p->next->pre = pre;
			}
			else {
				pre->next = NULL;//如果我们查找的结点是最后一个结点，我们要将next指向NULL，不然之后遍历时会出问题
			}
			q = h->next;
			while (q) {//进行排序
				if (t->freq >= q->freq) {//结点freq大于等于当前遍历结点时，插入
					t->next = q;
					q->pre = t;
					preQ->next = t;
					t->pre = preQ;
					break;
				}
				preQ = q;
				q = q->next;
			}
			break;
		}
		pre = p;
		p = p->next;
	}
	if (!flag) {
		printf("未找到该元素,序列不改变");
	}
}
int main() {
    // 创建双链表
	int n, data,num;
	Link *head = ( Link *)malloc(sizeof(Link));
	head->next = NULL;
	head->pre = NULL;
	Link *p = head;
	printf("请输入节点个数：n=");
	scanf("%d", &n);
	for (int i = 0; i < n; i++) {
		printf("请输入第%d个节点值:", i + 1);
		scanf("%d", &data);
		Link *newP = ( Link*)malloc(sizeof( Link));
		newP->data = data;
		newP->pre = p;
		newP->freq = 0;
		p->next = newP;
		p = newP;
	}
	p->next = NULL;
	do {
        printf("\n");
		printf("请输入要查找的值,输入9999代表结束：num=");
		scanf("%d",&num);
		if (num == 9999)continue;//如果num=9999，跳入下一次循环
		locate(head,num);
		p = head->next;
		printf("调整后链表为：");
		while (p) {
			printf("%d ",p->data);
			p = p->next;
		}
	} while (num!=9999);
	return 0;
}

21.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *next;
}Link;

Link* createLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num==0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next;// head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}

		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

Link *isLoop(Link *h) {
    Link *fast = h, *slow = h;
	while(slow && fast && fast->next){  // slow每次走一步，fast每次走两步
        slow = slow->next;
        fast = fast->next->next;
        if(slow == fast){   // 再次相遇，有环
            break;
        }
	}
	if(slow == NULL || (fast == NULL || fast->next == NULL)){  // 无环
        return NULL;
	}
	fast = h;
	while(fast != slow){
        fast = fast->next;
        slow = slow->next;
	}
	return fast;
}


int main() {
	Link *head,*l, *s;
	int count = 0;    //默许创建的链表中结点的绝对值<=100
	//Link *createLink(int);
	head = createLink(0);
    l = head;
    while(l->next){
        l = l->next;
    }

    l->next = head->next->next->next;   // 手动设置一个环

    s = isLoop(head);
    if(s){
        printf("链表环起始结点值为：%d", s->data);
    }
    else{
        printf("链表无环");
    }
	return 0;
}

22.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *next;
}Link;

Link* createSinLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num==0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next;// head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}

		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

void findTheReciprocalK1(Link *h, int k){  // 方法1
    Link *p = h->next;
    int count = 0, num;
    while(p){  // 统计元素个数
        count++;
        p = p->next;
    }
    p = h->next;
    if(k > count){
        return 0;
    }
    else{
        num = count - k + 1;
        while(--num){
            p = p->next;
        }
        printf("%d ", p->data);
        return 1;
    }
}

void findTheReciprocalK2(Link *h, int k){  // 方法2
    Link *p = h->next, *q = h->next;
    int count = k;
    while(count--){   // 先让q走k个位置
        if(q == NULL){
            printf("倒数第%d个结点不存在", k);
            return 0;
        }
        q = q->next;
    }
    while(q != NULL){  // p, q同时后移，当q为空时，p所指为倒数第k个元素
        p = p->next;
        q = q->next;
    }
    printf("倒数第%d个结点值为：%d", k, p->data);
    return 1;
}

int main() {
    int k;
    Link *head;
    //Link *createSinLink();
    head = createSinLink(0);

    printf("请输入需查找倒数第几个数：");
    scanf("%d", &k);

    //findTheReciprocalK1(head, k);
    findTheReciprocalK2(head, k);
    return 0;
}

23.

在这里插入图片描述
在这里插入图片描述

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

typedef struct Link
{
    union{
        int data;
        char letter;
    };
	struct Link *next;
}Link;

Link* createLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num == 0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next; // head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}
		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

Link *findCommonSuffix(Link *h1,Link *h2){
    Link *p = h1->next, *q = h2->next;
    int countP = 0, countQ = 0, gap;
    while(p){  // 获取链表长度
        countP++;
        p = p->next;
    }
    while(q){
        countQ++;
        q = q->next;
    }
    if(countQ > countP){   // 让p指针始终指向较长的链表
        p = h2->next;
        q = h1->next;
        gap = countQ - countP;
    }
    else{
        p = h1->next;
        q = h2->next;
        gap = countP - countQ;
    }
    while(gap--){  // 较长链表先走gap个位置
        p = p->next;
    }
    while(q != p && q != NULL){  // 当指针不同且不为空时继续向后移动
        q = q->next;
        p = p->next;
    }

    return p;
}


int main() {
    Link *h1, *h2, *com, *p1, *p2, *start;
    //Link *createLink(int);
    char p[] = "letter";
    h1 = createLink(1);
    h2 = createLink(1);
    com = createLink(1);  // 公共部分

    p1 = h1->next;
    p2 = h2->next;
    while(p1->next){  // 到达链尾
        p1 = p1->next;
    }
    while(p2->next){
        p2 = p2->next;
    }
    p1->next = com->next;  // 链接公共部分
    p2->next = com->next;
    p1 = h1->next;
    p2 = h2->next;
    while(p1){
        printf("%c ", p1->letter);
        p1 = p1->next;
    }
    printf("\n");
    while(p2){
        printf("%c ", p2->letter);
        p2 = p2->next;
    }

    printf("\n");
    start = findCommonSuffix(h1, h2);
    printf("%c ", start->letter);
    return 0;
}

24.

在这里插入图片描述

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

typedef struct Link
{
    union{
        int data;
    }type;
    int data;
	struct Link *next;
}Link;

Link* createLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num==0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next;// head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}

		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

void deleteRepAbs(Link *h,int n) {
	int *arr = (int *)malloc(sizeof(int)*n);//大小是sizeof(int)*n
	for (int i = 0; i < n;i++) {    //赋初值0
		*(arr + i) = 0;
	}
	Link *pre = h, *p = h->next, *r;
	while (p) {
		if (*(arr+abs(p->data))==0) {//首次访问
			*(arr + abs(p->data)) = 1;
			pre = p;
			p = p->next;
		}
		else {
			r = p->next;
			pre->next = p->next;    //删除
			free(p);
			p = r;
		}
	}
}


int main() {
	Link *head,*p;
	int n = 100;    //默许创建的链表中结点的绝对值<=100
	//Link *createLink(int);
	head = createLink(0);

	deleteRepAbs(head,n);

	p = head->next;
	printf("去重后链表为：");
	while (p) {
		printf("%d ", p->data);
		p = p->next;
	}
	return 0;
}

25.

在这里插入图片描述

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

typedef struct Link
{
    int data;
	struct Link *next;
}Link;

Link* createLink(int num) {  //创建链表
	int n, data;
	char letter;
	printf("请输入创建链表的结点个数：");
	scanf("%d", &n);
	Link *q;
	Link *head = (Link*) malloc(sizeof(Link));
	head->next = NULL;
	q = head;
	for (int i = 0; i < n; i++) {
		Link *newP = (Link*) malloc(sizeof(Link));
		num ? printf("请输入第%d个结点的值(char)：",i+1): printf("请输入第%d个结点的值(int)：", i + 1);
		if (num==0) {  // 0代表创建整数型结点
			scanf("%d", &data);
			newP->data = data;

		}
		else {  // 1代表创建字符型结点
			getchar();
			scanf("%c", &letter);
			newP->data = letter;
		}
		newP->next = NULL;
		head->next = newP;
		head = head->next;// head要始终指向最新结点
	}
	head->next = NULL;
	head = q;   //最后head要指向头结点
	printf("打印链表：");
	printf("\n");
	while (head->next) {
		if (num==0) {
			printf("%d ", head->next->data);
		}
		else {
			printf("%c", head->next->data);
		}

		head = head->next;
	}
	printf("\n");
	head = q;
	return head;
}

void crossLink(Link *h) {
    void reverse(Link *);
    Link *fast = h->next, *slow = h->next, *mid;
    mid = (Link *)malloc(sizeof(Link));
	while(fast->next && fast->next->next){  // 寻找中间结点
        slow = slow->next;
        fast = fast->next->next;
	}
	mid->next = slow->next;
	reverse(mid);  // 逆置mid后的结点
	slow->next = mid->next;
	fast = h->next;
	slow->next = NULL;
	slow = mid->next;
	while(slow){  // 逐个进行输入
        mid = slow->next;
        slow->next = fast->next;
        fast->next = slow;
        slow = mid;
        fast = fast->next->next;
	}
}

void reverse(Link *h){    //头插法逆置
    Link *p = h->next, *r;
    h->next = NULL;
    while(p){
        r = p->next;
        p->next = h->next;
        h->next = p;
        p = r;
    }
}

int main() {
	Link *head,*p;
	int count = 0;    //默许创建的链表中结点的绝对值<=100
	//Link *createLink(int);
	head = createLink(0);

	crossLink(head);
    printf("新链表为：");
    p = head->next;
    while(p){
        printf("%d ", p->data);
        p = p->next;
    }

	return 0;
}
Jasper.w
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
考研王道数据结构代码.zip
11-26
通过参考"考研王道数据结构代码.zip"中的代码，考生不仅可以加深对理论的理解，还能提高编程能力，为应对考研中的编程题和综合应用题做好准备。同时，结合CSDN上提供的博客文章，可以进行互动学习，解答疑惑，进一步...
王道数据结构代码实现(单链表)
m0_64008087的博客
04-25 354
【代码】王道数据结构代码实现(单链表)
【数据结构】【王道】【线性表】单链表的实现及基本操作（带头结点）（可直接运行）
treesorshining的博客
07-11 1771
1.2 初始化 1.3 判空 1.4 按位序插入 1.5 指定结点后插操作 1.6 指定结点前插操作 1.7 按位序删除 1.8 按位查找 1.9 按值查找 1.10 表的长度 1.11 单链表建立（尾插法） 1.12 单链表建立（头插法） 1.13 输出所有链表元素 2.完整代码 3.运行截图............
【王道数据结构笔记】带头节点的单链表（代码分析）
m0_74195174的博客
04-28 462
这篇文章到这里就结束了如果觉得这篇博客对你有用的话，别忘记三连哦。我是豌豆射手^，让我们我们下次再见。
【椰羊加工厂】王道2024数据结构代码实现--单链表
DNApifa的博客
05-06 175
欢迎阅读文章！准备101012单链表。
2024王道数据结构课后部分代码题
04-16
"2024王道数据结构课后部分代码题"针对的是这一主题，特别是关于树的数据结构部分，这是一组用于学习和实践的代码题目。 树是一种非线性数据结构，它由节点（也称为顶点）和边组成，每个节点可以连接到零个或多个...
王道数据结构+C语言版+超全笔记(图文)+个人整理版本
04-05
(一)数据元素、数据结构、抽象数据类型等概念 (二)算法设计的基本要求 (三)语句的频度和估算时间复杂度 二、线性表 (一)线性表的定义和基本操作 (二)线性表的实现 1.顺序存储结构 2.链式存储结构 3.线性表的应用 三...
2018王道数据结构课后习题代码
10-26
2018年王道数据结构课后习题代码是一个针对该课程学习者的重要资源，它包含了对数据结构概念的深入理解和实际编程实践。这份资料的提供者已经通过了考研，这意味着这些代码经过了实际检验，具有一定的权威性和实用性...
数据结构day3
qq_55245263的博客
07-18 260
顺序表实现学生管理系统
从零开始学数据结构系列之第四章《prim算法（普里姆算法）详解》
铁匠匠匠的博客
07-18 1033
可以参考以下视频。
数组算法--基本查找
2303_78660417的博客
07-20 293
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度
qq_44962949的博客
07-17 224
【代码】(C++二叉树02) 翻转二叉树 对称二叉树 二叉树的深度。
数据结构第32节 无锁编程
hummhumm的专栏
07-17 851
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
C语言排序算法
最新发布
m0_49476241的博客
07-21 721
本篇文章带大家来学习C语言的基本算法。本篇文章主要为大家讲解了C语言中的排序算法，在笔试面试当中可能会经常考察到这些排序算法。
数据结构——栈
weixin_45942515的博客
07-19 248
1、栈的英文为stack2、栈是先入后出（FILO-First In Last Out）的有序列表。3、栈stack是限制线性表中元素的插入和删除只能在线性表的同一端进行的一种特殊线性表。允许插入和删除的一端，为变化的一端，称为栈顶 (Top)，另一端固定的一端，称为栈底(Bottom)。4、根据栈的定义可知，最先放入栈中的元素在栈底，最后放入栈中的元素在栈顶，而删除元素刚好相反，最后放入的元素最先删除，最先放入的元素最后删除。
数据结构之细说链表
m0_73634434的博客
07-17 1063
这里while循环的条件判断必须是tail->next->next，因为我们需要释放最后一个节点的地址，所以需要利用它前面一共节点来释放它，然后将tail->next置空，如果我们直接找最后一个地址然后将它释放前面一个节点就会指向被释放的地址变成一个野指针，因为我们已经找不到前面一个节点的位置了。头插就比较简单了，将该节点连接在第一个节点和第二个节点之间就可以了，但是我们需要先连接第二个和新节点，如果先连接第一个节点和新节点就会找不到第二个节点的地址。下面我们给出链表的构成，看看链表是如何解决这些问题的。
24暑假算法刷题 | Day16 | LeetCode 513. 找树左下角的值，112. 路径总合，106. 从中序和后序遍历序列构造二叉树
weixin_54468359的博客
07-18 1084
24暑假刷题day15打卡 二叉树进阶
数据结构 day2
没有百宝袋的哆啦A梦的博客
07-17 1166
由相同数据类型或不同数据类型构成的集合，但是，该集合中的成员共享同一块内存空间union 结构体名称成员类型1 成员变量1;成员类型2 成员变量2；。。。成员类型n 成员变量n;当程序员写程序时，可能会因为数据类型的问题，在定义变量时，导致该程序比较晦涩难懂，例如：unsigned long int ,struct Stu为了提高代码的简洁性，以及为了更加方便理解使得代码更加优雅，我们可以将这些类型重新起一个简洁好记的名字。引入了关键字 typedef。
王道数据结构代码实现C语言
07-29
王道数据结构提供了一系列的代码实现，包括顺序表、链表、栈队列、二叉树、图以及查找排序等部分的代码实现。\[1\]这些代码实现使用了C语言来实现各种数据结构的功能。 例如，可以使用createDouLoopLink函数来创建一个带有头结点的双向循环链表。该函数会根据用户输入的节点个数和节点值来创建链表，并将链表的尾节点与头结点相连，形成循环链表。\[2\] 另外，还可以使用reverseOutput函数来实现从尾到头输出链表节点的值。该函数利用递归的方式，从链表的尾节点开始逐个输出节点的值，实现了从尾到头的输出。\[3\] 总之，王道数据结构提供了丰富的代码实现，可以帮助学习者更好地理解和应用各种数据结构。 #### 引用[.reference_title] - *1* *2* *3* [王道数据结构【链表】部分代码实现（C语言）](https://blog.csdn.net/u014297502/article/details/126105387)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值