顺序表、链表

先写下顺序表和链表的代码。

=======顺序表======

#include <stdio.h>
#include <stdlib.h>

typedef struct _seqlist_ {
 int * const data;
 int clen;
 int tlen;
}seqlist_t;

seqlist_t *list_init(int len);
int list_destroy(seqlist_t *list);
int list_insert(seqlist_t *list, int value);
int list_show(seqlist_t *list);
int list_delete(seqlist_t *list, int obj);
int list_modify(seqlist_t *list, int old, int new);
int list_search(seqlist_t *list, int obj);
int list_getlen(seqlist_t *list);

int main()
{
 seqlist_t *list;
 int value = 100;

 list = list_init(10);

 puts("insert:");
 while (0 == list_insert(list, value))
  value += 100;
 list_show(list);

#if 0
 list_delete(list, 1500);
 list_show(list);

 puts("modify:");
 list_modify(list, 1400, 3000);
 list_show(list);

 puts("search:");
 if (list_search(list, 1400))
  puts("yes");
 else
  puts("no");
#endif

 printf("Clen: %d\n", list_getlen(list));

 list_destroy(list);

 return 0;
}

seqlist_t *list_init(int len)
{
 seqlist_t *list = NULL;

 list = malloc(sizeof(seqlist_t));
 *(int **)&list->data = malloc(sizeof(int) * len);
list->data = malloc(sizeof(int )* len);
 list->tlen = len;
 list->clen = 0;

 return list;
}

int list_destroy(seqlist_t *list)
{
 free(list->data);
 free(list);

 return 0;
}

int list_insert(seqlist_t *list, int value)
{
 if (list->clen >= list->tlen)
  return -1;

 list->data[list->clen ++] = value;

 return 0;
}

int list_show(seqlist_t *list)
{
 int i;

 printf("Clen: %d\tTlen: %d\n", list->clen, list->tlen);
 for (i = 0; i < list->clen; i++)
  printf("%5d", list->data[i]);
 putchar('\n');

 return 0;
}

int list_delete(seqlist_t *list, int obj)
{
 int i;

 for (i = 0; i < list->clen; i++) {
  if (obj == list->data[i])
   break;
 }
 if (i == list->clen)
  return -1;

 for (; i + 1 < list->clen; i++)
  list->data[i] = list->data[i+1];

 list->clen--;

 return 0;
}

int list_modify(seqlist_t *list, int old, int new)
{
 int i;

 for (i = 0; i < list->clen; i++) {
  if (old == list->data[i])
   break;
 }
 if (i >= list->clen)
      return -1;

     list->data[i] = new;

     return 0;
}

int list_search(seqlist_t *list, int obj)
{
 int i;

 for (i = 0; i < list->clen; i ++) {
  if (obj == list->data[i])
   return 1;
 }

 return 0;
}

int list_getlen(seqlist_t *list)
{
 return list->clen;
}
==========链表=========
#include <stdio.h>
#include <stdlib.h>

typedef struct _linknode_ {
 int data;
 struct _linknode_ *next;
}linknode_t;

typedef struct _linklist_ {
 linknode_t *head;
 int clen;
 int tlen;
}linklist_t;

linknode_t *create_linknode(int value);
linklist_t *list_init(int len);
int list_insert(linklist_t *list, int value);

int main()
{
 linklist_t *list = NULL;
 int value = 100;

 list = list_init(10);

 while (0 == list_insert(list, value))
  value += 100;

 list_show(list);

#if 0
 list_delete();
 list_modify();
 list_search();
 list_getlen();
 list_destroy();
#endif

 return 0;
}

linklist_t *list_init(int len)
{
 linklist_t *list = NULL;

 list = malloc(sizeof(linklist_t));
 list->head = NULL;
 list->clen = 0;
 list->tlen = len;

 return list;
}

int list_insert(linklist_t *list, int value)
{
 linknode_t *new = NULL;

 if (list->clen >= list->tlen)
  return -1;

 new = create_linknode(value);
 new->next = list->head;
 list->head = new;

 list->clen++;

 return 0;
}

linknode_t *create_linknode(int value)
{
 linknode_t *node = NULL;

 node = malloc(sizeof(linknode_t));
 node->next = NULL;
 node->data = value;

 return node;
}
int list_show(linklist_t *list)
{
 linknode_t *p = list->head->next;

 while (NULL != p) {
  printf("%5d", p->data);
  p = p->next;
 }
 putchar('\n');

 return 0;
}

int list_destroy(linklist_t *list)
{
 linknode_t *p = list->head;
 linknode_t *tmp = NULL;

 while (NULL != p) {
  tmp = p;
  p = p->next;
  free(tmp);
 }
 free(list);

 return 0;
}

int list_delete(linklist_t *list, int obj)
{
 linknode_t *p = list->head;
 linknode_t *tmp = NULL;

 while (NULL != p->next && p->next->data != obj)
  p = p->next;
 if (NULL == p->next)
  return -1;

 tmp = p->next;
 p->next = tmp->next;
 free(tmp);

 list->clen--;

 return 0;
}

linknode_t *list_search(linklist_t *list, int obj)
{
 linknode_t *p = list->head->next;

 while (NULL != p && p->data != obj)
  p = p->next;

 return p;
}

int list_modify(linklist_t *list, int old, int new)
{
 linknode_t *p = list->head->next;

 while (NULL != p && p->data != old)
  p = p->next;
 if (NULL == p)
  return -1;

 p->data = new;

 return 0;
}

int list_getlen(linklist_t *list)
{
 return list->clen;
}

int list_reverse(linklist_t *list)
{
 linknode_t *p = list->head->next;
 linknode_t *tmp = NULL;

 list->head->next = NULL;
 while (NULL != p) {
  tmp = p;
  p = p->next;
  tmp->next = list->head->next;
  list->head->next = tmp;
 }

 return 0;
}