数据结构学习总结(2) 线性表之单链表

#include<stdlib.h>
#include<stdio.h>
//定义链表结构
typedef struct link {
    int elem;//数据域
    link *next;//指针域，指向直接后继元素
}link;//link为节点名，每个节点都是一个link结构体

//初始化无头节点链表函数
link* initNoToplink();
//创建有头节点的初始化链表
link * initlink();
//用于输出链表函数无头节点
void display(link *p);

void havadisplay(link *p);
int main() {
    //初始化链表{1,2,3,4}
    printf("初始化链表为无头节点：\n");
    link *p = initNoToplink();
    display(p);
    printf("初始化链表为有头节点：\n");
    p = initlink();
    havadisplay(p);

    return 0;
}
void havadisplay(link *p) {
    link* temp = p;//将temp指针重新指向头结点
                   //只要temp指针指向的结点的next不是Null，就执行输出语句。
    while (temp->next) {
        temp = temp->next;
        printf("%d ", temp->elem);
    }
    printf("\n");
}

//无头节点遍历链表
void display(link *p) {
    link *temp = p;//将temp指针重新指向头节点
    //判断只要temp指针指向的节点next不是null,就执行输出语句
    while (temp) {
        printf("%d ",temp->elem);
        temp = temp->next;
    }
    printf("\n");
}
//有头节点初始化
link * initlink() {
    link * p = (link*)malloc(sizeof(link));//创建一个头结点
    link * temp = p;//声明一个指针指向头结点，
                    //生成链表
    for (int i = 1; i<5; i++) {
        link *a = (link*)malloc(sizeof(link));
        a->elem = i;
        a->next = NULL;
        temp->next = a;
        temp = temp->next;
    }
    return p;
}
//无头节点初始化
link *initNoToplink() {
    link *p=NULL;//创建头指针
    link *temp = (link*)malloc(sizeof(link));//创建首元节点
    //初始化首元节点
    temp->elem = 1;
    temp->next = NULL;
    p = temp;//头指针指向首元节点
    //从第二个节点开始创建
    for (int i = 2; i < 5;i++) {
        link *a = (link*)malloc(sizeof(link));//创建一个新的节点并初始化
        a->elem = i;
        a->next = NULL;
        temp->next = a;//将temp节点与新建立的a节点建立逻辑关系
        //指针temp每次指向新链表的最后一个节点，其实就是a节点，这里temp=a;也对
        temp = temp->next;
    }
    return p;
}

#include<stdio.h>
#include<stdlib.h>
//声明节点结构
typedef struct Link {
    int elem;//存储整型元素
    struct Link *next;//指向直接后继元素的指针
}Link;

//创建一个带头结点的函数
Link* initLink() {
    Link *p = (Link*)malloc(sizeof(Link));//创建一个头节点
    Link *temp = p;//声明一个指针指向头节点，用于遍历链表
    //生成链表
    for (int i = 1; i < 5;i++) {
        //创建节点并初始化
        Link* a = (Link*)malloc(sizeof(Link));
        a->elem = i;
        a->next = NULL;
        //建立新节点与直接前驱节点的关系
        temp->next = a;
        //指针temp每次都指向新链表的最后一个节点，其实就是 a节点，这里写temp=a也对
        temp = temp->next;
    }
    return p;
}
//插入元素
//p为原链表，elem为插入的新数据元素 add为插入节点的位置
Link* InsertLink(Link *p,int elem,int add) {
    Link* temp = p;//创建临时节点temp
    //首先找到要插入位置的上一个节点
    for (int i = 1; i < add;i++) {
        if (temp==NULL) {
            printf("插入位置无效\n");
            return p;
        }
        temp = temp->next;
    }
    //创建插入的节点C
    Link *c = (Link*)malloc(sizeof(Link));
    c->elem = elem;
    //向链表中插入节点
    c->next = temp->next;//先断后
    temp->next = c;//再断前
    return p;
}

//链表的删除
//p为原链表，add为要删除链表的值
Link* delLink(Link *p,int add) {
    Link* temp = p;//创建一个临时节点
    //temp指向被删除节点的上一个节点
    for (int i = 1; i < add;i++) {
        temp = temp->next;
    }
    Link *del = temp->next;//单独设置一个指针指向被删除节点，以防丢失
    temp->next = temp->next->next;//删除某个节点的方法是更改前一个节点的指针域
    free(del);//手动释放该节点防止内存泄漏
    return p;
}

//链表查找
//p为原链表，elem表示被查找元素
int selectElem(Link* p,int elem) {
     //新建一个临时指针,初始化为头指针p
    Link* t = p;
    int i = 1;
    //由于头节点的存在，因此while中的判断为t->next;
    while (t->next) {
        t = t->next;
        if (t->elem==elem) {
            return i;
        }
        i++;
    }
    //程序执行至此，表示查找失败
    printf("查找元素不存在");
    return -1;
}
//更新链表
//p表示原链表，add更改节点在链表中的位置，newElem为新的元素
Link* updataLink(Link* p,int add,int newElem) {
    Link* temp = p;//建立临时节点
    //遍历之前，temp指向首元节点
    temp = temp->next;
    //遍历到被删除的节点
    for (int i = 1; i < add;i++) {
        temp = temp->next;
    }
    temp->elem = newElem;
    return p;
}
//遍历有头节点的链表
void display(Link *p) {
    Link* temp = p;//将temp指针重新指向头结点
                   //只要temp指针指向的结点的next不是Null，就执行输出语句。
    while (temp->next) {
        temp = temp->next;
        printf("%d ", temp->elem);
    }
    printf("\n");
}

int main() {
    //初始化链表（1，2，3，4）
    printf("初始化链表为：\n");
    Link *p = initLink();
    display(p);

    printf("在第4的位置插入元素5：\n");
    p = InsertLink(p, 5, 4);
    display(p);

    printf("删除元素3:\n");
    p = delLink(p, 3);
    display(p);

    printf("查找元素2的位置为：\n");
    int address = selectElem(p, 2);
    if (address == -1) {
        printf("没有该元素\n");
    }
    else {
        printf("元素2的位置为：%d \n", address);
    }
    printf("更改第3的位置上的数据为7:\n");
    p = updataLink(p, 3, 7);
    display(p);

    return 0;
}

#include<stdlib.h>
#include<stdio.h>
#define maxSize 6
typedef struct {
    int data;//数据域
    int cur;//指针域
}component;

//将结构体数据中所有分量连接到备用链表
void reserveArr(component* array);
//初始化静态链表
int initArr(component* array);
//输出函数
void displayArr(component*,int body);
//从备用链表上摘下空闲节点的函数
int mallocArr(component* array);
int main() {
    component array[maxSize];
    int body = initArr(array);
    printf("静态链表为：\n");
    displayArr(array, body);
    return 0;
}

//创建备用链表
void reserveArr(component* array) {
    for (int i = 0; i < maxSize;i++) {
        array[i].cur = i + 1;//将每个数组分量链接到一起
    }
    array[maxSize - 1].cur = 0;//链表最后一个节点的游标值为0
}
//提取分配空间
int mallocArr(component* array) {
    //若备用链表非空，则返回分配的节点下标，否则返回0
    //(当分配最后一个节点时，该节点的游标值为0)
    int i = array[0].cur;
    if (array[0].cur) {
        array[0].cur = array[i].cur;
    }
    return i;
}
//初始化静态链表
int initArr(component *array) {
    reserveArr(array);
    int body = mallocArr(array);
    //声明一个变量，把它当指针使，指向链表的最后的一个结点，因为链表为空，所以和头结点重合
    int tempBody = body;
    for (int i = 1; i<4; i++) {
        int j = mallocArr(array);//从备用链表中拿出空闲的分量
        array[tempBody].cur = j;//将申请的空闲分量链接在链表的最后一个结点后面
        array[j].data = i;//给新申请的分量的数据域初始化
        tempBody = j;//将指向链表最后一个结点的指针后移
    }
    array[tempBody].cur = 0;//新的链表最后一个结点的指针设置为0
    return body;
}
void displayArr(component * array, int body) {
    int tempBody = body;//tempBody准备做遍历使用
    while (array[tempBody].cur) {
        printf("%d,%d ", array[tempBody].data, array[tempBody].cur);
        tempBody = array[tempBody].cur;
    }
    printf("%d,%d\n", array[tempBody].data, array[tempBody].cur);
}

#include <stdio.h>
#include <stdlib.h>
typedef struct node{
    int number;
    struct node * next;
}person;
person * initLink(int n){
    person * head=(person*)malloc(sizeof(person));
    head->number=1;
    head->next=NULL;
    person * cyclic=head;
    for (int i=2; i<=n; i++) {
        person * body=(person*)malloc(sizeof(person));
        body->number=i;
        body->next=NULL; 
        cyclic->next=body;
        cyclic=cyclic->next;
    }
    cyclic->next=head;//首尾相连
    return head;
}
void findAndKillK(person * head,int k,int m){
    person * tail=head;
    //找到链表第一个结点的上一个结点，为删除操作做准备
    while (tail->next!=head) {
        tail=tail->next;
    }
    person * p=head;
    //找到编号为k的人
    while (p->number!=k) {
        tail=p;
        p=p->next;
    }
    //从编号为k的人开始，只有符合p->next==p时，说明链表中除了p结点，所有编号都出列了，
    while (p->next!=p) {
        //找到从p报数1开始，报m的人，并且还要知道数m-1de人的位置tail，方便做删除操作。
        for (int i=1; i<m; i++) {
            tail=p;
            p=p->next;
        }
        tail->next=p->next;//从链表上将p结点摘下来
        printf("出列人的编号为:%d\n",p->number);
        free(p);
        p=tail->next;//继续使用p指针指向出列编号的下一个编号，游戏继续
    }
    printf("出列人的编号为:%d\n",p->number);
    free(p);
}
int main() {
    printf("输入圆桌上的人数n:");
    int n;
    scanf("%d",&n);
    person * head=initLink(n);
    printf("从第k人开始报数(k>1且k<%d)：",n);
    int k;
    scanf("%d",&k);
    printf("数到m的人出列：");
    int m;
    scanf("%d",&m);
    findAndKillK(head, k, m);
    return 0;
}