基本算法实现小结（一）—— 单链表

各种基本算法实现小结（一）—— 单链表

（均已测试通过）

============================================================

单链表(测试通过)

测试环境： Win-TC

[cpp:showcolumns] view
plaincopy

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

#include <stdio.h>

struct _node

{

int data;

struct _node *next;

};

typedef struct _node list;

void display(list *l)

{

list *p;

p=l;

while(p->next)

{

printf("%5d", p->next->data);

p=p->next;

}

}

void main()

{

int i, n;

list *h, *p, *s;

printf("Enter num n:");

scanf("%d", &n);

h=(list*)malloc(sizeof(list));

h->data=-1;

h->next=NULL;

s=p=h;

for(i=n;i>0;i--)

{

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

scanf("%d", &(p->data));

p->next=h->next;

h->next=p;

h=h->next;

}

display(s);

getch();

}

运行结果：






=================================================

单链表各种操作(测试通过)

测试环境： Win-TC



[b][cpp:showcolumns] view
plaincopy[/b]

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

#include <stdio.h>

#include <malloc.h>

#include <stdlib.h>

struct _node

{

int data;

struct _node *next;

};

typedef struct _node node, *plist;

plist init_list()

{

plist pl;

pl=(plist)malloc(sizeof(node));

if(NULL==pl)

{

printf("init list, malloc is fail.../n");

return NULL;

}

pl->data=-1;

pl->next=NULL;

return pl;

}

int isempty_list(plist pl)

{

if(NULL==pl || NULL!=pl->next)

return 1;

else

return 0;

}

plist clear_list(plist pl)

{

pl=NULL;

return pl;

}

void destroy_list(plist pl)

{

plist p, s;



p=pl->next;

while(p)

{

s=p;

p=p->next;

free(s);

}



pl=NULL;

}

void insert_item(plist pl, int i, int e)

{

int j=1;

plist p, s;

p=pl;

while(p && j<i)

{

p=p->next;

j++;

}

if(!p || j>i) /* >len or <1 */

printf("Insert fail.../n");

s=(plist)malloc(sizeof(node));

s->data=e;

s->next=p->next;

p->next=s;

}

void display(plist pl)

{

plist p;

p=pl->next;

while(pl && p)

{

printf("%5d", p->data);

p=p->next;

}

printf("/n/n");

}

int getbyid_item(plist pl, int i)

{

plist p=pl->next;

int j=1;

while(p && j<i)

{

p=p->next;

j++;

}

if(!p || j>i) /* >len or <1 */

{

printf("fail.../n");

exit(1);

}

return p->data;

}

int locate_item(plist pl, int e)

{

plist p=pl->next;

int j=1;

while(p->data != e && p->next)

{

p=p->next;

j++;

}

if(p->data == e)

return j;

else

{

printf("There is n %d in list/n", e);

return -1;

}

}

void delete_item(plist pl, int i, int *e)

{

plist p=pl;

plist q;

int j=1;

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

{

p=p->next;

j++;

}

if(!p->next || j>i) /* >len or <1 */

{

printf("fail..../n");

return;

}

q=p->next;

p->next=q->next;

*e=q->data;

free(q);

}

int len_list(plist pl)

{

int j=0;

plist p=pl;

while(pl && p->next)

{

j++;

p=p->next;

}

return j;

}

plist traverse_list(plist pl)

{

plist h, p, s;



if(!pl || !pl->next)

return pl;

h=pl->next;

s=h;

p=s->next;

h->next=NULL;

while(p)

{

s=p;

p=p->next;

s->next=h;

h=s;

}

pl->next=h;



return pl;

}

void main()

{

int len, pos, *del;

plist pl=NULL;

del=(int *)malloc(sizeof(int));

pl=init_list();

isempty_list(pl);

insert_item(pl, 1, 1);

insert_item(pl, 2, 3);

insert_item(pl, 3, 5);

insert_item(pl, 4, 7);

insert_item(pl, 5, 9);

insert_item(pl, 6, 11);

display(pl);

len=len_list(pl);

printf("link list len: %d/n", len);

pos=locate_item(pl, 7);

printf("num 7 pos: %d/n", pos);

delete_item(pl, 3, del);

printf("delete pos 3 num: %d/n", *del);

display(pl);

printf("link list traverse.../n");

pl=traverse_list(pl);

display(pl);

destroy_list(pl);

getch();

}

运行结果：






=================================================

单向循环链表(测试通过)

测试环境： Win-TC

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

#include <stdio.h>

#include <malloc.h>

struct _node

{

int data;

struct _node *next;

};

typedef struct _node node, *plist;

plist init_list()

{

plist pl=(plist)malloc(sizeof(node));

if(!pl)

{

printf("error malloc fail.../n");

return NULL;

}

pl->data=-1;

pl->next=pl; /* pl->next=NULL */

return pl;

}

void insert_item(plist pl, int pos, int data)

{

int j=0;

plist p,s;

s=p=pl;

while(p && j<pos-1)

{

p=p->next;

j++;

}

if(!p || j>pos-1)

{

printf("Error insert fail.../n");

return;

}

s=(plist)malloc(sizeof(node));

if(!s)

{

printf("Error malloc fail.../n");

return;

}

s->data=data;

s->next=p->next;

p->next=s;

}

int find_item(plist pl, int data)

{

plist s,p;

s=p=pl;

p=p->next;

while(s != p)

{

if(data==p->data)

return 1;

p=p->next;

}

return 0;

}

void delete_item(plist pl, int data)

{

plist p,s;

s=p=pl;

if(data == p->data) /* first item is equal with data, then last item = second item */

{

s=p;

while(s != p->next)

p=p->next;

p->next=s->next;

return;

}

while(s != p->next) /* first item is not equal with data */

{

if(data == p->next->data)

{

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

return;

}

p=p->next;

}

}

void display(plist pl)

{

plist s,p;

s=p=pl;

printf("%5d", p->data); /* print first item */

p=p->next;

while(s != p)

{

printf("%5d", p->data);

p=p->next;

}

printf("/n/n");

}

void main()

{

int f;

plist pl;

pl=init_list();

insert_item(pl, 1, 1);

insert_item(pl, 2, 3);

insert_item(pl, 3, 5);

insert_item(pl, 4, 7);

insert_item(pl, 5, 9);

display(pl);

printf("Finding 3.../n");

f=find_item(pl, 3);

if(f)

printf("True find 3/n");

else

printf("False find 3.../n");

printf("/nDeleting 1.../n");

delete_item(pl->next, 1);

display(pl->next);

getch();

}

运行结果：



=================================================

双向循环链表(测试通过)

测试环境： Win-TC

[cpp:showcolumns] view
plaincopy

·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150

#include <stdio.h>

#include <malloc.h>

struct _node

{

int data;

struct _node *prior;

struct _node *next;

};

typedef struct _node node, *plist;

plist init_list()

{

plist p;

p=(plist)malloc(sizeof(node));

if(!p)

{

printf("Error, malloc fail.../n");

return NULL;

}

p->data=-1; /* head->data = -1 */

p->prior=p;

p->next=p;

return p;

}

void insert_item(plist pl, int pos, int data)

{

int j=0;

plist s,p;

p=pl;

while(p && j<pos-1)

{

p=p->next;

j++;

}

if(!p || j>pos-1) /* pos is less than 1 or pos larger than len_list+1 */

{

printf("Error %d is invalide num.../n", pos);

return;

}

s=(plist)malloc(sizeof(node));

if(!s)

{

printf("Error, malloc fail.../n");

return NULL;

}

s->data=data;

s->prior=p;

s->next=p->next;

p->next->prior=s;

p->next=s;

}

int find_item(plist pl, int data)

{

plist s,p;

s=p=pl;

if(data == p->data)

return 1;

p=p->next;

while(s != p)

{

if(data == p->data)

return 1;

p=p->next;

}

return 0;

}

void delete_item(plist pl, int data)

{

plist s,p;

s=p=pl;

if(data == p->data) /* first check equal */

{

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

p->next=p->prior;

return;

}

while(s != p->next)

{

if(data == p->next->data)

{

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

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

}

p=p->next;

}

}

void display(plist pl)

{

plist s,p;

s=p=pl;

printf("%5d", p->data); /* first item, such as head->data is -1 */

p=p->next;

while(s != p)

{

printf("%5d", p->data);

p=p->next;

}

printf("/n/n");

}

void main()

{

int f;

plist pl;

pl=init_list();

insert_item(pl, 1, 1);

insert_item(pl, 2, 3);

insert_item(pl, 3, 5);

insert_item(pl, 4, 7);

insert_item(pl, 5, 9);

display(pl);

printf("Finding 3.../n");

f=find_item(pl->next->next, 3);

if(f)

printf("True find 3/n");

else

printf("Fail find 3.../n");

printf("Finding 6.../n");

f=find_item(pl->prior->prior, 6);

if(f)

printf("True find 6/n");

else

printf("Fail find 6.../n");

printf("/nDeleting 3.../n");

delete_item(pl->next->next, 3);

display(pl);

getch();

}

运行结果：



======================================================

以上代码，均在Win-TC 1.9.1 编译器环境测试通过（测试部分用例）

由于刚刚学习算法，编程水平有限，以上代码多有考虑不周或错误

欢迎大家在下面留言，改正或优化代码，给予指点或建议，谢谢！