链表

1. 单链表

 

单链表的动态数据结构的声明：

 

typedef   char  datatype;

typedef  struct  node{

        datatype  data;

        struct   node  *next;

}listnode, *linklist;

//typedef  listnode  *linklist;

 //       listnode  *p;

        linklist  head;           // head为指针名，把链表称为表head

 

单链表的建立：

 

linklist createl_single_list(void){

   char ch = getchar();

   linklist head = null;

   listnode *p;

   while(ch! = ’/n’){

      p=(listnode*)malloc(sizeof(listnode));

      p->data = ch;

      p->next = head;

      head = p;

      ch=getchar();

}

return(head);

}//表头插入法，生成的链表中结点的次序和输入的顺序相反。

linklist cerat_single_list2( ){

char ch;

linklist head;

listnode *p, *q ;

head = q= null; //r为链表的尾指针；

while((ch = getchar()) != ‘/n’ ){

    p = (listnode*)malloc(sizeof(listnode));

    p->data = ch;

    if(head = null)

head = p;

    else

 q->next = p;

        q= p;

}

if(q != null) q->next = null;

return head;

}//表尾插入；

 

单链表的查找：

 

listnode *get_node(linklist head, int i){

int j;

listnode *p;

p = head;      //可能找头结点，从j＝0开始找；

j = 0;

while(p->next&&j<i){

p = p->next;

j++;

}

If(i = j)

    return p;

else

    return null;

}//按序号查找

 

listnode *locate_node(linklist head, int key){

listnode *p = head->next;   //头节点没有值

while(p && p->data != key)

    p = p->next;

   return p;

}//按值查找，值是整型值

 

单链表的插入：

 

void insert_node(linklist head, int x, int i){ //在 之前插入整数x，即 和 之间；

listnode *p, *q;

p = get_node(head, i-1);

if(p = null)

    error(“position  error”);

q = (linknode*)malloc(sizeof(linknode));

q->data = x;

q->next = p->next;

p->next = q;

}//设链表的长度为n，合法的插入位置是1≦i≦n+1。

 

单链表的删除

 

void del ete_node(linklist head, int i){

listnode *p, *q;

p = get_node(head, i-1)

if(p = = null || p->next = = null)  //p结点不能是尾结点

    return -1;

q = p->next;

p->next = q->next;

free(q);

}//删除i位置的结点；

 

单链表的长度:

 

int length(linklist head){

int k=0;

listnod *p;

p = head; //把头结点算上，注意头指针和头结点区别，头结点没有数据值；

while(p -> next){

    p = p -> next;

    k++;

}

return k;

}

 

链接两个单链表heada、headb:

 

void connect_list (linklist heada, linklist headb, linklist &headc) {

 //把链表hb接在ha后面形成链表hc
     headc = heada; p = heada;
      while(p -> next) p = p -> next;
      p -> next = hb;
}//connect_list

 

单链表的转置

 

linklist reverse_list(linklist head){

listnode *p, *q;

if(head ->head&&head ->next -> next){//至少有两个结点，除头结点外；

    p = head -> next;

    q = p -> next;

    p -> next = null;//把开始结点变成尾结点；

    while(q){

   p = q;

   q = q ->next;

   p ->next = head -> next;

   head -> next = p;  //使每次的p结点插入到head后面；

}

    return  head;

}

return head;

}

 

 

2. 循环链表

 

1）单循环链表

单循环链表的基本操作于单链表的相似，只是要注意多考虑一步，尾结点指向的是头结点。

//实际中多采用尾指针表示单循环链表,因为查找开始结点和终端结点都方便，它们的存储位置分别是(rear–>next) —>next和rear，查找时间都是O(1)。

 

链接两个单循环链表heada、headb

 

linklist  connect_list(linklist heada, linklist headb){  //heada headb表示的都是尾结点

linklist p;

p = heada->next;

heada->next = (headb->next)->next;

free(headb->next);

headb->next = p;

return(headb);

}//

 

单循环链表表示稀疏矩阵

 

结构声明：

typedef  int  datatype

struct matrix_list{

int row;

int col;

datatype data;

struct matrix_list *right;

struct matrix_list *down;

}matrix_node, *matrix_list;

 

2）双链表

 

双链表的动态数据结构的声明:

 

typedef   char  datatype;

typedef struct d_listnode{

datatype data;

    struct d_listnode *prior, *next;

}d_listnode, d_linklist, head;

   //typedef d_listnode * dlinklist;

   // dlinklist head;

 

双链表的建立

 

d_linklist create_d_list(void){

    char ch = getchar();

d_linklist head = null;

d_listnode *p, *q;

p = (d_listnode *)malloc(sizeof(d_listnode)); //建立头结点；

head = p ;

while(ch != ‘/n’){

    q = (d_listnode *)malloc(sizeof(listnode));

    q -> data = ch;

    p -> right = q;

    q -> left = p;

    p = q;

}

return head;

}//表尾插入的，带头结点的链；

 

双链表的前插

 

void d_insert_befor(d_listnode *p, datatype x){

d_listnode *q = malloc(sizeof(d_listnode));

q -> data = x;

q -> prior = prior;

q -> next = p;

p -> prior -> next = q;

p ->prior = q;

}

双链表的查找：

 

listnode *locate_d_node(linklist head, int key){

listnode *p = head->next;   //头节点没有值

while(p && p->data != key)

    p = p->right;

   return p;

}//按值查找，值是整型值

 

双链表的删除

 

void d_delete_node(d_listnode *p){

p -> prior -> next = p -> next;

p -> next -> prior = p -> prior ;

free(p);

}