单链表的基本操作(建立.遍历.添加.删除)

有n个元素,我们把他们用链表表示,执行一些操作在某个位置添加一个数,或者删除某个位置的数;

输入合法的代码:

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
using namespace std;
struct node
{
    int date;
    struct node *next;
};

node *CreatList(node *head, int n);
void TravList(node *head);
node *AddList(node *head, int n, int pos, int num);
node *DelList(node *head, int n, int pos);

int main()
{
    int n, pos, num;
    node *head;
    while(scanf("%d", &n)!=EOF)
    {
        head = (node*)malloc(sizeof(node));

        head = CreatList(head, n);
        TravList(head);

        scanf("%d %d",&pos, &num);///在第pos个位置插入num;
        head = AddList(head, n+1, pos, num);
        TravList(head);

        scanf("%d", &pos);///删除第pos个位置的数;
        head = DelList(head, n+1, pos);
        TravList(head);

    }
    return 0;
}
node *CreatList(node *head, int n)
{
    head->next = NULL;
    for(int i=1; i<=n; i++)
    {
        node *p;
        p = (node *)malloc(sizeof(node));
        scanf("%d", &p->date);
        p->next = head->next;
        head->next = p;
    }
    return head;
}
void TravList(node *head)
{
    node *real;
    real = head->next;
    while(real != NULL)
    {
        printf("%d ", real->date);
        real = real->next;
    }
    printf("\n");
}
node *AddList(node *head, int n, int pos, int num)
{
    node *pre, *p, *q;
    pre = head;
    p = pre->next;
    int i=1;
    while(i<pos)
    {
        pre = p;
        p = p->next;
        i++;
    }
    q = (node*)malloc(sizeof(node));
    q->date = num;
    q->next = pre->next;
    pre->next = q;
    return head;
}
node *DelList(node *head, int n, int pos)
{
    node *pre, *p;
    pre = head;
    p = pre->next;
    int i=1;
    while(i<pos)
    {
        pre = p;
        p = p->next;
        i++;
    }
    pre->next = p->next;
    free(p);
    return head;
}
/*
5
1 2 3 4 5
3 10
1

5 4 3 2 1
5 4 10 3 2 1
4 10 3 2 1
*/

对所有输入都可以的代码:

#include<stdio.h>
#include<stdlib.h>
#define OK 1
#define ERROR 0
typedef int Status;

typedef struct Lnode
{
    int data;
    struct Lnode *next;
} Lnode,*Linklist;

int m=sizeof(Lnode);

Linklist Creatlist(int n);
Linklist CreatlistRear(int n);
void Trealist(Linklist L);
Status Listdel(Linklist L,int k);
Status ListAdd(Linklist L,int num,int x);

Linklist Creatlist(int n)///从表的前面插入;
{
    Linklist head,p;
    int i;
    head=(Linklist)malloc(m);
    head->next=NULL;
    for(i=1;i<=n;i++)
    {
        p=(Linklist)malloc(m);
        scanf("%d",&p->data);
        p->next=head->next;
        head->next=p;
    }
    return head;
}

Linklist CreatlistRear(int n)///从表的后面插入;
{
    Linklist rear,p,head;
    int i;
    head=(Linklist)malloc(m);
    head->next=NULL;
    rear=head;
    for(i=0;i<n;i++)
    {
        p=(Linklist)malloc(m);
        scanf("%d",&p->data);
        rear->next=p;
        rear=p;
    }
    rear->next=NULL;
    return head;
}

void Trealist(Linklist L)///遍历单链表;
{
    Linklist p;
    p=L->next;
    while(p)
    {
        printf("%d ",p->data);
        p=p->next;
    }
    printf("\n");
}
Status Listdel(Linklist L,int k)///删除单链表的元素;
{
    int j=1;
    Linklist p=L,q=L->next;
    while(q&&j<k)
    {
        p=q;
        q=q->next;
        j++;
    }
    if((q==0 && j<=k) || k<1 )
        return ERROR;
    p->next=q->next;
    free(q);
    return OK;
}
Status ListAdd(Linklist L,int num,int x)///添加单链表的元素;
{
    Linklist p,q,s;
    p=L;
    q=p->next;
    int j=1;
    while(q&&j<x)
    {
        p=q;
        q=q->next;
        j++;
    }
    if((q==0&&j<x)||x<1)
        return ERROR;
    s=(Linklist)malloc(m);
    s->data=num;
    s->next=p->next;
    p->next=s;
    return OK;
}

int main()
{
    int n,k,num,x;
    while(scanf("%d",&n)!=EOF)
    {
        Linklist L;
        //L=Creatlist(n);
        L=CreatlistRear(n);//两种建立链表的方法;
        Trealist(L);
        printf("请输入要删除的位置\n");
        scanf("%d",&k);
        int m=Listdel(L,k);
        if(m==1)
            printf("删除成功\n");
        else
            printf("删除失败\n");
        Trealist(L);
        printf("请输入要插入的数和位置\n");
        scanf("%d %d",&num,&x);
        m=ListAdd(L,num,x);
        if(m==1)
            printf("插入成功\n");
        else
            printf("插入失败\n");
        Trealist(L);
    }
    return 0;
}

时间: 2024-10-22 00:21:44

单链表的基本操作(建立.遍历.添加.删除)的相关文章

「C语言」单链表/双向链表的建立/遍历/插入/删除

最近临近期末的C语言课程设计比平时练习作业一下难了不止一个档次,第一次接触到了C语言的框架开发,了解了View(界面层).Service(业务逻辑层).Persistence(持久化层)的分离和耦合,一种面向过程的MVC的感觉. 而这一切的基础就在于对链表的创建.删除.输出.写入文件.从文件读出...... 本篇文章在于巩固链表的基础知识(整理自<C语言程序设计教程--人民邮电出版社>第十章),只对链表的概念及增删改查作出探讨,欢迎指教. 一.链表结构和静态/动态链表 二.单链表的建立与遍历

单链表的基本操作(创建,删除,插入,逆置)

代码鲁棒性较差,之后补充注释以及减少BUG增加可读性. #include <iostream> #include <vector> #include <cstring> #include <malloc.h> using namespace std ; typedef struct Node{ int data ; struct Node *next ; }node , *Lnode ; int Linklist_length( node *head ){

用Java实现单链表的基本操作

笔试题中经常遇到单链表的考题,下面用java总结一下单链表的基本操作,包括添加删除节点,以及链表转置. package mars; //单链表添加,删除节点 public class ListNode { private Node head; public ListNode(){ head=null; } //在链表前添加节点 public void addpre(int dvalue){ Node n=new Node(dvalue); if(head==null){ head=n; }els

单链表的基本操作实现

1.写这篇博文的原因 C语言有三个重要部分:流程控制.函数.指针. 对于指针,单单了解它的简单运用是远远不够的,最重要的是学习链表.所以这篇文章通过用C语言实现链表的一些基本操作和总结,希望对C语言的指针有更新的理解和认识. 2.单链表的定义 单链表是通过一组任意的存储单元来存储线性表中的数据元素,这些存储单元可以是连续的也可以是不连续的.为了建立起数据元素之间的关系,对于每个数据元素除了存放元素自身的信息外,还必须有包含指向该元素直接后继元素位置的信息,这两部分信息组成一个节点,即每个节点都有

C语言实现单链表的基本操作及其部分面试题

//单链表的基本数据类型及其结构 typedef int DataType; typedef struct LinkNode { DataType data; struct LinkNode *next; }LinkNode,*pLinkNode,*pLinkList; //单链表的初始化 void InitLinkList(pLinkList* pHead)//初始化 { assert(pHead); *pHead = NULL; } //当尾插,头插,插入时都需要建立一个新的结点,为方便建立

数据结构:链表的基本操作(创建,删除,插入,逆序,摧毁)

代码注释比较详细: #include <iostream> #include <cstdlib> using namespace std; struct Node{ int data; Node* next; }; Node* head = NULL; bool create() { head = (Node*)malloc(sizeof(Node)); if(NULL == head) return false; head->data = 0; head->next

链表(二)——单向链表的基本操作(创建、删除、打印、结点个数统计)

1.指针的联动 通过两个指针分别指向前驱和后继结点,并在单向链表上进行移动,当指针指向待处理的结点时,该结点的前驱也有指针指向. 2.设有一个无序单向链表,且数据域的值均不相同,使指针pmin指向最小值结点,并使指针prem指向最小值结点的前驱结点: 代码片段: for(p = head; p; q = p, p = p->next) { if(pmin->data > p->data) { pmin = p; prem = q; } } 3.单向链表的删除算法 注:使用mallo

单链表的创建,插入,删除,遍历

1 #include<stdio.h> 2 #include<iostream> 3 #include<malloc.h> 4 #define OK 1 5 #define ERROR 0 6 using namespace std; 7 typedef struct LNode 8 { 9 int data; 10 struct LNode *next; 11 } LNode,*LinkList; 12 13 void Init(LinkList &L)///

《实验课---单链表的基本操作》

//线性表---链表的基本操作#include<stdio.h>#include<stdlib.h>#include<conio.h>#define TRUE 1#define FALSE 0#define OK 1#define ERROR 0#define INFEASIBLE -1#define NULL 0typedef int Status; //函数结果状态代码typedef int ElemType; //数据元素类型//------线性表的单链表存储结构