数据结构之链表

 未完，待续

<pre class="cpp" name="code"><pre class="cpp" name="code"><pre class="cpp" name="code">//数组模拟单链表
/*
特点：
存储方式为连续存储
访问快，插入删除慢
*/

#include<cstdio>
#include<malloc.h>
typedef int ListItem;
typedef struct alist *List;
typedef struct alist{
    int n;
    int maxsize;
    ListItem *table;
}Alist;
List ListInit(int size);
int ListEmpty(List L);
int ListLength(List L);
ListItem ListRetrieve(int k,List L);
int ListLocate(ListItem x,List L);
void ListInsert(int k,ListItem x,List L);
ListItem ListDelete(int k,List L);
void PrintList(List L);
void ERROR(char *str)
{
    puts(str);
    exit(-1);
}
void ItemShow(ListItem a)
{
    printf("%d ",a);
}
List ListInit(int size)
{
    List L=(List) malloc(sizeof*L);
    L->table=(ListItem *) malloc(size*sizeof(ListItem));
    L->maxsize=size;
    L->n=0;
    return L;
}
int ListEmpty(List L)
{
    return L->n==0;
}
int ListLength(List L)
{
    return L->n;
}
int ListLocate(ListItem x,List L)
{
    int i;
    for(i=0;i<L->n;++i)
    if(L->table[i]==x) return ++i;
    return 0;
}
ListItem ListRetrieve(int k,List L)
{
    if(k<1||k>L->n) ERROR("out of bounds");
    return L->table[k-1];
}
void ListInsert(int k,ListItem x,List L)
{
    int i;
    if(k<0||k>L->n) ERROR("out of bounds");
    if(L->n==L->maxsize) ERROR("out of memory");
    for(i=L->n-1;i>=k;--i) L->table[i+1]=L->table[i];
    L->table[k]=x;
    L->n++;
}
ListItem ListDelete(int k,List L)
{
    int i;ListItem x;
    if(k<1||k>L->n) ERROR("out of bounds");
    x=L->table[k-1];
    for(i=k;i<L->n;++i) L->table[i-1]=L->table[i];
    L->n--;
    return x;
}
void PrintList(List L)
{
    int i;
    for(i=0;i<L->n;++i) ItemShow(L->table[i]);
}

<pre class="cpp" name="code"><pre class="cpp" name="code">/*
表头不存储元素，只为方便插入删除等操作
表首 是表头后的第一个存储元素的节点
表头 下标记为0
表首 下标记为1
插入删除速度快，访问慢

*/
#include<stdio.h>
#include<malloc.h>
typedef int ListItem;
typedef struct node *link;
typedef struct node {
    ListItem element;
    link next;
}Node;
//![0]专用于表头
typedef struct llist *List;
typedef struct llist {link first;}Llist;
//![0]
void ERROR(char *str)
{
    puts(str);
    exit(-1);
}
void ItemShow(ListItem a)
{
    printf("%d ",a);
}
link NewNode()
{
    link p;
    if((p=(link)malloc(sizeof(Node)))==NULL)
       ERROR("Exhausted memory.");
    else return p;
}
List ListInit()
{
    List L=(List) malloc(sizeof(*L));
    L->first=NULL;
    return L;
}
int ListEmpty(List L)
{
    return L->first==NULL;
}
int ListLength(List L)
{
    int len=0;
    link p;
    while(p){len++;p=p->next;}
    return len;
}
ListItem ListRetrieve(int k,List L)
{
    int i;
    link p;
    if(k<1) ERROR("out of bounds");
    p=L->first;i=1;
    while(i<k&&p) {p=p->next;++i;}
    return p->element;
}
int ListLocate(ListItem x,List L)
{
    int i=1;
    link p;
    p=L->first;
    while(p&&p->element!=x){p=p->next;++i;}
    return p?i:0;//如果是空链表，则p=NULL返回0
}
//![1] 表头为0 插入到第k个后面
void ListInsert(int k,ListItem x,List L)
{
    link p,y;
    int i;
    if(k<0) ERROR("out of bounds");
    p=L->first;
    for(i=1;i<k&&p;++i) p=p->next;//找到插入位置
    y=NewNode();
    y->element=x;
    if(k) {y->next=p->next;p->next=y;}
    else {y->next=L->first;L->first=y;}//k==0是表示在表首插入
}
//![1]

//![2]
ListItem ListDelete(int k,List L)
{
    link p,q;
    ListItem x;
    int i;
    if(k<1||!L->first) ERROR("out of bounds");
    p=L->first;
    if(k==1) L->first=p->next;//删除表首元素
    else
    {
        q=L->first;
        for(i=1;i<k-1&&q;++i)q=q->next;
        p=q->next;
        q->next=p->next;
    }
    x=p->element;free(p);
    return x;
}
//![2]
void PrintList(List L)
{
    link p;
    for(p=L->first;p;p=p->next) ItemShow(p->element);
}

y->next=p->next;//该代码建立 第三条关系
p->next=y;//该代码  使得原来的 第一条关系变成 第二条关系

待删除节点 pp=q->next;
q->next=p->next;//改变关系1 建立关系3

/*
用间接寻址方法实现表
特点：
访问速度快
插入删除相对于数组有改进
理由：因为数组里面存的是地址（4字节），
当数组元素较大时，直接交换较慢，
地址交换速度较快
*/
#include<stdio.h>
#include<malloc.h>
typedef int ListItem;
typedef ListItem *addr;
typedef struct indlist *List;
typedef struct indlist{
    int n;
    int maxsize;
    addr *table;
}Indlist;

void ERROR(char *str)
{
    puts(str);
    exit(-1);
}
void ItemShow(ListItem a)
{
    printf("%d ",a);
}
List ListInit(int size)
{
    List L=(List)malloc(sizeof(*L));
    L->n=0;L->maxsize=size;
    L->table =(addr *) malloc(size* sizeof(addr));
    return L;
}
int ListEmpty(List L)
{
    return L->n==0;
}
int ListLength(List L)
{
    return L->n;
}
ListItem ListRetrieve(int k,List L)
{
    if(k<1||k>L->n) ERROR("out of bounds");
    return *L->table[k-1];
}
int ListLocate(ListItem x,List L)
{
    int i;
    for(i=0;i<L->n;++i)
        if(*L->table[i]==x) return ++i;
    return 0;
}
addr NewNode()
{
    addr p;
    if((p=(addr)malloc(sizeof(p)))==0)
        ERROR("Exhausted memory");
    else
        return p;
}
void ListInsert(int k,ListItem x,List L)
{
    int i;
    if(k<0||k>L->n) ERROR("out of bounds");
    if(L->n==L->maxsize) ERROR("out of bounds");
    for(i=L->n-1;i>=k;--i) L->table[i+1]=L->table[i];
    L->table[k]=NewNode();
    *L->table[k]=x;
    L->n++;
}
ListItem ListDelete(int k,List L)
{
    int i;ListItem x;addr p;
    if(k<1||k>L->n) ERROR("out of bounds");
    p=L->table[k-1];
    x=*p;
    for(i=k;i<L->n;++i)L->table[i-1]=L->table[i];
    L->n--;
    free(p);
    return x;
}
void PrintList(List L)
{
    int i;
    for(i=0;i<L->n;++i) ItemShow(*L->table[i]);
}