顺序表&&单链表

最新推荐文章于 2022-11-02 16:30:39 发布
最新推荐文章于 2022-11-02 16:30:39 发布
阅读量512 收藏 4
点赞数
分类专栏： c语言 文章标签： 单链表 顺序表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zjx624bjh/article/details/78089291
版权

顺序表

顺序表是在计算机内存中以数组的形式保存的线性表，是指用一组地址连续的存储单元依次存储数据元素的线性结构。
顺序表空间是连续的，便于随机访问，在不增容的情况下，尾插的效率高，头插和中间插入不容易实现，增容的代价较高，但其cpu利用率相比链表较高。

单链表

单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。
一次只开辟一个结点的空间，用来存储当前要保存的数据及指向下一个结点或NULL的指针，所以单链表的空间大小时动态变化的。
链表中的每个节点通过链或指针连接在一起，程序通过指针访问链表中的节点。不支持随机访问。

接下来，我们来了解一些单链表的基本操作！

一，静态顺序表

#include<iostream>
#include<stdio.h>
#include<stdlib.h>
#include<assert.h>
using namespace std;
const int Max = 10;
struct SeqListNode
{
    int data[Max];
    size_t _size;
};
typedef SeqListNode List;
void init(List* head)//初始化顺序表
{
    head->_size = 0;
    memset(head->data,0,Max*sizeof(int));
}
void print(List* head)
{
    assert(head);
    for(size_t i = 0;i<head->_size;i++)
    {
        cout<<head->data[i]<<" ";
    }
    cout<<"\n";
}
int size(List* head)
{
    return head->_size;
}
void pushBack(List* head, int data)
{
    if(head->_size == Max)
        return;
    head->data[head->_size]=data;
    head->_size++;
}
void popBack(List* head)
{
    if(head->_size>0)
    {
        head->_size--;
    }
}
void pushFront(List* head,int data)
{
    if(head->_size == Max)
        return;
    else
    {
        for(int i=head->_size;i>0;i--)
        {
            head->data[i]=head->data[i-1];
        }
        head->data[0] =data;
        head->_size++;
    }
}
void popFront(List* head)
{
    assert(&head);
    if(head->_size = 1)
    {
        head->_size--;
    }
    else
    {
        for(size_t i = 1;i<head->_size;i++)
        {
            head->data[i+1]=head->data[i];
        }
        head->_size--;
    }
}
bool Empty(List* head)
{
    return head->_size == 0;
}
void insert(List* head, int pos, int data)
{
    if(pos<0||pos>=Max)
        return;
    else
    {
        for(int i = head->_size;i>=pos;i--)
        {
            head->data[i+1]=head->data[i];
        }
        head->data[pos]=data;
        head->_size++;;
    }
}
void erase(List* head, int pos)
{
    assert(head);
    if(pos<0 || pos>=Max)
        return;
    else
    {
        for(size_t i = pos;i<head->_size;i++)
        {
            head->data[i]=head->data[i+1];
        }
        head->_size--;
    }
}
int Find(List* head,int data)
{
    assert(head);
    for(size_t i=0;i<head->_size;i++)
    {
        if(head->data[i]==data)
        {
            return i;
        }
    }
}
void remove(List* head,int data)
{
    assert(head);
    for(size_t i = 0;i<head->_size;i++)
    {
        if(head->data[i] == data)
        {
            for(size_t j = i;j<head->_size;j++)
            {
                head->data[j] = head->data[j+1];
            }
            head->_size--;
        }
    }

}

二，单链表

1.单链表的数据结构

#pragma once//防止头文件被重复引用
typedef int DataType;

typedef struct Node//定义结构体
{
    DataType data;//定义数据
    struct Node* next;//指向下一个节点的指针
}Node;

2.建立节点

//建立节点
Node* NewNode(DataType x)
{
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = x;
    node->next = NULL;
    return node;
}

3.打印单链表

void Print(Node* head)
{
    Node* cur = head;
    while(cur)
    {
        printf("%d ",cur->data);
        cur = cur->next;
    }
}

4.在单链表的尾部插入节点
这里写图片描述

void PushBack(Node**head,DataType x)
{
    if(*head == NULL)
    {
        *head = NewNode(x);
    }
    else if((*head)->next == NULL)
    {
        (*head)->next=NewNode(x);
    }
    else
    {
        Node* tail = *head;
        while(tail->next)
        {
            tail = tail->next;
        }
        tail->next=NewNode(x);
    }
}

5.删除一个单链表的尾部节点
这里写图片描述

//尾删
void PopBack(Node**head)
{
    if(*head == NULL)
    {
        printf("The list is empty\n");
        return ;
    }
    else if((*head)->next == NULL)
    {
        free(*head);
        *head=NULL;
    }
    else
    {
        Node* prev = NULL;
        Node* cur = NULL;
        cur =* head;
        while(cur->next)
        {
            prev=cur;
            cur=cur->next;
        }
        free(cur);
        prev->next=NULL;
    }
}

6.在单链表指定位置pos前插入一个节点
这里写图片描述

//pos前面插入一个数
void Insert(Node** head,Node *pos,DataType x)
{
    //assert(pos);
    if(pos == NULL)
    {
        PushFront(head,x);
    }
    else
    {
        Node* tmp = NewNode(x);
        Node* prev = *head;
        while(prev->next!=pos)
        {
            prev = prev->next;
        }
        prev->next = tmp;
        tmp->next = pos;
    }
}

7.删除一个无头单链表的非尾节点
无头单链表不知道头节点的地址，所以找不到要删除节点的位置，换个思路可以将问题转化为：
1>记下要删除节点pos的下一个节点next；
2>将next节点的数据赋给pos节点
3>让pos的下一个节点指向next的下一个节点；
4>最后free掉next即可。
这里写图片描述

void Earse(Node** head,Node *pos)
{
    assert(*head);
    if(*head == NULL)
    {
        printf("The list is empty\n");
        return;
    }
    else if((*head)->next == NULL)
    {
        PopFront(head);
    }
    else 
    {
        Node* cur = *head;
        while(cur->next!=pos)
        {
            cur=cur->next;
        }
        cur->next = pos->next;
        free(pos);
        pos=NULL;
    }
}

完整代码：

#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#include<assert.h>
typedef int DataType;
typedef struct Node
{
    DataType data;
    struct Node* next;
}Node;
//建立节点
Node* NewNode(DataType x)
{
    Node* node = (Node*)malloc(sizeof(Node));
    node->data = x;
    node->next = NULL;
    return node;
}
void Print(Node* head)
{
    Node* cur = head;
    while(cur)
    {
        printf("%d ",cur->data);
        cur = cur->next;
    }
}
//尾插
void PushBack(Node**head,DataType x)
{
    if(*head == NULL)
    {
        *head = NewNode(x);
    }
    else if((*head)->next == NULL)
    {
        (*head)->next=NewNode(x);
    }
    else
    {
        Node* tail = *head;
        while(tail->next)
        {
            tail = tail->next;
        }
        tail->next=NewNode(x);
    }
}
//尾删
void PopBack(Node**head)
{
    if(*head == NULL)
    {
        printf("The list is empty\n");
        return ;
    }
    else if((*head)->next == NULL)
    {
        free(*head);
        *head=NULL;
    }
    else
    {
        Node* prev = NULL;
        Node* cur = NULL;
        cur =* head;
        while(cur->next)
        {
            prev=cur;
            cur=cur->next;
        }
        free(cur);
        prev->next=NULL;
    }
}
//头插
void PushFront(Node** head,DataType x)
{
    if(*head == NULL)
    {
        *head = NewNode(x);
    }
    else
    {
        Node* tmp = NewNode(x);
        tmp->next = *head;
        *head = tmp;
    }
}
//头删
void PopFront(Node** head)
{
    if(*head == NULL)
    {
        printf("The list is empty\n");
        return;
    }
    else if((*head)->next == NULL)
    {
        free(*head);
        *head=NULL;
    }
    else
    {
        Node* next = (*head)->next;
        free(*head);
        *head=next;
    }
}
//查找
Node* Find(Node* head,DataType x)
{

    while(head)
    {
        if(head->data == x)
        {
            return head;
        }
        head = head->next;
    }
    return NULL;
}
//pos前面插入一个数
void Insert(Node** head,Node *pos,DataType x)
{
    //assert(pos);
    if(pos == NULL)
    {
        PushFront(head,x);
    }
    else
    {
        Node* tmp = NewNode(x);
        Node* prev = *head;
        while(prev->next!=pos)
        {
            prev = prev->next;
        }
        prev->next = tmp;
        tmp->next = pos;
    }
}
//删除一个数
void Earse(Node** head,Node *pos)
{
    assert(*head);
    if(*head == NULL)
    {
        printf("The list is empty\n");
        return;
    }
    else if((*head)->next == NULL)
    {
        PopFront(head);
    }
    else 
    {
        Node* cur = *head;
        while(cur->next!=pos)
        {
            cur=cur->next;
        }
        cur->next = pos->next;
        free(pos);
        pos=NULL;
    }
}


int main()
{
    Node* head = NULL;
    Node* pos = Find(head,2);
    PushBack(&head,1);
    PushBack(&head,2);
    PushBack(&head,3);
    Print(head);
    PushBack(&head,4);
    printf("\n");
    printf("尾插:");
    Print(head);

    PushFront(&head,0);
    printf("\n");
    printf("头插:");
    Print(head);

    PopBack(&head);
    printf("\n");
    printf("尾删:");
    Print(head);

    PopFront(&head);
    printf("\n");
    printf("头删:");
    Print(head);


    pos = Find(head,2);
    Insert(&head,pos,30);
    printf("\n");
    printf("2前面插入30:");
    Print(head);

    pos = Find(head,2);
    Earse(&head,pos);
    printf("\n");
    printf("删除2:");
    Print(head);    
}

这里写图片描述

德卡拉
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构——顺序表/单链表实现
Luria
08-20 639
一、顺序表 // 静态存储 typedef struct SeqList_1 { DataType array[N]; size_t size; }SeqList_1; //动态存储 typedef struct SeqList { DataType *base; size_t size; // 有效数据个数 size_t capacity; //容量大小 }SeqList; 部分接口实现 //初始化 void SeqListInit(SeqList* psl, size_t c.
时间复杂度&&空间复杂度&&顺序表&&链表&&顺序表和链表的区别以及优缺点对比
qq_54626677的博客
08-03 936
顺序表（逻辑结构和物理结构是一致的）- 本质是数组，动态增长，并且要求里面存储的数据必须从左往右是连续的。实际中我们计算时间复杂度时，我们其实并不一定要计算精确的执行次数，而只需要大概执行次数，那么这。空间复杂度 - 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。链表（逻辑结构和物理结构是不一致的）- 空间按需所取，头部空间不需要挪动数据。时间复杂度 - 算法中的基本操作的执行次数，为算法的时间复杂度。总结：这两个数据结构是相辅相成的。里我们使用大O的渐进表示法。...
顺序表+单链表
o f f i c的博客
04-10 790
代码如下； //顺序表基本运算算法 #include #include #include <malloc.h> #define Maxsize 100 using namespace std; typedef int Elemtype; typedef struct { Elemtype data[Maxsize]; int length; } SqList; void Crea...
顺序表和单链表
qq_39234304的博客
12-31 327
建立顺序表和单链表时，需要自己书写库函数文件 类似于SeqList.h 等的“.h" 文件。库函数中的数据变量均为不确定的，这便于今后再调用的时候，根据程序需要另行定义。 在写主程序是，要注意main() 函数前的数据类型定义，库函数引入和变量定义的先后顺序。对于指针，*p输出一定是某变量的值，p=&a ，*p为a的值，p=a; *p 输出为错误。 其他见解已在代码中标出
顺序表与链表（单链表）
qq_64262956的博客
07-23 1109
单链表（初阶数据结构）
数据结构--顺序表和单链表
weixin_46077587的博客
03-12 1937
顺序表的基本操作 //顺序表静态分配内存空间的情况 #include<bits/stdc++.h> using namespace std; const int maxsize = 100; //定义一个顺序表 typedef struct{ int data[maxsize]; int len;//顺序表的长度 }Seqlist; //初始化一个顺序表 bool InitSeqlist(Seqlist &L){ for(int i = 0;i<maxsize;i
利用C++简单实现顺序表和单链表的示例代码
12-26
本文主要给大家介绍了关于C++实现顺序表和单链表的相关内容，分享出来供大家参考学习，话不多说，来一起看看详细的介绍： 一、顺序表示例代码： #include #include using namespace std; typedef int Datatype; ...
数据结构顺序表与单链表课程设计报告.doc
10-06
在这个课程设计报告中，我们将关注两种基本的数据结构：顺序表和单链表。这两种结构都是线性数据结构，它们提供了不同的方式来组织和操纵数据。 顺序表是一种将数据元素存储在内存中连续的位置上的数据结构。这种...
JAVA模拟新增顺序表及单链表
08-18
JAVA模拟新增顺序表及单链表 在计算机科学中，顺序表和单链表是两种基本的数据结构。顺序表是一种数组实现的数据结构，用于存储一系列的数据元素，每个元素都有其索引。单链表是一种链表结构，通过节点来存储数据...
ShiYan1_单链表_C++_顺序表_数据结构_
09-29
1．顺序表的验证 (1）定义一个结构体，描述学生信息。学生信息包括：学号、姓名、性别、班级和电话号码等。用描述学生信息的结构体作为线性表的数据元素类型测试顺序表。 （3）在顺序表类模板中增加成员函数max()和...
将长度为n的顺序表转换为带头结点的单链表，元素位序不变
vener_的博客
09-30 1356
typedef struct { Elemtype data[Max]; int length; }SqList; typedef struct LNode { Elemtype data; struct LNode *next; }LNode,*LinkList; LinkList convert(SqList L) { LinkList A=(LNode*)malloc(sizeof(LNode)); LNode *p,*r=A; for(int i=0;i<n;i++) { .
顺序表的链式实现-单链表
对自己笑
10-16 423
一、线性链表   逻辑上相邻的两个元素在物理存储单元上不一定是不相邻的，这就是链表。 二、单链表具体实现 头文件： #include<stdio.h> #include<stdlib.h> #include<Windows.h> typedef int ElemType; typedef struct LNode{ ElemType data; LNode...
一表读懂顺序表和单链表
qq_42092076的博客
07-25 516
顺序表 单链表 定义 具有相同特性的数据元素的有限序列 线性表的链式存储结构，每个节点都有唯一的前驱节点和唯一的后继节点，用一组任意的存储单元存储线性表的数据元素 优点 ①：存储密度大，无需为线性表之间的逻辑关系而增加额外的存储空间 ②：具有随机存取特性 ①：采用节点的动态分配方式，具有良好的适应性 ②：插入和...
顺序表与链表
最新发布
Djsnxbjans的博客
11-02 1012
顺序表与链表详解
单链表和顺序表的实现
火锅——博客
05-15 385
单链表实现：//函数声明："linklist.h" #define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> #include<stdlib.h> typedef int ElemType; typedef struct linknode { ElemType data; struct linknode *
顺序表和链表02——单链表的实现
m0_61608447的博客
04-30 1012
手写一个单链表--简单的一批
顺序表【使用数组实现单链表】
qq_42803467的博客
08-14 255
import java.util.Arrays; public class MyArrayList { public int[] elem;//数组 public int usedSize;//有效数据的个数 public static final int intCapacity = 10;//初始容量 //构造方法 public MyArrayList(){ this.elem = new int[intCapacity]; thi.
C语言实现顺序表与单链表逆置操作
本资源是一份关于C语言实现顺序表和单链表逆置操作的教学文档。主要关注的是顺序表和单链表这两种基础数据结构在C语言中的实现以及它们的逆置操作。以下是详细的知识点解析： 1. **顺序表（数组实现）**: - 使用...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值