链表基础(我们组的代码)

Future

#include<stdlib.h>

typedef struct Node
{
	int data;//数据域
	Node* next;//指针域，存放下一个节点地址
} Node;

//链表初始化
Node* initlist()
{
	Node* head = (Node*)malloc(sizeof(Node));
	head->data = 0;
	head->next = NULL;
	return head;
}

//头插法
Node* headinsert(int data, Node* list)
{
	Node* newnode = (Node*)malloc(sizeof(Node));
	newnode->data = data;
	newnode->next = list->next;
	list->next = newnode;
	return list;
}

//遍历链表
void listnode(Node* list)
{
	Node* p = list->next;
	while (p != NULL)
	{
		printf("%d ", p->data);
		p = p->next;
	}
	printf("\n");
}

//找尾结点上一个节点地址
Node* findtail(Node* list)
{
	Node* p=list;
	while (p->next != NULL)
	{
		p = p->next;
	}
	return p;
}

//尾插法
Node* tailinsert(int data, Node* tail)
{
	Node* newnode = (Node*)malloc(sizeof(Node));
	newnode->data = data;
	tail->next = newnode;
	newnode->next = NULL;
	return newnode;
}

//指定位置插入
Node* insertNode(Node* head, int pos, int data) {
	Node* newNode = (Node*)malloc(sizeof(Node));
	newNode->data = data;
	if (pos == 1) {
		newNode->next = head->next;
                head->next=newNode;
		return head;
	}
	Node* p = head;
	for (int i = 0; i < pos - 1 && p != NULL; i++) {
		p = p->next;
	}
	if (p == NULL) {
		printf("插入位置不合法\n");
		free(newNode);
		return head;
	}
	newNode->next = p->next;
	p->next = newNode;
	return head;
}

//删除指定数值的节点
  Node* deleteNode(Node* head, int val)
  {
	Node* v = NULL;
	Node* p = head;
	while (p != NULL && p->data != val)
	{
		v = p;
		p = p->next;
	}
	if (p == NULL) {
		printf("未找到要删除的节点\n");
		return head;
	}
	if (v == NULL) {
		head = p->next;
	}
	else {
		v->next = p->next;
	}
	free(p);
	return head;
}

int main()
{
	Node* list = initlist();
	list = headinsert(60, list);
	listnode(list);
	//获取尾结点前一个节点地址
	Node* tail = findtail(list);
	Node* sign= tailinsert(50, tail);
	printf("%d\n", sign->data);
	listnode(list);
	list=insertNode(list, 2, 40);
	listnode(list);
	list = deleteNode(list, 40);
	listnode(list);
	return 0;
}

Koarz

Future
malloc 出的变量没全部 free 内存泄漏

RiVER

#include<iostream>
using namespace std;
typedef struct LNode{
	int date;
	struct LNode* next;
}LNode,*LinkList;
bool Initlist(LinkList& L){//初始化函数
	L = new LNode;
	if (L == NULL)
		return false;
	L->next = NULL;
	return true;
}
bool empty(LinkList& L)//判断链表是否为空
{
	if (L->next == NULL) return true;
	else return false;
}
bool ListInsert(LinkList& L, int i, int e) {//插入函数
	if (i < 1)
		return false;
	LNode* p = L;
	int j = 0;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL)
		return false;
	LNode* s = new LNode;
	s->date = e;
	s->next = p->next;
	p->next = s;
	return true;
}
bool InsertNextNode(LNode* p, int e) {//指定节点后插
	if (p == NULL)
		return false;
	LNode* s = new LNode;
	if (s == NULL)
		return false;
	s->date = e;
	s->next = p->next;
	p->next = s;
}
bool InsertPriorNode(LNode* p, int e) {//指定节点前插
	if (p == NULL)
		return false;
	LNode* s = new LNode;
	if (s == NULL)
		return false;
	s->next = p->next;
	p->next = s;
	s->date = p->date;
	p->date = e;
	return true;
}
bool ListDelete(LinkList& L, int i) {//删除操作
	if (L == NULL)
		return false;
	LNode* p = L;
	int j = 0;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	if (p == NULL)
		return false;
	LNode* q = p->next;
	p->next = q->next;
	delete q;
	return true;
}
bool DeleteNode(LNode* p) {//删除指定节点(不可删除最后一个节点)
	if (p == NULL)
		return false;
	LNode* q = p->next;
	p->date = q->date;
	p->next = q->next;
	delete q;
	return true;
}
bool Delete_back(LinkList& L)
{
	LNode* p = L;
	while (p->next->next != NULL)
	{
		p = p->next;
	}
	if (p == NULL)
		return false;
	p->next = NULL;
	return true;
}
LNode* GetElem(LinkList& L, int i) {//按位查找
	if (i < 0)
		return NULL;
	LNode* p = L;
	int j = 0;
	while (p != NULL && j < i - 1) {
		p = p->next;
		j++;
	}
	return p;
}
LNode* LocateElem(LinkList& L, int e) {//按值查找
	LNode* p = L->next;
	while (p != NULL && p->date != e) {
		p = p->next;
	}
	return p;
}
int length(LinkList& L) {//求表长
	int len = 0;
	LNode* p = L;
	while (p->next != NULL) {
		p = p->next;
		len++;
	}
	return len;
}
int main()
{
	LinkList L;
	Initlist(L);
	ListInsert(L, 1, 2);
	ListInsert(L, 1, 3);
	ListInsert(L, 1, 4);
	InsertNextNode(L->next, 0);
	InsertPriorNode(L->next, 99);
	ListDelete(L, 5);
	DeleteNode(L->next);
	LNode* arr = L->next;
	
	while (arr != NULL) {
		cout << arr->date << " ";
		arr = arr->next;
	}
	return 0;
}

Godwit

#include<iostream>
using namespace std;


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

void init(Node* head);//初始化
bool isempty(Node* head);//判断是否为空
void show(Node* head);//正序打印
void rshow(Node* head);//逆序打印
void insert_front(Node* head, int n);//在前面插入数据n
void insert_behind(Node* head, int n);//在后面插入数据n
void dele(Node* head, int n);//删除数据n

int main() {
	Node* head = (Node*)malloc(sizeof(Node));
	init(head);
	cout << (isempty(head)) << endl;
	cout << endl;
	for (int i = 0; i < 10; i++)
		insert_behind(head, i);
	insert_behind(head, 0);
	dele(head, 0);
	show(head);
	return 0;
}

void init(Node* head) {
	head->data = 0;
	head->last = head;
	head->next = head;
}
bool isempty(Node* head) {
	bool flag = 1;
	if (head->next != head) flag = 0;
	return flag;
}
void show(Node* head) {
	Node* p = head;
	while (p->next != head) {
		p = p->next;
		cout << p->data << endl;
	}
}
void rshow(Node* head) {
	Node* p = head;
	while (p->last != head) {
		p = p->last;
		cout << p->data << endl;
	}
}
void insert_front(Node* head, int n) {
	Node* temp = (Node*)malloc(sizeof(Node));
	temp->data = n;
	temp->last = head;
	temp->next = head->next;
	head->next = temp;
	temp->next->last = temp;
}
void insert_behind(Node* head, int n) {
	Node* temp = (Node*)malloc(sizeof(Node));
	temp->data = n;
	temp->next = head;
	temp->last = head->last;
	head->last = temp;
	temp->last->next = temp;
}
void dele(Node* head, int n) {
	Node* p = head;
	while (p->next != head) {
		p = p->next;
		if (p->data == n) {
			p->last->next = p->next;
			p->next->last = p->last;
			free(p);
			break;
		}
	}
}

Cu_Sugar

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

typedef struct linkedlist
{
    int value;
    struct linkedlist *next;
} linkedlist;

linkedlist *list_create(int n)
{
    linkedlist *head, *node, *end;
    head = (linkedlist *)malloc(sizeof(linkedlist));
    head->value = n;
    head->next = NULL;
    end = head;
    for (int i = 0; i < n; i++)
    {
        node = (linkedlist *)malloc(sizeof(linkedlist));
        scanf("%d", &node->value);
        node->next = NULL;
        end->next = node;
        end = node;
    }

    return head;
}

void printlist(linkedlist *list) //打印链表
{
    linkedlist *temp = list;
    temp = list->next;
    while (temp != NULL)
    {
        printf("%d=>", temp->value);
        temp = temp->next;
    }
    printf("NULL");
}

void endadd(linkedlist *list, int data) //尾插
{
    linkedlist *node, *end;
    node = (linkedlist *)malloc(sizeof(linkedlist));
    node->next = NULL;
    node->value = data;
    end = list;
    while (end->next != NULL) //找到最后一个节点
    {
        end = end->next;
    }
    end->next = node;
}

void headadd(linkedlist *list, int data) //头插
{
    linkedlist *node;
    node = (linkedlist *)malloc(sizeof(linkedlist));
    node->value = data;
    node->next = list->next;    //将node替换为第一个节点
    list->next = node; 
}


int main()
{
    int chioce, amount, data;
    linkedlist *list = NULL;
    while (1)   
    {
        printf("链表\n1.创建链表\n2.头插\n3.尾插\n");
        printf("当前链表:");
        if (list == NULL)
        {
            printf("NULL\n");
        }else
        {
            printlist(list);
            printf("\n");
        }
        printf("选择:");
        scanf("%d", &chioce);
        switch (chioce)
        {
        case 1:
            printf("节点数：");
            scanf("%d", &amount);
            printf("数据：");
            list = list_create(amount);
            break;
        
        case 2:
            printf("插入的数据：");
            scanf("%d", &data);
            headadd(list, data);
            break;
        
        case 3:
            printf("插入的数据：");
            scanf("%d", &data);
            endadd(list, data);
            break;
        default:
            break;
        }
        printf("\n");
    }
    return 0;
}

发表情包召唤

#include <stdlib.h>
typedef struct student {
    int num;
    char name[20];
    int score;
    struct student* next;
} STU;

// 创建链表
STU* link_creat(STU* head, STU* p_new) {
    if (head == NULL) {
        p_new->next = NULL;
        return p_new; // 返回新的头节点
    } else {
        STU* p_mov = head;
        while (p_mov->next != NULL) {
            p_mov = p_mov->next;
        }
        p_mov->next = p_new;
        p_new->next = NULL;
    }
    return head; // 返回旧的头节点
}

void link_print(STU* head) {
    STU* p_mov = head;
    while (p_mov != NULL) {
        printf("num=%d,name:%s,score=%d\n", p_mov->num, p_mov->name, p_mov->score);
        p_mov = p_mov->next;
    }
}

// 查找学号
STU* link_find_num(STU* head, int num) {
    STU* p_mov = head;
    while (p_mov != NULL) {
        if (p_mov->num == num)
            return p_mov;
        p_mov = p_mov->next;
    }
    return NULL;
}

// 查找姓名
STU* link_find_name(STU* head, const char* name) {
    STU* p_mov = head;
    while (p_mov != NULL) {
        if (strcmp(p_mov->name, name) == 0)
            return p_mov;
        p_mov = p_mov->next;
    }
    return NULL;
}

// 删除节点
STU* link_delete(STU* head, int num) {
    if (head == NULL) {
        printf("链表为空\n");
        return head;
    }

    STU* pb = head;
    STU* pf = NULL;

    // 如果要删除的是头节点
    if (pb->num == num) {
        head = pb->next;
        free(pb);
        return head;
    }

    // 寻找要删除的节点
    while (pb != NULL && pb->num != num) {
        pf = pb;
        pb = pb->next;
    }

    if (pb != NULL) { // 找到节点
        pf->next = pb->next;
        free(pb);
    } else {
        printf("没找到要删除的节点\n");
    }

    return head;
}

// 插入新节点
STU* link_insert(STU* head, STU* p_new) {
    if (head == NULL || p_new->num < head->num) {
        p_new->next = head;
        return p_new; // 新的头节点
    }

    STU* pb = head;
    STU* pf = NULL;

    while (pb != NULL && p_new->num >= pb->num) {
        pf = pb;
        pb = pb->next;
    }

    p_new->next = pb;
    if (pf != NULL) {
        pf->next = p_new;
    }

    return head; // 返回旧的头节点
}

int main() {
    int number;
    scanf("%d", &number);

    STU* head = NULL;

    for (int i = 0; i < number; i++) {
        STU* p_new = (STU*)malloc(sizeof(STU));
        scanf("%d %s %d", &p_new->num, p_new->name, &p_new->score);
        head = link_creat(head, p_new); // 更新头指针
    }

    // 示例：打印链表
    link_print(head);

    // 示例：查找并打印特定学号的学生信息
    int search_num;
    scanf("%d", &search_num);
    STU* found = link_find_num(head, search_num);
    if (found) {
        printf("Found student: num=%d, name=%s, score=%d\n", found->num, found->name, found->score);
    } else {
        printf("Student not found.\n");
    }

    // 示例：删除特定学号的学生信息
    int delete_num;
    scanf("%d", &delete_num);
    head = link_delete(head, delete_num); // 更新头指针

    // 示例：插入新学生信息
    STU* new_student = (STU*)malloc(sizeof(STU));
    scanf("%d %s %d", &new_student->num, new_student->name, &new_student->score);
    head = link_insert(head, new_student); // 更新头指针

    // 最后打印链表查看结果
    link_print(head);

  

    return 0;
}```