顺序表&&单链表

原创 2017年09月25日 20:47:33

顺序表

顺序表是在计算机内存中以数组的形式保存的线性表,是指用一组地址连续的存储单元依次存储数据元素的线性结构。
顺序表空间是连续的,便于随机访问,在不增容的情况下,尾插的效率高,头插和中间插入不容易实现,增容的代价较高,但其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);    
}

这里写图片描述

版权声明:本文为博主原创文章,未经博主允许不得转载。

链表和顺序表的一些区别

顺序表与链表是非常基本的数据结构,它们可以被统称为线性表。 线性表(Linear List)是由 n(n≥0)个数据元素(结点)a[0],a[1],a[2]…,a[n-1] 组成的有限序列。 ...
  • qq_15037231
  • qq_15037231
  • 2016年07月03日 20:33
  • 3865

【数据结构】链表与顺序表的优缺点,和2道经典的题

这两道题是:1.从尾到头打印单链表。                2.单链表实现约瑟夫环的问题。        首先我们在面试时可能会遇到说明一下顺序表和链表的优缺点,说说他们分别在什么场景下使用:...
  • q1239678315
  • q1239678315
  • 2016年09月26日 18:04
  • 1613

顺序表与链表的比较

在本章介绍了线性表的逻辑结构及它的两种存储结构:顺序表和链表。 通过对它们的讨论可知它们各有优缺点,顺序存储有三个优点: (1) 方法简单,各种高级语言中都有数组,容易实现。 (2) 不用为...
  • u011308691
  • u011308691
  • 2013年11月18日 19:45
  • 997

笔记题

1.以下属于逻辑结构的是() A.顺序表     B.哈希表     C.有序表     D.单链表 答案:C. 数据结构是反映数据的一种形式,它具体分为逻辑结构和物理结构, 1,逻辑结构:它是表...
  • u012507032
  • u012507032
  • 2017年05月17日 15:45
  • 254

循环链表,双链表,顺序表和链表的比较

循环链表:在单链表中,如果将终端结点的指针域由空指针改为指向头结点,就使得整个单链表形成一个环,这种头尾相接的单链表称为循环单链表,简称循环链表。 在用头指针指示的循环链表中,找到开始结点的时间是O(...
  • zh23862691
  • zh23862691
  • 2013年10月03日 09:38
  • 1193

【数据结构】顺序表、单链表、循环链表的插入与删除

写在前面的 顺序表 插入 删除 定位 单链表 插入 删除 双向循环链表 删除 插入 总结写在前面的       在复习数据结构的过程中对于链表的操作总是容易忘记,时不时的就不知道具体的该怎么操作了,所...
  • SugaryoTT
  • SugaryoTT
  • 2016年09月19日 23:05
  • 1288

链表:顺序链表和单链表

在学习线性表之前,必须要清楚“顺序存储的线性表”和“链式存储的线性表”。 (1)顺序存储线性表         1、采用数组来存储顺序线性表的各元素。         2、基本结构: #define...
  • look122333
  • look122333
  • 2013年10月27日 20:09
  • 2354

顺序表和链表存储的优缺点

顺序表和链表存储的优缺点 1.顺序表存储      原理:顺序表存储是将数据元素放到一块连续的内存存储空间,存取效率高,速度快。但是不可以动态增加长度      优点:存取速度高效,通过下标来直...
  • u013538542
  • u013538542
  • 2015年08月07日 11:31
  • 5138

《顺序表和单链表的区别及应用场景+单链表经典例题》

前言: 线性表可分为:顺序表与链表。其中,顺序表又可分为动态的和静态的两种,链表可分为单向链表、单向循环链表、双向链表、双向循环链表等。本篇文章主要讲解动态顺序表与单向链表的区别与应用场景以及关...
  • Mr_______zhang
  • Mr_______zhang
  • 2017年06月24日 19:07
  • 1067

线性表之顺序表与单链表的区别及优缺点

这里比较的是基于C语言实现的顺序表与单链表,与其他语言的实现可能会有差异,但我相信语言是相通的,它们的实现机制应该也差不多。 1、What 什么是顺序表和单链表 ①顺序表: 顺序表是在计算机内...
  • ljx_5489464
  • ljx_5489464
  • 2016年03月23日 23:43
  • 11523
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:顺序表&&单链表
举报原因:
原因补充:

(最多只允许输入30个字)