C语言链表相关操作_c语言printlist函数怎么用-CSDN博客

本文链接：https://blog.csdn.net/qq_39120955/article/details/121912286

文中涵盖了链表几乎所有的操作，代码中的注释详细，可直接运行，粘贴在编译器中研究更好！

申明结构体

#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
    int data;                                           //数据域
    struct Node *next;                                  //指针域
}Node,*List;                                            //List代表链表，Node代表一个结点

创建结点

Node* CreateNode(int data){     //创建结点
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    return node;
}

链表初始化

List Init(){           //初始化链表
    return CreateNode(0); //头指针
}

打印链表

void PrintList(List L){
    Node* p = L->next;
    while (p != NULL){
        printf("%d ",p->data);
        p = p -> next;
    }
    printf("\n");
}

尾插法插入一个元素

void InsertByTail(List L,int data){
    Node *p, *node = CreateNode(data); //创建新结点
    p = L;
    node->data = data;
    node->next = NULL;
    while (p->next) //找到最后一个结点
    {
        // p++; 千万不要写p++啊，害死人不偿命！！！
        p = p -> next;
    }
    p->next = node;
}

头插法插入一个元素

void InsertByHead(List L,int data){  //头插法
    Node *node = CreateNode(data);  //创建结点
    node->next = L->next;
    L->next = node;
}

按照下标插入一个元素

void InsertByIndex(List L,int data,int index){
    Node* p = FindByIndex(L,index);
    //创建结点
    Node* node = CreateNode(data);
    //开始插入
    node->next = p->next;
    p->next = node;
}

通过下标删除元素

void DeleteNodeByIndex(List L,int index){
    Node *temp;
    Node* p = FindByIndex(L,index); //找到index的前一个结点
    if(index > ListSize(L) || index < 1){  //下标有误
        return ;
    }
    // 删除结点
    temp = p->next;
    p->next = p->next->next;
    free(temp);
}

通过下标查询元素

int SelectByIndex(List L,int index){
    Node* p = FindByIndex(L,index);
    return p->next->data;
}

通过下标更改元素

void UpdateByIndex(List L,int data,int index){
    Node* p = FindByIndex(L,index);
    p->next->data = data;
}

统计有多少个元素，不包含头结点

int ListSize(List L){
    int i = 0;
    Node* p = L->next;
    while (p != NULL){
        i++;
        p = p-> next;
    }
    return i;
}

找到下标前的一个元素，返回其地址

Node* FindByIndex(List L,int index){
    int i;
    Node* p = L;
    for (i = 1; i < index; i++) { //找到index的前一个结点
        p = p -> next;
    }
    return p;
}

逆序输出链表

List ReversePrintList(List L){
    //顺序输出很简单，逆序输出可以用递归
    if(L == NULL) return NULL;
    ReversePrintList(L->next);
    printf("%d ",L->data);
}

反转链表

List ReverseList(List L){
    List now = Init();  //创建一个链表
    Node* p = L->next;
    while (p!=NULL){ //遍历L链表
        InsertByHead(now,p->data);  //用头插法插入新链表
        p = p->next;
    }
    return now;
}

合成两个有序链表（type1升序，type0降序）

List LinkTwoListByOrder(List L1,List L2,int type){
    int index = 0,i,j,temp,a[ListSize(L1)+ ListSize(L2)];
    List L = Init();
    Node *p1 = L1 -> next,*p2 = L2 -> next;
    // 将两个链表的数据放到数组中
    while (p1!=NULL){
        a[index] = p1->data;
        p1 = p1->next;
        index++;
    }
    while (p2!=NULL){
        a[index] = p2->data;
        p2 = p2->next;
        index++;
    }
    //对数组进行升序排序
    if(type == 1){
        for(i=0;i<index;i++){
            for(j=0;j<index-i-1;j++){
                if(a[j] > a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }else if(type == 0){ //降序
        for(i=0;i<index;i++){
            for(j=0;j<index-i-1;j++){
                if(a[j] < a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }
    //将数组转到链表中
    p1 = L;
    for(i=0;i<index;i++) {
        //新建节点
        Node* node = CreateNode(a[i]);
        p1 -> next = node;
        p1 = node;
    }
    return L;
}

创建对应大小的链表，size不包含头结点

List CreateListBySize(int size){
    int i;
    List L = Init();
    for (i=0;i<size;i++){
        InsertByHead(L,0);
    }
    return L;
}

删除一个链表的尾节点

void DeleteByHead(List L){
    Node* temp = L->next;
    L->next = temp -> next;
    free(temp);
}

删除一个链表的第一个节点（不是删除头结点）

void DeleteByTail(List L){
    Node* p = L->next,*temp;
    while (p->next->next != NULL) { //找到尾节点的前一个结点
        p = p->next;
    }
    //开始删除结点
    temp = p->next;
    p -> next = NULL;
    free(temp);
}

按照值删除所有节点

void DeleteByValue(List L,int value){
    Node *p = L, *temp,*pre;
    while (p != NULL){
        if(p->data == value){  //找到要删除的元素结点
            //利用前一个节点删除该结点
            temp = p;
            pre -> next = p -> next;
            p = pre -> next;
            free(temp);
            continue;
        }
        pre = p;
        p = p->next;
    }
}

查找倒数第i个结点，只能遍历一次

int SelectByIndexReverse(List L,int index){
    Node *slow = L, *fast = L;
    int i;
    for(i=1;i<index;i++){  //快指针向后移动index位
        fast = fast->next;
    }
    while (fast->next != NULL){   //快指针移动到最后一位的时候，慢指针刚好在倒数第index位置
        fast = fast->next;
        slow = slow->next;
    }
    return slow->data;
}

删除倒数第i个结点，只能遍历一次

void DeleteByIndexReverse(List L,int index){
    Node *slow = L, *fast = L,*temp;
    int i;
    for(i=0;i<index;i++){  //快指针向后移动index+1位
        fast = fast->next;
    }
    while (fast->next != NULL){   //快指针移动到最后一位的时候，慢指针刚好在倒数第index的前一个位置
        fast = fast->next;
        slow = slow->next;
    }
    //删除结点
    temp = slow->next;
    slow->next = slow->next->next;
    free(temp);
}

所有代码，包括main函数中的测试方法，复制粘贴可直接运行

#include <stdio.h>
#include <stdlib.h>
typedef struct Node{
    int data;                                           //数据域
    struct Node *next;                                  //指针域
}Node,*List;                                            //List代表链表，Node代表一个结点

/*******************************************************************************
 *                                  方法定义区                                   *
 *******************************************************************************/
Node* CreateNode(int data);                             //创建结点
List Init();                                            //链表初始化
void InsertByTail(List L,int data);                     //尾插法插入一个元素
void InsertByHead(List L,int data);                     //头插法插入一个元素
void InsertByIndex(List L,int data,int index);          //按照下标插入一个元素
void PrintList(List L);                                 //打印链表
void DeleteNodeByIndex(List L,int index);               //通过下标删除元素
int SelectByIndex(List L,int index);                    //通过下标查询元素
void UpdateByIndex(List L,int data,int index);          //通过下标更改元素
int ListSize(List L);                                   //统计有多少个元素，不包含头结点
Node* FindByIndex(List L,int index);                    //找到下标前的一个元素，返回其地址
List ReversePrintList(List L);                          //逆序输出链表
List ReverseList(List L);                               //反转链表
List LinkTwoListByOrder(List L1,List L2,int type);      //合成两个有序链表（type1升序，type0降序）
List CreateListBySize(int size);                        //创建对应大小的链表，size不包含头结点
void DeleteByHead(List L);                              //删除一个链表的尾节点
void DeleteByTail(List L);                              //删除一个链表的第一个节点（不是删除头结点）
void DeleteByValue(List L,int value);                   //按照值删除所有节点
int SelectByIndexReverse(List L,int index);             //查找倒数第i个结点，只能遍历一次
void DeleteByIndexReverse(List L,int index);            //删除倒数第i个结点，只能遍历一次
int main(){
    List L = Init();  //初始化
    int i,index,num;
    //创建一个链表，元素为 1 2 3 4 5 6 7 8 9 10

    for(i=1;i<10;i=i+2){
        InsertByTail(L,i);
        //InsertByHead(L,i);
    }
    InsertByTail(L,9);

    printf("原来的链表为：");
    PrintList(L);  //打印

//    //按下标删除
//    printf("请输入要删除第几个元素:\n");
//    scanf("%d",&index);
//    DeleteNodeByIndex(L,index);
//    printf("删除第%d个元素后为：",index);
//    PrintList(L);  //打印
//
//    //按下标插入
//    printf("请输入要插入的下标:\n");
//    scanf("%d",&index);
//    printf("请输入要插入的数据:\n");
//    scanf("%d",&num);
//    InsertByIndex(L,num,index);
//    printf("在第%d个位置插入%d后为：\n",index,num);
//    PrintList(L);  //打印
//
//    //按下标查找
//    printf("请输入要查找的下标:\n");
//    scanf("%d",&index);
//    printf("%d对应的数据为：%d\n",index,SelectByIndex(L,index));
//
//    //按下标更新
//    printf("请输入要更新的下标:\n");
//    scanf("%d",&index);
//    printf("请输入要更新的值:\n");
//    scanf("%d",&num);
//    UpdateByIndex(L,num,index);
//    printf("更新后的数据为：\n");
//    PrintList(L);
//
//    //逆序输出
//    printf("逆序输出后为：\n");
//    ReversePrintList(L->next);
//
//    //逆转链表
//    List new = ReverseList(L);
//    printf("逆转后为：");
//    PrintList(new);
//
//    //两表连接
//    List L2 = Init();
//    for(i=2;i<7;i=i+2){
//        InsertByTail(L2,i);
//    }
//    printf("链表L2:");
//    PrintList(L2);
//    List L3 = LinkTwoListByOrder(L,L2,0);
//    printf("合并后链表L3:");
//    PrintList(L3);

//    //头删法
//    DeleteByHead(L);
//    printf("删除之后的链表为：");
//    PrintList(L);
//
//    //尾删法
//    DeleteByTail(L);
//    printf("删除之后的链表为：");
//    PrintList(L);
//
//    //按照元素值删除
//    DeleteByValue(L,9);
//    printf("删除之后的链表为：");
//    PrintList(L);

//    //查找第倒数多少位
//    index = 2;
//    int n = SelectByIndexReverse(L,index);
//    printf("倒数第%d位是：%d\n",index,n);
//    return 0;

    //删除第倒数多少位
    index = 4;
    DeleteByIndexReverse(L,index);
    printf("删除倒数第%d位后：",index);
    PrintList(L);
    return 0;

}
void InsertByTail(List L,int data){
    Node *p, *node = CreateNode(data); //创建新结点
    p = L;
    node->data = data;
    node->next = NULL;
    while (p->next) //找到最后一个结点
    {
        // p++; 千万不要写p++啊，害死人不偿命！！！
        p = p -> next;
    }
    p->next = node;
}
Node* CreateNode(int data){     //创建结点
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = data;
    return node;
}
List Init(){           //初始化链表
    return CreateNode(0); //头指针
}
void PrintList(List L){
    Node* p = L->next;
    while (p != NULL){
        printf("%d ",p->data);
        p = p -> next;
    }
    printf("\n");
}
void InsertByHead(List L,int data){  //头插法
    Node *node = CreateNode(data);  //创建结点
    node->next = L->next;
    L->next = node;
}
void DeleteNodeByIndex(List L,int index){
    Node *temp;
    Node* p = FindByIndex(L,index); //找到index的前一个结点
    if(index > ListSize(L) || index < 1){  //下标有误
        return ;
    }
    // 删除结点
    temp = p->next;
    p->next = p->next->next;
    free(temp);
}
int ListSize(List L){
    int i = 0;
    Node* p = L->next;
    while (p != NULL){
        i++;
        p = p-> next;
    }
    return i;
}
Node* FindByIndex(List L,int index){
    int i;
    Node* p = L;
    for (i = 1; i < index; i++) { //找到index的前一个结点
        p = p -> next;
    }
    return p;
}
void InsertByIndex(List L,int data,int index){
    Node* p = FindByIndex(L,index);
    //创建结点
    Node* node = CreateNode(data);
    //开始插入
    node->next = p->next;
    p->next = node;
}
int SelectByIndex(List L,int index){
    Node* p = FindByIndex(L,index);
    return p->next->data;
}
void UpdateByIndex(List L,int data,int index){
    Node* p = FindByIndex(L,index);
    p->next->data = data;
}
List ReversePrintList(List L){
    //顺序输出很简单，逆序输出可以用递归
    if(L == NULL) return NULL;
    ReversePrintList(L->next);
    printf("%d ",L->data);
}
List ReverseList(List L){
    List now = Init();  //创建一个链表
    Node* p = L->next;
    while (p!=NULL){ //遍历L链表
        InsertByHead(now,p->data);  //用头插法插入新链表
        p = p->next;
    }
    return now;
}
List LinkTwoListByOrder(List L1,List L2,int type){
    int index = 0,i,j,temp,a[ListSize(L1)+ ListSize(L2)];
    List L = Init();
    Node *p1 = L1 -> next,*p2 = L2 -> next;
    // 将两个链表的数据放到数组中
    while (p1!=NULL){
        a[index] = p1->data;
        p1 = p1->next;
        index++;
    }
    while (p2!=NULL){
        a[index] = p2->data;
        p2 = p2->next;
        index++;
    }
    //对数组进行升序排序
    if(type == 1){
        for(i=0;i<index;i++){
            for(j=0;j<index-i-1;j++){
                if(a[j] > a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }else if(type == 0){ //降序
        for(i=0;i<index;i++){
            for(j=0;j<index-i-1;j++){
                if(a[j] < a[j+1]){
                    temp = a[j];
                    a[j] = a[j+1];
                    a[j+1] = temp;
                }
            }
        }
    }
    //将数组转到链表中
    p1 = L;
    for(i=0;i<index;i++) {
        //新建节点
        Node* node = CreateNode(a[i]);
        p1 -> next = node;
        p1 = node;
    }
    return L;
}
List CreateListBySize(int size){
    int i;
    List L = Init();
    for (i=0;i<size;i++){
        InsertByHead(L,0);
    }
    return L;
}
void DeleteByHead(List L){
    Node* temp = L->next;
    L->next = temp -> next;
    free(temp);
}
void DeleteByTail(List L){
    Node* p = L->next,*temp;
    while (p->next->next != NULL) { //找到尾节点的前一个结点
        p = p->next;
    }
    //开始删除结点
    temp = p->next;
    p -> next = NULL;
    free(temp);
}
void DeleteByValue(List L,int value){
    Node *p = L, *temp,*pre;
    while (p != NULL){
        if(p->data == value){  //找到要删除的元素结点
            //利用前一个节点删除该结点
            temp = p;
            pre -> next = p -> next;
            p = pre -> next;
            free(temp);
            continue;
        }
        pre = p;
        p = p->next;
    }
}
int SelectByIndexReverse(List L,int index){
    Node *slow = L, *fast = L;
    int i;
    for(i=1;i<index;i++){  //快指针向后移动index位
        fast = fast->next;
    }
    while (fast->next != NULL){   //快指针移动到最后一位的时候，慢指针刚好在倒数第index位置
        fast = fast->next;
        slow = slow->next;
    }
    return slow->data;
}
void DeleteByIndexReverse(List L,int index){
    Node *slow = L, *fast = L,*temp;
    int i;
    for(i=0;i<index;i++){  //快指针向后移动index+1位
        fast = fast->next;
    }
    while (fast->next != NULL){   //快指针移动到最后一位的时候，慢指针刚好在倒数第index的前一个位置
        fast = fast->next;
        slow = slow->next;
    }
    //删除结点
    temp = slow->next;
    slow->next = slow->next->next;
    free(temp);
}