【数据结构】第二章 线性表

最新推荐文章于 2020-07-07 22:26:03 发布
最新推荐文章于 2020-07-07 22:26:03 发布
阅读量330 收藏
点赞数
分类专栏： 数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43923155/article/details/103842227
版权

1.线性表的定义和特点

  • 存在唯一一个“第一个”元素
  • 存在唯一一个“最后一个”元素
  • 除第一个元素外，每一个元素都有且只有一个直接前驱
  • 除最后一个元素外，每个元素都有且只有一个直接后继

2.线性表的顺序表示

3.线性表的链式表示

4.实验报告

（1） 编程实现顺序表的基本操作（建立、插入、删除、输出、顺序查找、折半查找、排序等），并设计一个菜单调用。

com_def.h

#include <stdio.h> 
#include <iostream>
#include <iomanip>
#include <string.h>
#include <malloc.h>
#include <process.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
typedef int Status;

sqlist_def.h

#define LIST_INIT_SIZE 100//线性表存储空间的初始分配量
#define LISTINCREMENT 10//线性表存储空间的分配增量
typedef int ElemType;
typedef struct{
 ElemType *elem; //存储空间的首地址
 int length; //当前长度 
 int listsize; //当前分配的存储容量 
}Sqlist;

sqlist_func.h

#include "com_def.h"
using namespace std;
Status InitList_Sq(Sqlist &L);
Status ListInsert_Sq(Sqlist &L,int i,ElemType e);
Status Show(Sqlist L);
Status GetElem(Sqlist L, int i,ElemType &e);
Status LocateElem(Sqlist L, ElemType e);
Status BubbleSort(Sqlist L);
Status Binary_Search(Sqlist &L, int &i,ElemType e);

Status InitList_Sq(Sqlist &L){
 //构造一个空的线性表
 int n,i;
 L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));
 if(!L.elem) exit(OVERFLOW);  //存储分配失败
 cout<<endl<<"请输入元素个数：";
 cin>>n;
 cout<<"请输入这"<<n<<"个元素:"<<endl;
 for(i=0;i<n;i++){
  cin>>L.elem[i];
 }
 
 L.length=n;//空表长度为 0 
 L.listsize=LIST_INIT_SIZE;//初始存储容量
 return OK; 
}
Status ListInsert_Sq(Sqlist &L,int i,ElemType e){
 //在顺序线性表L中第i个位置之前插入新的元素e
 //i的合法值为1<=i<=ListLength_sq(L)+1
 ElemType *p;
 if(i<1||i>L.length+1) return ERROR;//i值不合法
 if(L.length>=L.listsize){
  //当前存储空间已满，请重新分配内存
  ElemType *newbase=(ElemType*)realloc(L.elem,(L.listsize+LISTINCREMENT)*sizeof(ElemType));
  if(!newbase) exit(OVERFLOW);//存储分配失败 
  L.elem=newbase;//新的首地址 
  L.listsize+=LISTINCREMENT;//增加存储容量 
 }
 ElemType *q=&(L.elem[i-1]);//q为插入位置的地址 
 for(p=&(L.elem[L.length-1]);p>=q;--p){
  *(p+1)=*p;//插入位置及之后的元素右移  
 } 
 *p=e;//插入e
 ++L.length;//表长增加1
 return OK;
  
}

Status ListDelete_Sq(Sqlist &L,int i,ElemType &e){
 //在顺序线性表L中删除第i个元素，并用e值返回
 //i的合法值为1<=i<=ListLength_Sq(L)
 ElemType *p,*q;
 if(i<1||i>L.length) return ERROR;//i的值不合法
 p=&(L.elem[i-1]);//p为删除元素的位置
 e=*p;//被删除的元素的值赋给e
 q=L.elem+L.length-1;//表尾元素的位置
 for(++p;p<=q;++p){
  //被删除元素之后的元素左移 
  *(p-1)=*p; 
 } 
 --L.length;//表长减一 
 return OK; 
  
}

Status Show(Sqlist L)
{
 int i;
 cout<<"此时表中现有的元素为：\n";
 for(i=0;i<L.length;i++)
 {
  cout<<L.elem[i]<<endl;
 }
}

Status GetElem(Sqlist L, int i,ElemType &e)
{
 
 if(i<1||i>L.length) return ERROR;
 e=L.elem[i-1];
 return OK; 
}

Status LocateElem(Sqlist L, ElemType e){
 int i;
 ElemType *p;
 i=1;
 p=L.elem;
 while(i<=L.length&&*p!=e){
  ++i;
  p++;
 }
 if(i<=L.length) return i;
 else return 0;
}

Status BubbleSort(Sqlist L){
 //冒泡排序 
 int i,j;
 ElemType temp;
 for(i=0;i<L.length;i++)
 {
  for(j=1;j<L.length-i;j++)
  {
   if(L.elem[j-1]>L.elem[j])
   {
    temp=L.elem[j];
    L.elem[j]=L.elem[j-1];
    L.elem[j-1]=temp;
   }
  }  
 }
}

Status Binary_Search(Sqlist &L, int &i,ElemType e){
 //折半查找法 
 BubbleSort(L);
    int low=0,high=L.length-1,mid;     //置当前查找区间上、下界的初值
    while(low<=high)
    {
        if(L.elem[low]==e)
            i= low;
        if(L.elem[high]==e)
            i= high;          
        mid=low+((high-low)/2);
            /*使用(low+high)/2会有整数溢出的问题
            （问题会出现在当low+high的结果大于表达式结果类型所能表示的最大值时，
              这样，产生溢出后再/2是不会产生正确结果的，而low+((high-low)/2)
              不存在这个问题*/
        if(L.elem[mid]==e)
          i= mid;             //查找成功返回
        if(L.elem[mid]<e)
          low=mid+1;              
        else
          high=mid-1;             
    }
    if(low>high)
        return ERROR;//当low>high时表示所查找区间内没有结果，查找失败
}

Status QucikSort(Sqlist &L){
 int i, j,key;      /*定义变量为基本整型*/
    i = start;         /*将每组首个元素赋给i*/
    j = end;     /*将每组末尾元素赋给j*/
    key = L.elem[start];   /*设置基准值*/
    while (i < j)
    {
        while (i < j && key< L.elem[j])
            j--;    /*位置左移*/
        if (i < j)
        {
            L.elem[i] = L.elem[j];  /*将s[j]放到s[i]的位置上*/
            i++;     /*位置右移*/
        }
        while (i < j && L.elem[i] <= L.elem[0])
            i++;    /*位置右移*/
        if (i < j)
        {
            L.elem[j] = L.elem[i];  /*将大于基准值的s[j]放到s[i]位置*/
            j--;    /*位置右移*/
        }
    }
    L.elem[i] = key;    /*将基准值放入指定位置*/
    if (start < i)
        QucikSort(L, start, j - 1);/*对分割出的部分递归调用函数qusort()*/
    if (i < end)
       QucikSort(L, j + 1, end); 
}

main.cpp

#include "com_def.h"
#include "sqlist_def.h"
#include "sqlist_func.h"
using namespace std;
//1,6,8
int main(){
 Sqlist L;
 InitList_Sq(L); 
 //cout<<L.length<<endl; 
 int i,n;
 ElemType e;
 int choice=0;
 do{
  cout<<"***********************"<<endl;
  cout<<"* 1.插入元素          *\n";
  cout<<"* 2.删除元素          *\n";
  cout<<"* 3.输出元素          *\n";
  cout<<"* 4.按位置查找元素    *\n";
  cout<<"* 5.按值查找元素      *\n";
  cout<<"* 6.折半查找元素      *\n";
  cout<<"* 7.线性表冒泡排序    *\n";
  cout<<"* 8.线性表快速排序    *\n";
  cout<<"* 0.退出              *\n";
  cout<<"***********************"<<endl;
  cout<<"请输入你的选择:";
  cin>>choice;  
  switch(choice)
  {
   case 1:
    {
     cout<<"请输入插入位置和插入的数值"<<endl;
     cin>>i>>e;
     if(ListInsert_Sq(L,i,e)==OK)
     {
        cout<<"插入成功!"<<endl<<endl;
        Show(L);
     }
     else{
      cout<<"插入失败!"<<endl<<endl;
      Show(L);
     }
     break; 
    }
   case 2:
    {
     cout<<"请输入删除位置"<<endl;
     cin>>i;
     if(ListDelete_Sq(L, i, e))
     {
     cout<<"删除成功"<<endl;
     }
     else
     {
     cout<<"删除失败"<<endl;
     }
     cout<<"删除位置的值为"<<e<<endl;
     break;
    }
   case 3:
    {
     Show(L);
     break;
    }
   case 4:
    {
     cout<<"请输入查找的位置:";
     cin>>i;
     if(GetElem(L, i, e))
     {
      cout<<"查找成功!"<<endl;
      cout<<"查找位置的值为:"<<e<<endl;
     }
     else
     {
      cout<<"查找失败!"<<endl;
     }
     
     break; 
     } 
    case 5:
     {
      cout<<"请输入查找的值:";
     cin>>e;
     if(LocateElem(L, e))
     {
      cout<<"查找成功!"<<endl;
     }
     else
     {
      cout<<"查找失败!"<<endl;
     }
     cout<<"查找值的位置为:"<<i+1<<endl;
     break;
     }
   case 6:
    {
     cout<<"升幂排序"<<endl;
     BubbleSort(L);
     Show(L);
        cout<<"请输入查找数值:";
     cin>>e;
     if(!Binary_Search(L, i, e))
     {
     cout<<"查找成功"<<endl;
     }
     else
     {
     cout<<"查找失败"<<endl;
     }
     cout<<"查找数值的位置为:"<<i+1<<endl;
     break;
    }
   case 7:
    {
     cout<<"冒泡排序："<<endl;
     BubbleSort(L);
     Show(L);
     break;
    }
   case 8:
    {
     cout<<"快速排序："<<endl;
     QucikSort(L);
     Show(L);
     break;
    }             
  }//switch后 
 }while(choice!=0) ;
}

（2） 编程实现单链表的基本操作（建立、插入、删除、求表长、顺序查找、逆置、有序表的合并等），并设计一个菜单调用。

com_def.h

#include <stdio.h> 
#include <iostream>
#include <iomanip>
#include <string.h>
#include <malloc.h>
#include <process.h>
#define OK 1
#define ERROR 0
#define TRUE 1
#define FALSE 0
#define OVERFLOW -1
typedef int Status;

linklist_def.h

typedef int ElemType;
typedef struct LNode{
 ElemType data;
 struct LNode *next;
}LNode,*LinkList;

linklist_func.h

#include "com_def.h"
using namespace std;
 /*初始化空表*/
Status Init_Linklist(LinkList &L)
{   
 int i,n;
 LinkList p,q;//p是指向第i个元素的指针 
    L=(LinkList)malloc(sizeof(LNode));
    if(!L) exit(OVERFLOW);
    L->next=NULL;// 空链表 
    q=L;//q为尾指针
 cout<<"利用尾插法开始建立链表！"<<endl; 
    cout<<endl<<"请输入元素的个数：";
 cin>>n;
 cout<<"输入 "<<n<<" 个元素:"<<endl; 
 for(i=1;i<=n;i++){
  p=(LinkList)malloc(sizeof(LNode));
  if(!p) exit(OVERFLOW);
  cin>>p->data;//元素的值存入链表 
  q->next=p;//下一个元素的地址赋给上一个元素的指针起到链接的作用 
  q=p;//再把p的地址赋给q 
 } 
 q->next=NULL;//创建链表完成 尾指针指空 
    return OK;
}
void OutputLinklist(LinkList &L){
 LinkList p;
 p=L->next;
 while(p){
  cout<<p->data;
  p=p->next;
 }
 cout<<endl; 
}
Status GetElem(LinkList &L,int i,ElemType &e){
 int j=1;
 LinkList p=L->next;
 while(p&&j<i)
 {
  p=p->next;
  j++;
 }
 if(!p||j>i) return ERROR;
 e=p->data;
 return OK;
}
Status Insert_Linklist(LinkList &L,int i,ElemType e){
 LinkList p,s;//s指向i-1个结点 
 int j=0;//j计数 
 p=L;//p为尾节点 
 while(p&&j<i-1)
 {
  p=p->next;
  ++j;//寻找第i-1个结点 
 }
 if(!p||j>i+1) return ERROR;
 s=(LinkList)malloc(sizeof(LNode));//生成新的结点 
 s->data=e;
 s->next=p->next;//插入L中 
 p->next=s;
 return OK;
}
Status ListDelete_L(LinkList &L,int i,ElemType &e){
 //在带头节点的单链线性表L中，删除第i个元素，并由e返回其值
 LinkList p,q;
 p=L;
 int j=0;
 while(p->next&&j<i-1)
 { //寻找第i个结点，并令p指向其前驱 
  p=p->next;
  ++j;
  } 
 if(!(p->next)||j>i-1) return ERROR;//删除位置不合理
 q=p->next;//q指向第i个结点 
 p->next=q->next;//令第i-1的结点直接与第i+1结点相连 
 e=q->data;
 free(q);
 return OK;  
}
void Length_Linklist(LinkList L){
 //求链表的长度 
 int num=0;
 LinkList p;
 p=L->next;
 while(p)
 {
  num++;
  p=p->next;
 }
 cout<<"链表的长度为："<<num; 
}
void Inverse_Linklist(LinkList &L){
 LinkList p,q,r;
 if(!L->next||!L->next->next) return ;//链表为空，或者只有一个结点 
 p=NULL;//新建只有头结点的链表
 q=L->next;//指向当前需逆置链表的第一个结点 
 while(q)
 {
  r=q->next;//先保存下一个结点的位置 
  q->next=p;//存到新的链表
  p=q;   
  q=r;
  } 
 L->next=p;//把旧链表的头结点指向新的尾 
}
//void MergeList_L(LinkList &La,LinkList &Lb,LinkList &Lc){
// //已知单链线性表La和Lb的元素按值非递减排列
// //归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列
// LinkList pa,pb,r;
// pa=La->next;
// pb=Lb->next;
// Lc=pc=La;
// while(pa&&pb){
//  if(pa->data<=pb->data){
//   pc->next=pa;
//   pc=pa;
//   pa=pa->next;
//  }
// } 
//}

void menu(){
  cout<<endl;
     cout<<"*********************************"<<endl;
  cout<<"* 1.创建单链表                  *\n";
  cout<<"* 2.显示单链表                  *\n";
  cout<<"* 3.查找元素                    *\n";
  cout<<"* 4.插入元素（尾插法）          *\n";
  cout<<"* 5.删除元素                    *\n";
  cout<<"* 6.单链表的长度                *\n";
  cout<<"* 7.逆置                        *\n";
  //cout<<"* 8.有序表的合并                *\n";
  cout<<"* 0.退出                        *\n";
  cout<<"*********************************"<<endl;
  cout<<endl;
}

main.h

#include "com_def.h"
#include "linklist_def.h"
#include "linklist_func.h"
#include "menu.h"
using namespace std;
int main(){
 LinkList L;
 int choice=0;
 int i,n;
 ElemType e; 
 do{
  menu();
  cout<<"请输入你的选择:";
  cin>>choice;  
  switch(choice)
  {
   case 1:
    {
     if(Init_Linklist(L))
     {
      cout<<"单链表创建成功\n";
                  cout<<"链表为："<<endl;
                  OutputLinklist(L);
     }                 
              else
              {
               cout<<"单链表创建失败\n";
     }                 
              break;
    }
   case 2:
    {
     OutputLinklist(L);
     cout<<endl;
     break; 
    }
   case 3:
    {
     cout<<"请输入查找的位置:";
     cin>>i;
     if(GetElem(L, i, e))
     {
      cout<<"查找成功!"<<endl;
      cout<<"查找位置的值为:"<<e<<endl;
     }
     else
     {
      cout<<"查找失败!"<<endl;
     }     
     break;
    }
   case 4:
    {
     cout<<"请输入插入的位置:";
     cin>>i;
     cout<<"请输入插入的元素值:";
     cin>>e;
     if(Insert_Linklist(L, i, e))
     {
      cout<<"插入成功!\n";
                  cout<<"插入后的链表为："<<endl;
                  OutputLinklist(L);
     }                
              else
              {
               cout<<"插入失败!\n";
     }                
              break;
    }
   case 5:
    {
     cout<<"请输入要删除的位置:";
     cin>>i;       
     if(ListDelete_L(L, i, e))
     {
      cout<<"删除成功!\n";
      cout<<"删除元素的值为："<<e<<endl; 
                  cout<<"删除后的链表为："<<endl;
                  OutputLinklist(L);
     }                 
              else
              {
               cout<<"删除失败!\n";
     }                
              break;
    }
   case 6:
    {
     Length_Linklist(L);
     cout<<endl;
     break; 
    }
   case 7:
    {
     cout<<"逆置后的链表为："<<endl; 
     Inverse_Linklist(L);
     OutputLinklist(L);
     cout<<endl;
     break;
    }          
  }
 }while(choice!=0); 
}

在这里插入图片描述

Meranchine.
关注
专栏目录
第二章 数据结构-线性表
qq_45604925的博客
10-08 689
注：这是本人观看B站王卓老师讲的数据结构与算法的学习笔记
数据结构知识点——第二章线性表
lthahaha的博客
03-16 222
1.线性结构的特点： 在数据元素的非空有限集中，存在惟一的一个被称为“第一个”的数据元素；存在惟一的一个被称做“最后一个”的数据元素；除第一个之外，集合中的每个数据元素均只有一个前驱；除最后一个之外，集合中每一个数据元素均只有一个后继。 ...
数据结构——栈与队列
强川川的博客
07-07 445
栈 是一种仅限定在表尾进行插入或删除操作的线性表。 表尾→栈顶 表头→栈底 不含元素为空栈 栈为 LIFO 结构线性表（后进先出）。 基本操作 InitStack(&S)：构造一个空栈 DestroyStack(&S)：若栈S已存在，则将其销毁 ClearStack(&S)：若栈S已存在，则将S清为空栈 StackEmpty(S)：若S为空栈，返回TRUE，否则返回FALSE StackLength(S)：返回栈S的元素个数，即栈的长度
数据结构_线性表
YIU
10-12 463
  原文地址 （作者也是我本人） 如果你是为了完成老师的作业，建议不要照抄照搬，自己敲。 线性表的顺序表示和实现  #include &lt;iostream&gt; #include &lt;cstring&gt; #include &lt;string&gt; #include &lt;cstdio&gt; #include &lt;algorithm&gt; #include &l...
单链表的建立、查找、删除、插入
10-29
单链表的头插入、尾插入、以及查找、删除、逆置等操作
数据结构第二章线性表c++代码
07-14
本压缩包包含的数据结构第二章线性表的C++代码，重点展示了数据结构中的几个基本概念，如静态顺序表、动态顺序表、单链表和双链表。这些数据结构在实际编程中有着广泛的应用，例如在操作系统、数据库系统、编译器...
专升本数据结构第二章 线性表.pdf
最新发布
01-14
线性表是数据结构的基础部分，它是一种特殊的数据组织形式，由n（n>=0）个相同类型的数据元素构成的有限序列。线性表的每个元素都有一个直接前驱和直接后继，除了首元素（没有前驱）和尾元素（没有后继）。这种结构...
数据结构第二章线性表.pdf
09-30
数据结构第二章线性表.pdf 本章主要介绍了线性表的逻辑结构、顺序存储结构和链式存储结构，并对顺序表和链表进行了比较。学习目的要求学生能够熟悉线性表的逻辑结构和各种存储表示方法，以及定义在逻辑结构上的各种...
数据结构第二章线性表习题.doc
09-24
数据结构第二章线性表习题 本节习题涵盖了数据结构第二章线性表的主要知识点，包括线性表的定义、顺序表和链表的存储结构、插入、删除、查找等基本操作的时间复杂度分析，以及栈的实现和应用。 1. 线性表是有限...
数据结构第二章线性表
03-03
线性表的定义和基本操作 线性表的顺序存储结构 线性表的链式存储结构 线性表的应用举例
顺序表(包含合并，排序，交集，插入删除)
10-17
顺序表(包含合并，排序，交集，插入删除)，几乎包含了顺序表的所有基本功能
数据结构实验代码
圣三一
10-21 4019
抽象数据类型的表示与实现 一、实验目的及要求 （1）了解非数值问题的数学模型不是数学方程，而是表、树和图之类的数据结构。 （2）理解数据、数据元素、数据对象、数据结构和数据类型等的定义。掌握数据的逻辑结构和存储结构及其种类；算法的重要特征等。 （3）熟悉类C语言的书写规范，特别注意参数的区别，输入输出的方式和错误处理方式，以及抽象数据类型的表示和实现。 （4）会根据语句频度估算算法的时间复杂度。 ...
线性表的建立以及基本操作
热门推荐
ciganxian的专栏
05-29 1万+
#include #include #define MaxSize 50 typedef char ElemType; typedef struct { ElemType elem[MaxSize]; //存放顺序表中的元素 int length; //存放顺序表的长度 } SqList; void InitList(
十．用C语言实现查找算法 （1）顺序查找；（2）二分查找（折半查找）；（3）二叉排序树；（4）哈希查找
晴天的专栏
08-16 1万+
程序名称：Search.cpp // 程序功能：采用结构化方法设计程序，实现多种查找算法。 // 程序作者：*** // 最后修改日期：2011-3-3 #include"iostream" #include"stdlib.h" #include"stdio.h" #include "malloc.h" #define MAX 11 using namespace std; typedef in
C++构建一张单链表，实现对单链表的插入、删除、求表长。将单链表逆置，并判断单链表是否递增有序
Frank_LLX的博客
02-02 911
来自大二上学期实验报告1，请多指教。 一、实验任务： 构建一张单链表，实现对单链表的插入、删除、求表长。将单链表逆置，并判断单链表是否递增有序。 二、代码： template<class DataType> struct Node { DataType data; Node<DataType>* next; }; template<class DataType&g...
《数据结构》（C语言版）——线性表的动态分配顺序存储结构
prlhnxx的博客
01-26 8292
//P21 线性表的 顺序表示和实现 //函数结果状态代码 #define TRUE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2 //Status是函数的类型，其值是函数结果状态代码 typedef int Status; //用到的库文件 #include /
线性表删除一个元素
weixin_30883311的博客
12-07 178
//删除一个元素 #include #include #defineLIST_INIT_SIZE100 #defineLISTINCREMENT10 #defineOVERFLOW-2 #defineERROR0 #defineOK1 typedefintStatus; usingnamespacestd; typedefstruct { ...
单链表——基本操作（求表长、查找、插入、删除）(java)
IFollowRivers
04-13 2587
public class LinkedList { public Node first;//定义头结点 public LinkedList(){ this.first=null; } //定义节点类 public class Node{ int data; Node next=null; public Node(int data){ this.data=
线性表的顺序表示和实现
我要上天~
09-15 2254
线性表的顺序表示指的是用一组地址连续的存储单元一次存储线性表的数据元素。 假设线性表的每个元素需要占用个存储单元，并以所占的第一个但愿的存储地址作为数据元素的存储位置。则线性表中第个数据元素的存储位置和第个数据元素的存储位置之间满足下列关系： 一般来说，线性表的第个数据元素的存储位置为： 线性表的这种机内表示称作线性表的顺序存储结构或顺序映像，通常，称这种存储结构的线性表
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值