数据结构 线性表(一)

（一）线性表基本概念
1.概念
相同特性数据元素的一个有限序列。
长度：序列中所含元素的个数。（大于等于0）
2.逻辑特性（同绪论）
3.存储结构
（1顺序表
线性表中所有元素按照逻辑顺序，依次存储到指定的存储位置开始的一块连续存储空间。
（2链表
包含元素信息和元素之间逻辑关系。
（3比较
顺序表：随机访问（根据随便一个可以找到任何一个）、连续存储空间、插入操作需要移动以后所有元素。
链表：不支持随机访问、空间存储率较低、支持存储空间的动态分配、插入操作改变指针。

分配方式：
顺序表存储空间一次性分配，链表存储空间是多次分配。
存储密度：
顺序表存储密度=1 、链表存储空间<1
基于时间比较：
存取方式：
顺序表可以随机存取，也可以顺序存取。链表只能顺序存取（读取某个元素，要遍历之前所有元素）。

插入删除移动元素个数：
1，求概率 每一个位置都是1/n
2，每个位置插入需要移动的个数
插入第i个元素之后，移动n-i个元素
E=N-1/2

链表形式：
（1单链表
节点中包含数据域、指针域。

带头结点的单链表：
头指针head指向头节点，头节点值域不含内容。head！=NULL。head->next=NULL代表空链表。

不带头结点的单链表：
头指针head指向开始节点，head=NULL代表空链表。

区别：带头结点单链表有一个不存储信息，作为标志。

（2双链表
两个指针

解决从终端节点到头节点问题。

（3循环单链表
单链表最后一个节点指针指向第一个节点。
特点：实现从一个节点出发访问链表的任何节点。
（4循环双链表
最后一个节点指针指向头一个节点。
带头结点：
空链表，head->next 和head->prior为空。
（5静态链表
数据都存在于数组中，但是存储位置随机。
例题：假设静态链表存储a[1,2,3]

（二）线性表结构体定义和基本操作
1.结构体定义
（1顺序表：
typedef struct {
int data[maxSize];
int length;
}Sqlist;
（2.单链表
typedef struct node {
int data;
struct node *next;
}node ;

（3.双链表
typedef struct node {
int data;
struct node *piror;
struct node *next;
}node ;

node *A = (node *)malloc(sizeof(node ))
这个A有两个含义：指针和节点名

2.顺序表操作
例题1：
顺序表单调递增，设计算法，插入元素x，仍然单调递增。
分析两步操作：
先找到插入的位置
位置后的所有元素都往后移动一个位置，腾出插入地方。

操作一：可以从小到大扫描表中元素，找到比x大的元素，把x插在这个元素之前就可以。
（图见408数据结构的P25）

int find_node (Sqlist L,int x){
int i ;
for(i=0;i<L.length;++i)
{
if(x<L.data[i])
{
return i;
}
}
return i;
}

操作二：将插入位置之后的往后移动一个位置，先移动最右边的元素
void insert_node(Sqlist &L,int x)
{
int p,i;
p = find_node (L,x);
for(i = L.length-1;i>=p;i–)
{
L.data[i+1]=L.data[i];
}
L.data[p]=x;
++(L.length);
}

思想：1.查找算法2.插入算法

例题2：
删除顺序表下标为p的元素。

分析：找到下标为p的元素，其后面的元素都向前移动一个位置就可以。
int delete_node (Sqlist &L,int p,int &e)
{
int i;
if(p<0||p>L.length-1)
{
return 0;
}
e = L.data[p];
for(i<p;i<Length-1;++i)
{
L.data[i] = L.data[i+1];
–(L.length);
return 1;
}
}

初始化顺序表算法：
void init_list(Sqlist &L)
{
L.length=0;
}

求指定未知元素的算法：
void get_node (Sqlist L,int p ,int &e)
{
if(p<0||p>L.length-1)
return 0 ;
e = L.data[p];
return 1;
}

3.单链表操作
例题3：合并单链表
两个单链表AB递增有序，将A、B合并成一个递增有序的链表C。
分析：找到A、B共同最小的元素依次插入C。
void merge(Lnode *A,Lnode *B,Lnode *C)
{
Lnode *p = A->next;
Lnode *q =B->next;
Lnode *r;
C=A;
C->next = NULL;
free(B);
r=C;

}