数据结构 study 3：单链线性表 表头指针 结点指针

数据结构

是用来解决现实生活中或者实际项目中遇到的问题的
那么在实际的项目中，会遇到哪些问题呢？

有两组任意的数据 ，
假设为:La= {1， 2， 3， 4 ，5}， Lb= {2， 4， 6， 8， 10}.
将这两组数据 组合存放到一块。
变成一个新的组合:Lc = {1, 2, 3, 4, 5, 6, 8, 10}.

按非递减顺序, 请输入5个数据
1 2 2 3 7
La=1 2 2 3 7
按非递增顺序, 请输入5个数据
9 8 8 7 5
Lb=5 7 8 8 9
Lc=1 2 2 3 5 7 7 8 8 9

如何用 单链线性表的方式 实现呢？

／／－ － － － － 单链表的存储结构－ － － － －
typedef struct LNode
{
	ElemType data; //结点的数据域
	struct LNode *next;
}LNode,*LinkList;  //LinkList 为指向结构体LNode 的指针类型

(1)这里定义的是单链表中每个结点的存储结构，它包括两部分：存储结点的数据
域data, 其类型用通用类型标识符ElemType 表示（例如，用链表表示案例2.1 中的图书
信息时，只需将ElemType 替换为2.4.1 定义的Book 数据类型即可）；存储后继结点位置
的指针域next, 其类型为指向结点的指针类型LNode *。

(2) 为了提高程序的可读性，在此对同一结构体指针类型起了两个名称，LinkList 与
LNode* , 两者本质上是等价的。通常习惯上用LinkList 定义单链表，强调定义的是某个单链
喊＇ 表的头指针；用LNode 定义指向单链表中任意结点的指针变量。例如，若定义LinkList L,
惩明则L 为单链表的头指针，若定义LNodep, 则p 为指向单链表中某个结点的指针，用p 代表
该结点。当然也可以使用定义LinkListp, 这种定义形式完全等价于LNodep。

(3) 单链表是由表头指针唯一确定，因此单链表可以用头指针的名宇来命名。若头
指针名是L, 则简称该链表为表L。

(4) 注意区分指针变量和结点变量两个不同的概念，若定义LinkListp 或LNode p,
则p 为指向某结点的指针变量，表示该结点的地址；而p 为对应的结点变量，表示该结
点的名称。

简单的单链表实例程序

/* c1.h (程序名) */
#include<string.h>
#include<ctype.h>
#include<malloc.h> /* malloc()等 */
#include<limits.h> /* INT_MAX等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include <sys/io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */

#include<pthread.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

typedef int ElemType;

#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量 */
#define LIST_INCREMENT_NUM 2 /* 线性表存储空间的分配增量 */

/* c2-2.h 线性表的单链表存储结构 */
typedef struct LNode
{
  ElemType data;
  struct LNode *next;
}LNode ,*LinkList,*LinkNode;

/*
  LinkList  是 单链表的表头指针
  LinkNode  是 单链表的结点指针
  两者是一样的
*/

void create_list(LinkList *L)
{    
    *L = (LinkList)malloc(sizeof(struct LNode)); /* 生成头结点 */
    (*L)->next=NULL;
}


int insert_list(LinkList L, int i , ElemType e)
{
    /* 在带头结点的单链线性表L中第i个位置之前插入元素e */
      int j=0;
      LinkNode p=L,s;
      while(p&&j<i-1) /* 寻找第i-1个结点 */
      {
        p=p->next;
        j++;
      }
      if(!p||j>i-1) /* i小于1或者大于表长 */
        return ERROR;
      s=(LinkNode)malloc(sizeof(struct LNode)); /* 生成新结点 */
      s->data=e; /* 插入L中 */
      s->next=p->next;
      p->next=s;
      return OK;    
}

void visit(ElemType c) /* ListTraverse()调用的函数(类型要一致) */
{
  printf("%d ",c);
}

Status traverse_list(LinkList L,void(*vi)(ElemType))
/* vi的形参类型为ElemType，与bo2-1.c中相应函数的形参类型ElemType&不同 */
{ /* 初始条件：线性表L已存在 */
  /* 操作结果:依次对L的每个数据元素调用函数vi()。一旦vi()失败,则操作失败 */
  LinkNode p=L->next;
  while(p)
  {
    vi(p->data);
    p=p->next;
  }
  printf("\n");
  return OK;
}


int main()
{
    LinkList L;
    int i ;
    int cnt ;
    ElemType data ;
    create_list(&L);
    
    printf("请输入要插入数据的个数:\n");
    scanf("%d",&cnt);
    printf("请输入要插入的数据:\n");
    for(i=1;i <= cnt; i++){
        scanf("%d",&data);
        insert_list(L,i,data);
    }

    traverse_list(L, visit);
}

程序输出:

请输入要插入数据的个数:
5
请输入要插入的数据:
1
2
3
4
5
1 2 3 4 5

进一步的程序

/* c1.h (程序名) */
#include<string.h>
#include<ctype.h>
#include<malloc.h> /* malloc()等 */
#include<limits.h> /* INT_MAX等 */
#include<stdio.h> /* EOF(=^Z或F6),NULL */
#include<stdlib.h> /* atoi() */
#include <sys/io.h> /* eof() */
#include<math.h> /* floor(),ceil(),abs() */

#include<pthread.h> /* exit() */

/* 函数结果状态代码 */
#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0

typedef int Status; /* Status是函数的类型,其值是函数结果状态代码，如OK等 */
typedef int Boolean; /* Boolean是布尔类型,其值是TRUE或FALSE */

typedef int ElemType;

#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量 */
#define LIST_INCREMENT_NUM 2 /* 线性表存储空间的分配增量 */

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


int create_list(LinkList *L)
{
    *L = (LinkList)malloc(sizeof(struct LNode));

    if(!(*L)){

        exit(1);
    }

    (*L)->next = NULL ;
    
    return 0 ;
}


/*
  i 从1这个位置开始
*/

int insert_list(LinkList L,int i ,ElemType e)
{
    LinkNode p ; 
    LinkNode s ;
    int j =0 ;

    p = L ;

    if(i <1){

        return -1 ;
    }

    

    while(p &&(j<i-1))
    {
        p = p->next ;
        j++ ;
    }

    if((!p)||(j<(i-1))){

        return  -1 ;
    }    

    s = (LinkNode)malloc(sizeof(struct LNode));
    s->next = NULL;

    s->data = e ;
    s->next = p->next ;
    p->next = s;
   
    return OK ;
}


void visit(ElemType data)
{
    printf("%d ", data);
}

int traverse_list(LinkList L,void (*visit)(ElemType ))
{
    LinkNode p = L->next ;

    while(p){

        visit(p->data);
        p = p->next;
    }

    printf("\n");

    return OK ;    
}


void MergeList(LinkList La,LinkList *Lb,LinkList *Lc)/* 算法2.12 */
{ /* 已知单链线性表La和Lb的元素按值非递减排列。 */
  /* 归并La和Lb得到新的单链线性表Lc，Lc的元素也按值非递减排列 */
  LinkList pa=La->next,pb=(*Lb)->next,pc;
  *Lc=pc=La; /* 用La的头结点作为Lc的头结点 */
  while(pa&&pb)
    if(pa->data<=pb->data)
    {
      pc->next=pa;
      pc=pa;
      pa=pa->next;
    }
    else
    {
      pc->next=pb;
      pc=pb;
      pb=pb->next;
    }
  pc->next=pa?pa:pb; /* 插入剩余段 */
  free(*Lb); /* 释放Lb的头结点 */
  Lb=NULL;
}


int main()
{

    

    LinkList La,Lb,Lc;    
    int i ;
    int cnt ;
    ElemType data ;
    create_list(&La);
    
    printf("请输入La要插入数据的个数:\n");
    scanf("%d",&cnt);
    printf("请输入La要插入的数据:\n");
    for(i=1;i <= cnt; i++){
        scanf("%d",&data);
        insert_list(La,i,data);
    }

    traverse_list(La, visit);


    create_list(&Lb);
    printf("请输入Lb要插入数据的个数:\n");
    scanf("%d",&cnt);
    printf("请输入Lb要插入的数据:\n");
    for(i=1;i <= cnt; i++){
        scanf("%d",&data);
        insert_list(Lb,i,data);
    }    

    traverse_list(Lb, visit);

    
    MergeList(La,&Lb,&Lc); /* 按非递减顺序归并La和Lb,得到新表Lc */
    printf("Lc="); /* 输出链表Lc的内容 */
    traverse_list(Lc,visit);

}