数据结构学习15：线性表

线性表其实就是零个或者多个数据元素的有限序列。关于线性的存储结构有顺序存储结构和链式存储结构。

顺序存储结构

1：顺序存储：指的是用一段地址连续的存储单元依次存储线性表的数据元素。在C语言中经常用一维数组来实现顺序存储结构。

关于建立一个线性表，最主要的是要做两个工作：在内存中找到一块地址，寻找到其存储空间的起始地址；再者就是估算其数组长度。

2：描述线性表顺序存储结构主要包括：

□存储空间的起始位置：数组data

□线性表的最大存储容量：数组长度MaxSize

□线性表的当前长度：length

3：结构代码：

#define MAXSIZE 20
typedef int ElemType；
typedef struct
{
	ElemType data[MAXSIZE];
	int length;}

4：顺序存储结构的操作

顺序存储结构的操作主要包括:插入和删除

1）插入

基本思路：·如果插入不合理，则抛出异常

 ·如果线性表长度大于数组长度，则抛出异常或者动态增加数组容量

 ·从最后一点元素遍历到第i个位置，分别将他们都向后移动一个位置

  ·将要插入元素填入位置i处

实现代码：

Status ListInsert（Sqlist *L，int i，ElemType e）
{
int k；
if（L->length==MAXSIZE）
return error；
if（i<=L-length）
{
for(k=L->length-1;k>=i-1;k--)
L->data[k+1]=L->data[k];
}
L->data[i-1]=e;
L->lenth++;
return OK;
}

2)删除

基本思路：·如果删除位置不合理，抛出异常

  ·取出删除元素

  ·从删除元素位置开始遍历到最后一个位置，分别将它们都向前移动一个位置

  ·表上减1

实现代码:

Status ListDelete(Sqlits *L,int i,ElemType e)

{

int k;

if(L->length==0)

return error;

if(i<1||i>L->length)

return error;

*e=L->data[i-1];

if(i<L->length)

{

for(k=i;k<L->length;k++)

L->data[k-1]=L->data[k];

}

L->length--;

return OK;

}

链式存储结构

相比较线性表的顺序存储结构，线性表的链式存储结构在删除和插入操作时有很大的便利。因为线性表的顺序存储结构在删除和插入时候需要移动大量的元素，这显然是耗费时间的。线性表的链式存储结构的特点就是用一组任意的存储单元存储线性表的数据元素。

为了表示每个数据元素ai与其后继数据元素ai+1之间的逻辑关系，还需要存储一个指示其直接后继的信息（即直接后继的存储位置）。我们把存储数据元素信息的域叫数据域，把存储直接后继位置的域称为指针域。指针域中存储的信息叫做指针或链。这两部分信息组成数据元素ai的存储映像，称之为结点（Node）。

1：基本概念

头指针：链表中第一个结点存储位置

空（NULL）：链表中最后一个结点指针为“空”（NULL或者“^”表示）

头结点：链表中第一个结点前附设一个结点，称之为头结点。

关于头指针与头结点的区别：
头结点是维了操作同意和方便而设立的，放在第一元素的结点之前。其数据域一般没有意义。是为了方便对第一元素结点进行操作。头结点不一定是链表必须元素

头指针：指向链表第一个结点的指针，若链表有头结点。则是指向头结点的指针。头指针是链表的必要元素。

2：结构代码

typedef struct Node
{
ElemType data;
struct Node *next;
}Node;
typedef struct Node *LinkList;

说明：假设p是指向线性表第i个元素的指针，则该结点ai的数据域可以用p->data表示，p->data的值是一个数据元素，结点ai的指针域可以用p->next表示。

p->next的值表示一个指针。指向第i+1个元素。

3：操作

（1）插入

假设存储元素e的结点是s，要实现p、p->next和s之间逻辑关系变化。

其实只要指针发生改变即可：
s->next=p->next;p->next=s;意思为：p的后继结点改成s的后继结点，指向p->next结点，再让p指向s结点，于是p->next=s；

这两句话是不能发生改变的

结构代码：

Status ListInsert（LinkList *L，int i，ElemType e）

{

int j;

LinkList p,s;

p=*L;

j=1;

while(p&&j<i)

{

p=p->next;

++j;

}

if(!p||j>i)

return error;

s=(LinkList)malloc(sizeof(Node))

s->data=e;

s->next=p->next;

p->next=s;

return ok;

}

（2）删除

假设存储元素ai的结点为q，要实现删除结点q。其实就是要将次结点绕过就行

假设结点q的前驱结点是p，后继结点是q->next

其实就是要p最后指向了q->next了就可以了

即：q=p->next；p->next=q->next;

单链表第i个数据删除结点的算法思路：

·声明一个结点p指向链表第一个结点，初始化j从1开始

·当j<1时，就遍历链表，让p的指针向后移动，不断指向下一个结点，j累加1

·若到了链表尾部p为空，则说明第i个元素不存在

·若查找成功，将欲删除的结点p->next赋值给q

·单链表的删除标准语句p->next=q->next;

·将q结点中数据赋值给e，作为返回

·释放q结点

Status ListDelete（LinkList *L，int i，ElemType *e）
{
int j；
LinkList p，q；
p=*L；
j=1；
while（p->next &&j<1）
{
p=p->next;
++j;
}
if(!(p->next)||j>1)
return error;
q=p->next;
p->next=q->next;
*e=q->date;
free(q);
return OK;
}

在把上述线性表的两种存储结构回顾了一遍以后，最主要的还是运用：

约瑟夫问题

问题描述： 
输入一个由随机数组成的数列（数列中每个数均是大于0的整数，长度已知），和初始计数值m。从数列首位置开始计数，计数到m后，将数列该位置数值替换计数值m，并将数列该位置数值出列，然后从下一位置从新开始计数，直到数列所有数值出列为止。如果计数到达数列尾段，则返回数列首位置继续计数。请编程实现上述计数过程，同时输出数值出列的顺序

比如： 输入的随机数列为：3,1,2,4，初始计数值m=7，从数列首位置开始计数（数值3所在位置）
第一轮计数出列数字为2，计数值更新m=2，出列后数列为3,1,4，从数值4所在位置从新开始计数
第二轮计数出列数字为3，计数值更新m=3，出列后数列为1,4，从数值1所在位置开始计数
第三轮计数出列数字为1，计数值更新m=1，出列后数列为4，从数值4所在位置开始计数
最后一轮计数出列数字为4，计数过程完成。
输出数值出列顺序为：2,3,1,4。

• 要求实现函数： 
void array_iterate(int len, int input_array[], int m, int output_array[])
【输入】 int len：输入数列的长度；
int intput_array[]：输入的初始数列
int m：初始计数值
【输出】 int output_array[]：输出的数值出列顺序
【返回】 无

分析：这是一个典型的运用线性表结构的问题，因为先给出的一个数组，每当进行操作以后都要删除一个元素。其实就是对线性表进行删除的操作，既可以用顺序存储结构进行完成，又可以用线性结构进行完成。在做这个案列分析的时候，尽量两种方法都用到。以达到对知识点的巩固的要求。

方案一：链式存储结构

首先定义个一个结构体结点：

再者就需要实现一个链表的整表创建： 单链表整表创建的算法思路：

1）声明一个结点p和计数器变量i；

2）初始化一个空链表L

3）让L的头结点的指针指向NULL，即建立一个带头结点的单链表

4）循环：

◇生成一个新结点赋值给p

◇随机生成一个数字赋值给p的数据域p->data

◇将p插入到头结点与前一新结点之间

头插法：

struct Node
{
int data；
Node *next；
}；<pre name="code" class="cpp">

void CreateListHead（LinkList *L，int n）
{
LinkList p；
int i；
srand（time（0））；
*L=(LinkList)malloc(sizeof(Node));
(*L)->next=NULL;
for(i=0;i<n;i++)
{
p=(LinkList)malloc(sizeof(Node));
p->data=rand()%100+1;
p->next=(*L)->next;
(*L)->next=p;
}
}

尾插法：

void CreateListHead(LinkList *L,int n)
{
LinkList p;
int i;
srand(time(0));
*L=(LinkList)malloc(sizeof(Node));
r=*L;
for(i=0;i<n;i++)
{
p=(Node*)malloc(sizeof(Node));
p->data=rand()%100+1;
r->next=p;
r=p;
}
r->next=NULL;
}

问题描述：编程实现单链表的建立/测长/打印

#include <iostream>
#include <stdio.h>
#incldue <string.h>
#include <conio.h>
using namespace std;
typedef struct student
{
int data;
struct student *next;
}node;
node *creat()
{
node *head,*p,*s;
int x,cycle=1;
head=(node*)malloc(sizeof(node));
p=head;
while(cycle)
{
printf("\nplease input the data:");
scanf("%d",&x);
if(x!=0)
{
s=(*node)malloc(sizeof(node));
s->data=x;
printf("\n%d",s->data);
p->next=s;
p=s;}
else cycle=0;
}
head=head->next;
p->next=NULL;
printf("\n yyy %d",head->data);
return (head);
}

//单链表测长

int length(node *head)
{
int n=0;
node *p;
p=head;
while(p!=NULL)
{
p=p->next;
n++;
}
return (n);}

//单链表打印

void print（node *head）
{
node *p;
int n;
n=length(head);
printf("\nNow,These %d records are:\n",n);
if(head!=NULL)
while(p!=NULL)
{printf("\n  uuu %d   ",p->data);
p=p->next;
}
}