数据结构----越往后越发现 大学挂科的科目原来很重要

                                            

                

数据结构体系图

参考《数据结构》刘喜勋编著，已征得作者同意

1.线性表的顺序存储

     
     
//<span style=”font-size:18px;”>线性表顺序存储结构的构建</span>
#include <stdio.h>
#define MaxSize 100
typedef int DataType;

typedef struct
{
  DataType list[MaxSize];
   int size;
} SeqList;

//初始化顺序表L
void ListInitiate(SeqList *L)
{
  L->size = 0;       //定义初始数据元素个数
}

//返回顺序表L的当前数据元素个数
int ListLength(SeqList L)
{
   return L.size;
}

//在顺序表L的位置i（0≤i≤L.size）前插入数据元素值x,插入成功返回1，插入失败返回0
int ListInsert(SeqList *L, int i, DataType x)
{
   int j;
   if(L->size >= MaxSize)
  {
       printf( ”顺序表已满无法插入! \n”);
       return 0;
  }
   else if(i < 0 || i > L->size )
  {
       printf( ”参数i不合法! \n”);
       return 0;
  }
   else
  {
       for(j = L->size+ 1; j > i; j–)
      L-> list[j] = L-> list[j -1];               //为插入做准备

      L-> list[i] = x;                           //插入
      L->size ++;                    　　　　　　 //元素个数加1

       return 1;
  }
}

//删除顺序表L中位置i（0≤i≤L->size-1）的数据元素值并存放到参数x中,删除成功返回1，删除失败返回0
int ListDelete(SeqList *L, int i, DataType *x)
{
   int j;
   if(L->size == 0)
  {
       printf( ”顺序表已空无数据元素可删! \n”);

       return 0;
  }
   else if(i < 0 || i > L->size -1)
  {
       printf( ”参数i不合法”);
       return 0;
  }
   else
  {
      *x = L-> list[i];                   //保存删除的元素到参数x中

       for(j = i + 1; j <= L->size; j++)
      L-> list[j -1] = L-> list[j];         //依次前移

      L->size–;                       //数据元素个数减1

       return 1;
  }
}

//取顺序表L中第i个数据元素的值存于x中，成功则返回1，失败返回0
int ListGet(SeqList L, int i, DataType *x)
{
   if(i < 0 || i > L.size -1)
  {
       printf( ”参数i不合法! \n”);
       return 0;
  }
   else
  {
      *x = L. list[i];
       return 1;
  }
}
     
     

示例——对线性表的操作（增删改查）

     
     
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
#define ListLenth 50
typedef int DataType;

//定义顺序表的类型SeqList
typedef struct
{
  DataType list[MaxSize];
   int size;
} SeqList;

//初始化数据
void CreList(SeqList *L)
{
   int i;

  L->size= 50;
   //顺序表加入数据，依次为0-49
   for(i= 0;i< 50;i++)
  {
      L-> list[i]=i;
  }
}

//初始化顺序表*L
void ListInitiate(SeqList *L)
{
  L->size= 0;
}

//返回顺序表L的当前数据元素个数
int ListLength(SeqList *L)
{
   return L->size;
}

//查找功能，传参——线性表L和查找元素DataType x，成功返回x在L中的序号否则返回-1
int ListLocate(SeqList L,DataType x)
{
   int i= 0;
   while(i<L.size&&L. list[i]!=x)
  {
      i++;
  }
   if(i<L.size)
       return (i);
   else
       return ( -1);
}

//插入功能，传参——线性表L、插入位置i和所插入元素x，成功返回1否则返回0
int ListInsert(SeqList *L,int i,DataType x)
{
   int j;
   if(L->size>=MaxSize -1)
  {
       printf( ”顺序表已满无法插入！\n”);
       return 0;
  }
   else if(i< 0||i>L->size+ 1)
  {
       printf( ”参数i不合法！\n”);
       return 0;
  }
   else
  {
       for(j=L->size;j>i;j–)
      {
          L-> list[j]=L-> list[j -1];         //为插入做准备
      }
      L-> list[i]=x;                     //插入
      L->size++;                         //元素个数加1
       return 1;
  }
}

//删除功能，传参——顺序表L、删除元素的序号i和要返回所删除的元素
int ListDelete(SeqList *L,int i,DataType *x)
{
   int j;
   if(L->size== 0)
  {
       printf( ”顺序表已空无数据元素可删！\n”);
       return 0;
  }
   else if(i< 0||i>L->size -1)
  {
       printf( ”参数i不合法！\n”);
       return 0;
  }
   else
  {
      *x=L-> list[i];
       for(j=i+ 1;j<L->size;j++)
      {
          L-> list[j -1]=L-> list[j];
      }
      L->size–;

       return 1;
  }
}

void ListShow(SeqList L)
{
   int i;

   printf( ”当前List表为\n”);
   for(i= 0;i<L.size;i++)
  {
       printf( ”%d “,L. list[i]);
  }
   printf( ”\n共%d个元素\n\n”,L.size);

   return ;
}

main()
{

   int i;
  SeqList L;
  DataType x;

   //初始化顺序表L
  ListInitiate(&L);
   //初始化顺序表数据为0-49
  CreList(&L);

   //显示链表
  ListShow(L);

   //删除操作
   printf( ”1.删除20位置元素\n”);
  ListDelete(&L, 20,&x);
   printf( ”所删除元素为：%d\n”,x);
  ListShow(L);

   //增加操作
   printf( ”2.在1位置插入元素10\n”);
  ListInsert(&L, 1, 10);
  ListShow(L);

   //查询操作
   printf( ”3.查询30在链表中的位置：%d\n”,ListLocate(L, 30));
   printf( ”\n”);
   printf( ”4.查询20(已删除)在链表中的位置：%d\n”,ListLocate(L, 20));

   return 0;
}
     
     

运行结果

2.线性表的链式存储

3.队列的顺序存储

4.循环队列的链式存储

5.栈的顺序存储

6.栈的链式存储

7.树的顺序存储

8.树的链式存储

9.图的邻接矩阵表示

To be continued ,
learning…（Date：2016-2-6）

           

               

                                            

                

数据结构体系图

参考《数据结构》刘喜勋编著，已征得作者同意

1.线性表的顺序存储

   
   
//<span style=”font-size:18px;”>线性表顺序存储结构的构建</span>
#include <stdio.h>
#define MaxSize 100
typedef int DataType;

typedef struct
{
  DataType list[MaxSize];
   int size;
} SeqList;

//初始化顺序表L
void ListInitiate(SeqList *L)
{
  L->size = 0;       //定义初始数据元素个数
}

//返回顺序表L的当前数据元素个数
int ListLength(SeqList L)
{
   return L.size;
}

//在顺序表L的位置i（0≤i≤L.size）前插入数据元素值x,插入成功返回1，插入失败返回0
int ListInsert(SeqList *L, int i, DataType x)
{
   int j;
   if(L->size >= MaxSize)
  {
       printf( ”顺序表已满无法插入! \n”);
       return 0;
  }
   else if(i < 0 || i > L->size )
  {
       printf( ”参数i不合法! \n”);
       return 0;
  }
   else
  {
       for(j = L->size+ 1; j > i; j–)
      L-> list[j] = L-> list[j -1];               //为插入做准备

      L-> list[i] = x;                           //插入
      L->size ++;                    　　　　　　 //元素个数加1

       return 1;
  }
}

//删除顺序表L中位置i（0≤i≤L->size-1）的数据元素值并存放到参数x中,删除成功返回1，删除失败返回0
int ListDelete(SeqList *L, int i, DataType *x)
{
   int j;
   if(L->size == 0)
  {
       printf( ”顺序表已空无数据元素可删! \n”);

       return 0;
  }
   else if(i < 0 || i > L->size -1)
  {
       printf( ”参数i不合法”);
       return 0;
  }
   else
  {
      *x = L-> list[i];                   //保存删除的元素到参数x中

       for(j = i + 1; j <= L->size; j++)
      L-> list[j -1] = L-> list[j];         //依次前移

      L->size–;                       //数据元素个数减1

       return 1;
  }
}

//取顺序表L中第i个数据元素的值存于x中，成功则返回1，失败返回0
int ListGet(SeqList L, int i, DataType *x)
{
   if(i < 0 || i > L.size -1)
  {
       printf( ”参数i不合法! \n”);
       return 0;
  }
   else
  {
      *x = L. list[i];
       return 1;
  }
}
   
   

示例——对线性表的操作（增删改查）

   
   
#include <stdio.h>
#include <stdlib.h>
#define MaxSize 100
#define ListLenth 50
typedef int DataType;

//定义顺序表的类型SeqList
typedef struct
{
  DataType list[MaxSize];
   int size;
} SeqList;

//初始化数据
void CreList(SeqList *L)
{
   int i;

  L->size= 50;
   //顺序表加入数据，依次为0-49
   for(i= 0;i< 50;i++)
  {
      L-> list[i]=i;
  }
}

//初始化顺序表*L
void ListInitiate(SeqList *L)
{
  L->size= 0;
}

//返回顺序表L的当前数据元素个数
int ListLength(SeqList *L)
{
   return L->size;
}

//查找功能，传参——线性表L和查找元素DataType x，成功返回x在L中的序号否则返回-1
int ListLocate(SeqList L,DataType x)
{
   int i= 0;
   while(i<L.size&&L. list[i]!=x)
  {
      i++;
  }
   if(i<L.size)
       return (i);
   else
       return ( -1);
}

//插入功能，传参——线性表L、插入位置i和所插入元素x，成功返回1否则返回0
int ListInsert(SeqList *L,int i,DataType x)
{
   int j;
   if(L->size>=MaxSize -1)
  {
       printf( ”顺序表已满无法插入！\n”);
       return 0;
  }
   else if(i< 0||i>L->size+ 1)
  {
       printf( ”参数i不合法！\n”);
       return 0;
  }
   else
  {
       for(j=L->size;j>i;j–)
      {
          L-> list[j]=L-> list[j -1];         //为插入做准备
      }
      L-> list[i]=x;                     //插入
      L->size++;                         //元素个数加1
       return 1;
  }
}

//删除功能，传参——顺序表L、删除元素的序号i和要返回所删除的元素
int ListDelete(SeqList *L,int i,DataType *x)
{
   int j;
   if(L->size== 0)
  {
       printf( ”顺序表已空无数据元素可删！\n”);
       return 0;
  }
   else if(i< 0||i>L->size -1)
  {
       printf( ”参数i不合法！\n”);
       return 0;
  }
   else
  {
      *x=L-> list[i];
       for(j=i+ 1;j<L->size;j++)
      {
          L-> list[j -1]=L-> list[j];
      }
      L->size–;

       return 1;
  }
}

void ListShow(SeqList L)
{
   int i;

   printf( ”当前List表为\n”);
   for(i= 0;i<L.size;i++)
  {
       printf( ”%d “,L. list[i]);
  }
   printf( ”\n共%d个元素\n\n”,L.size);

   return ;
}

main()
{

   int i;
  SeqList L;
  DataType x;

   //初始化顺序表L
  ListInitiate(&L);
   //初始化顺序表数据为0-49
  CreList(&L);

   //显示链表
  ListShow(L);

   //删除操作
   printf( ”1.删除20位置元素\n”);
  ListDelete(&L, 20,&x);
   printf( ”所删除元素为：%d\n”,x);
  ListShow(L);

   //增加操作
   printf( ”2.在1位置插入元素10\n”);
  ListInsert(&L, 1, 10);
  ListShow(L);

   //查询操作
   printf( ”3.查询30在链表中的位置：%d\n”,ListLocate(L, 30));
   printf( ”\n”);
   printf( ”4.查询20(已删除)在链表中的位置：%d\n”,ListLocate(L, 20));

   return 0;
}
   
   

运行结果

2.线性表的链式存储

3.队列的顺序存储

4.循环队列的链式存储

5.栈的顺序存储

6.栈的链式存储

7.树的顺序存储

8.树的链式存储

9.图的邻接矩阵表示

To be continued ,
learning…（Date：2016-2-6）