C单链表操作

  头指针存放链表元素数量,头节点开始存放数据,尾节点指向NULL

  list.h

#ifndef _LIST_H
#define _LIST_H
#include <stdio.h>
#include <stdlib.h>
#define DEBUG 0

typedef struct node{
    int val;
    struct node *next;
}Node;

Node * l_malloc();        // 分配内存
Node * init();            // 初始化
void show(Node *list);    // 显示链表元素
int lsearch_pos(Node *list,int n);    // 左搜索
int rsearch_pos(Node *list,int n);    // 右搜索
int find_val(Node *list,int val);    // 值搜索
Node * insert(Node *list,int pos,int n);    // 插入节点
Node * del_node(Node *list,int n);            // 指定位置删除节点
Node * del_val(Node *list,int val);        // 指定值删除节点

#endif

  list.c

#include "list.h"

/*************************************
 * 分配内存,当失败时重新尝试1次
 *************************************/
Node * l_malloc(){
    Node *p = NULL;
    int cnt = 3;
    do{
        p = (Node *)malloc( sizeof(Node) );
    }while( NULL == p && --cnt);  // 当失败时重新尝试
    if( 0 > cnt ){
        perror("malloc");
        exit(-1);                  // 内存分配失败,退出
    }
    return p;
}
/*************************************
 * 初始化
 *************************************/
Node * init(){
    const int num = 8;
    int cnt = 0;
    Node *head = NULL;
    Node *pcur = NULL;
    Node *pnew = l_malloc();

    head = pcur = pnew;            //
    head->val = 0;                // 头指针,值记录链表元素数量
    for( ; cnt < num; cnt++ ){
        pnew = l_malloc();
        pnew->val = cnt;
        pcur->next = pnew;
        pcur = pnew;
        head->val++;
    }
    pcur->next = NULL;
    return head;
}
/*************************************
 * 显示
 *************************************/
void show(Node *list){
    while( NULL != list ){
        printf("%d->",list->val);
        list = list->next;
    }
    printf("end\n\n");
}
/*************************************
 * 从左开始搜索
 *************************************/
int lsearch_pos(Node *list,int n){
    if( n < 1 || n > list->val ){        // 超出链表值数量
        printf("exceed length of list\n");
        return -1;
    }
    for( int cnt = 0; cnt < n ; cnt++ ){
        list = list->next;
    }
    return list->val;
}
/*************************************
 * 从右开始搜索
 *************************************/
int rsearch_pos(Node *list,int n){
    if( n < 1 || n > list->val ){
        printf("exceed length of list\n");
        return -1;
    }
    Node *pcur = list->next;        // 定义2个指针:当前位置
    Node *ptag = list->next;        // 目标位置
    for( int cnt = 0; cnt < n ; cnt++ ){
        pcur = pcur->next;
    }                                // 使当前位置与目标位置间隔 n
    while( NULL != pcur ){            // 当前位置先移动到表尾,此时 ptag 即为要搜索的位置
        pcur = pcur->next;            // 同时移动2个指针
        ptag = ptag->next;            //
    }
    return ptag->val;
}
/*************************************
 * 从左开始搜索指定值
 * 有值返回位置,无值返回-1
 *************************************/
int find_val(Node *list,int val){
    if( DEBUG ) printf("in find_val:\n");
    int cnt = 1;
    int len = list->val;
    for( ; cnt <= len; cnt++ ){
        list = list->next;
        if( DEBUG ) printf("    list->val:%d\n",list->val);
        if( val == list->val ){
            return cnt;
        }
    }
    return -1;
}
/*************************************
 * 指定位置插入新值
 *************************************/
Node * insert(Node *list,int pos,int n){
    if( DEBUG ) printf("in insert:\n");
    Node *pcur = list;
    Node *pnew = l_malloc();
    pnew->val = n;
    for( int cnt = 1; cnt < pos && pcur->next ; cnt++ ){    // 到达指定位置或链表尾时退出
        pcur = pcur->next;
        if( DEBUG ) printf("    pcur->val:%d\n",pcur->val);
    }
    if( NULL == pcur->next ){    // 到达链表尾部,测试空链表或负数运行正常化
        pnew->next = NULL;        // 当pos大于链表长度时,插入表尾
        pcur->next = pnew;
    }
    else{
        pnew->next = pcur->next;
        pcur->next = pnew;
    }
    list->val++;
    return list;
}
/*************************************
 * 指定位置删除值
 *************************************/
Node * del_node(Node *list,int n){
    if( n < 1 || n > list->val ){
        printf("exceed length of list\n");
        return list;
    }
    Node *pcur = NULL;
    Node *ptag = list;
    for( int cnt = 0; cnt < n ; cnt++ ){
        pcur = ptag;
        ptag = ptag->next;
    }
    pcur->next = ptag->next;
    free(ptag);
    list->val--;
    return list;
}
/*************************************
 * 指定值删除节点
 *************************************/
Node * del_val(Node *list,int val){
    int n = find_val(list,val);
    if( -1 == n ){        // 无指定值,不删除
        return list;
    }
    return del_node(list,n);
}

  main.c

#include "list.h"

int main(){
    Node *list = init();
    show(list);
    int num = lsearch_pos( list, 2 );
    printf("the 2th value is %d\n",num);
    show(list);

    num = rsearch_pos( list, 2 );
    printf("the value from right 2th is %d\n",num);
    show(list);

    num = find_val( list, 5 );
    printf("the value 5 is in %dth\n",num);
    show(list);
    list = del_node( list, 1 );
        printf("after delete 1th value,the list is:\n");
        show(list);

    list = del_val( list, 3 );
        printf("after delete value 3,the list is:\n");
        show(list);

    list = del_val( list, 100 );
        printf("after delete value 100,the list is:\n");
        show(list);
    for( int cnt = 10;cnt > 0;cnt -- ){
        list = del_node( list, cnt );
        printf("after delete %dth value,the list is:\n",cnt);
        show(list);
    }
    for( int cnt = 0;cnt <20 ;cnt ++ ){
        list = insert( list, cnt % 5 ,rand() );
        printf("after insert a value at %dth,the list is:\n",cnt);
        show(list);
    }
    list = insert( list, 6 ,99 );
    printf("after insert a value at 6th,the list is:\n");
    show(list);

    list = insert( list, -6 ,99 );
    printf("after insert a value at -6th,the list is:\n");
    show(list);
}
时间: 2024-10-05 05:40:22

C单链表操作的相关文章

数据结构上机测试2-1:单链表操作A (顺序建表+关键字删除)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

单链表操作

#include<stdio.h>#include<malloc.h> typedef struct Node{ int data; struct Node *next;}LinkList; //就地反转int LinkListRerverse(LinkList *head){ LinkList *q,*p; p = head->next; head->next = NULL; while(p != NULL){ q = p->next; p->next =

单链表操作系列

#include<stdio.h> #include<stdlib.h> typedef int ElemType; //定义结点类型 typedef struct Node { ElemType data; struct Node *next; }LNode,*LinkList; //单链表的建立1,头插法建立单链表,逆序生成 LinkList LinkListCreateH() { LinkList L,p; L = (LinkList)malloc(sizeof(LNode)

数据结构之 线性表---单链表操作A (删除链表中的指定元素)

数据结构上机测试2-1:单链表操作A Time Limit: 1000MS Memory limit: 4096K 题目描述 输入n个整数,先按照数据输入的顺序建立一个带头结点的单链表,再输入一个数据m,将单链表中的值为m的结点全部删除.分别输出建立的初始单链表和完成删除后的单链表. 输入 第一行输入数据个数n: 第二行依次输入n个整数: 第三行输入欲删除数据m. 输出 第一行输出原始单链表的长度: 第二行依次输出原始单链表的数据: 第三行输出完成删除后的单链表长度: 第四行依次输出完成删除后的

10、单链表操作

单链表操作 单链表操作1 /*单链表的类型定义*/ typedef int DataType; typedef struct node { DataType data; struct node * next; }LinkNode, *LinkList; /*单链表的定位运算*/ LinkNode *Locate(LinkNode *L, int k)//????为什么此处是LinkNode *Locate()类型,表示什么意思 { LinkNode *p; int i; i= 1; p = L-

循环单链表操作(转)

循环单链表的初始化,建立,插入,查找,删除. 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 //////////////////////////////////////////////// //循环单链表的初始化,建立,插入,查找,删除.// //Autho

单链表操作实例程序

#include <iostream> #include <iomanip> using namespace std; typedef struct node { int val; node *next; }node; node * create_list(); void traverse_list(node *pHead); int get_len_list(node *pHead); bool delete_list(node *pHead,int pos,int &v

单链表操作问题,主要是逆操作

工作无事,搞其它事也不太方便,写点简单代码.本来想写的高大上一些,发现用范型不是一点代码的事,还是算了. #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct list { int val; struct list *next; }Node_def; #define NODE_SIZE (sizeof(Node_def)) #undef T #define T Node_def

数据结构之---c语言实现循环单链表操作

//=========杨鑫========================// //循环单链表的实现 #include <stdio.h> #include <stdlib.h> typedef int ElemType; //定义结点类型 typedef struct Node { ElemType data; struct Node *next; }Node,*LinkedList; int count = 0; //1.单循环链表的初始化 LinkedList init_ci

单链表操作(数据结构实验一)

 实验内容 1 初始化一个带表头结点的单链表. 2 从表头不断插入结点建立一个带表头结点的单链表.设表中元素的类型为整型,元素值从键盘输入. 3 从表尾不断插入结点建立一个带表头结点的单链表.设表中元素的类型为整型,元素值从键盘输入. 4 打印一个带表头结点的单链表. 5 清空一个带表头结点的单链表. 代码:(只是把各个函数写好,并给出了调用数据,其他根据实验要求改就行了) #include<stdio.h> #include<stdlib.h> #include<mallo