线性表的链式存储结构c语言

㈠ c语言基础知识中：线性表的顺序、链式存储结构分别是：随机存取和顺序存取结构对吗

不对，数组是随机存取，所有的线性表都是顺序存取结构。你想想，我要找第5个元素，用数组直接 A[4] 就找到了，而线性表就要从“头”元素开始一个一个地往后遍历，直到需要的那个，随机不了。

㈡ C语言二级考试循环链表是循环队列的链式存储结构

循环队列本身是一种顺序存储结构，而循环列表是一种链式存储结构。两者之间是平级关系。

线性链表是线性表的链式存储结构，包括单链表，双链表，循环链表等。

队列的顺序存储结构一般采用循环队列的形式。

循环队列的操作是按数组取摸运算的，所以是顺序存储，而循环链表本身就是收尾相连的，所以循环链表不是循环队列，两种不同的存储结构，虽然实现的功能是一样的，实现循环两种方式 顺序存储就是循环队列，链式存储就是循环链表。

(2)线性表的链式存储结构c语言扩展阅读：

1、比顺序存储结构的存储密度小(链式存储结构中每个结点都由数据域与指针域两部分组成，相比顺序存储结构增加了存储空间)。

2、逻辑上相邻的节点物理上不必相邻。

3、插入、删除灵活 (不必移动节点，只要改变节点中的指针)。

4、查找节点时链式存储要比顺序存储慢。

5、每个节点是由数据域和指针域组成。

6、由于簇是随机分配的，这也使数据删除后覆盖几率降低，恢复可能提高。

㈢ c语言 建立线性表 链式 请写出代码

#include<stdio.h>
#include<stdlib.h>
typedef char elemtype;
typedef struct dnode
{elemtype data;
struct dnode *prior;
struct dnode *next;
}dlinklist;

void displist(dlinklist *L);
int listlength(dlinklist *L);
void list (void);
void initlist (dlinklist *&L);
void destorylist (dlinklist *L);
int listempty(dlinklist *L);
void listdelete (dlinklist *L,int i,elemtype &e);
void getelem (dlinklist *L,int i, elemtype &e);
int locateelem(dlinklist *L,elemtype e);
int listinsert (dlinklist *L,int i, elemtype e);

#include "head.h"
int length;
#include "head1.h"
int main (void)
{char ch;
dlinklist *L;
elemtype e;
int i;
while(1)
{list();
ch=getchar();getchar();
switch(ch)
{case '0': exit(0);
case '1': initlist(L);break;
case '2': destorylist(L);break;
case '3': printf("The length is %d\n",listlength(L));break;
case '4': if(listempty(L)) printf("表不空！\n");
else printf("表空！\n");break;
case '5': printf("请输入要取的元素的序号(1-%d)\n",length);scanf("%d",&i);getchar();
if(i>length)printf("只有%d个元素\n",length);
else if(length==0) printf("空表！\n");
else {getelem(L,i,e);printf("第%d个元素为%c\n",i,e);}break;
case '6': printf("请输入要找的元素\n"); scanf("%c",&e);getchar();i=locateelem(L,e);
if(i==0) printf("未找到！\n");
else printf("%c为第%i个元素\n",e,i);break;
case '7': printf("请输入要插入的元素及其序号(1-%d)\n",length+1);
scanf("%c%d",&e,&i);getchar();
if(listinsert(L,i,e))
printf("插入成功！\n");
else printf("插入失败！\n");break;
case '8': if(!listempty(L)) printf("空表\n");
else displist(L);break;
case '9': printf("请输入要删除的元素的序号:\n"); scanf("%d",&i);getchar();
if (i>length) printf("只有%d个元素!\n",length);
listdelete(L,i,e); printf("删除的元素为%c\n",e); break;
default: printf("输入错误！请重新输入\n");
}
}
return 0;
}
#include <stdio.h>
void list (void)
{printf("***************************************\n");
printf("1: 初始化链表 2: 释放链表\n");
printf("3: 求元素个数 4: 链表判空\n");
printf("5: 取第i 元素 6: 找元素e \n");
printf("7: 插入元素e 8: 输出链表\n");
printf("9: 删除第i 元 0: 退出程序\n");
printf("***************************************\n");
printf(" 请在上述功能中选择(0-9):");
}

#include"head.h"
extern int length;
void destorylist (dlinklist *L)
{ dlinklist *p=L->next;
if (length!=0)
{while(p!=L)
{L->next=p->next;
p->next->prior=L;
free(p);p=L->next;
}
length=0;
}
}

void displist(dlinklist *L)
{dlinklist *p=L->next;
while(p!=L)
{printf("%c ",p->data); p=p->next;}
printf("\n");
}

void getelem (dlinklist *L,int i, elemtype &e)
{int j=1;dlinklist *p=L->next;
while(p!=L&&j<i)
{p=p->next;j++;}
e=p->data;
}
extern int length;
void initlist (dlinklist *&L )
{
L=(dlinklist *)malloc(sizeof(dlinklist));
if(!L)
printf("初始化失败！\n");
else
{length=0;L->next=L->prior=L;}
}

void listdelete (dlinklist *L,int i,elemtype &e)
{dlinklist *p=L->next;
int j=1;
while(p!=L&&j<i)
{p=p->next;j++;}
if(j==i)
{p->prior->next=p->next;
p->next->prior=p->prior;
e=p->data;free(p);
length--;}
}

int listempty(dlinklist *L)
{
int i=0;
dlinklist *p=L->next;
while(p!=L)
{p=p->next;i++;}
return i;
}

int listinsert (dlinklist *L,int i, elemtype e)
{dlinklist *p=L->next,*q;int j=1;
while(p!=L&&j<i)
{p=p->next;j++;}
if(j==i)
{q=(dlinklist *)malloc(sizeof(dlinklist));
if(!q) return 0;
q->data=e; length++;
q->prior=p->prior;
p->prior->next=q;
q->next=p;
p->prior=q;
return 1;
}
else return 0;
}

int listlength(dlinklist *L)
{return length;
}

int locateelem(dlinklist *L,elemtype e)
{dlinklist *p=L->next;
int i=1;
while(p!=L&&p->data!=e)
{p=p->next;i++;}
if(p->data!=e)return 0;
else return i;
}

㈣ c语言线性表链式结构中如何存储数据

对于LinkList
L:
L是指向定义的node
结构体
的指针,可以用->运算符来访问结构体成员,即L->elem,而(*L)就是个Node型的结构体了,可以用点运算符访问该结构体成员,即(*L).elem;
对于LinkList
*L:L是指向定义的Node结构体指针的指针,所以(*L)是指向Node结构体的指针,可以用->运算符来访问结构体成员,即(*L)->elem,当然,(**L)就是Node型结构体了,所以可以用点运算符来访问结构体成员,即(**L).elem;
在
链表
操作中,我们常常要用链表变量作物函数的参数,这时,用LinkList
L还是LinkList
*L就很值得考虑深究了,一个用不好,函数就会出现逻辑错误,其准则是:
如果函数会改变指针L的值,而你希望函数结束调用后保存L的值,那你就要用LinkList
*L,这样,向函数传递的就是指针的地址,结束调用后,自然就可以去改变指针的值;
而如果函数只会修改指针所指向的内容,而不会更改指针的值,那么用LinkList
L就行了

㈤ 1、线性表顺序存储方式操作2、线性表链式存储方法操作：。两个都用c语言

下面是从我的博客里面给你找的，你参考一下。更多的数据结构的内容，也可以去看我的博客。

/************************************************************
说明：
1、主函数内的代码是为了测试方便，可以自行修改。
2、宏定义NEWS是人机交互信息提示，若不需要，可修改为0。
3、若是windows系统，请将258行中的clear修改为cls。
4、在输入数据后，请多按一下回车，实现清屏。
环境：ubuntu12.04LTS、codeblocks10.05、2014-04-02
************************************************************/
#include<iostream>
#include<stdlib.h>
#include<malloc.h>
#include<cstring>
#defineNEWS1
#defineLIST_INIT_SIZE100
#defineLIST_ADD_SIZE10
#defineNEW_SIZE(L->list_size+LIST_ADD_SIZE)
usingnamespacestd;
typedefintElem_Type;
typedefstruct
{
Elem_Type*data;//元素
intlen;//长度
intlist_size;//空间
}Sq_List;
typedefenum
{
OK=0,//正常
ERROR=-1,//逻辑异常
OVER=-2//内存异常
}Status;
/******************************
函数名：Init_List
功能：构造、初始化线性表
******************************/
Sq_List*Init_List(void)
{
Sq_List*L=(Sq_List*)malloc(sizeof(Sq_List));
if(!L)
exit(OVER);
L->data=(Elem_Type*)malloc(LIST_INIT_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);
L->len=0;
L->list_size=LIST_INIT_SIZE;
#if(NEWS)
cout<<"构造成功，已初始化"<<endl;
#endif
returnL;
}
/******************************
函数名：Destroy_List
功能：销毁线性表
******************************/
StatusDestroy_List(Sq_List*L)
{
free(L);
#if(NEWS)
cout<<"销毁成功，请不要再使用"<<endl;
#endif
returnOK;
}
/******************************
函数名：Clear_List
功能：清空线性表
******************************/
StatusClear_List(Sq_List*L)
{
memset(L->data,-1,sizeof(L->data));
L->len=0;
#if(NEWS)
cout<<"已全部清空"<<endl;
#endif
returnOK;
}
/******************************
函数名：Empty_List
功能：判断线性表是否为空
******************************/
boolEmpty_List(Sq_List*L)
{
returnL->len==0;
}
/******************************
函数名：Length_List
功能：获取线性表长度
******************************/
intLength_List(Sq_List*L)
{
returnL->len;
}
/******************************
函数名：Get_Elem_List
功能：指定位置获取元素
******************************/
StatusGet_Elem_List(Sq_List*L,intindex,Elem_Type*e)
{
if(!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"获取位置不合法"<<endl
<<"下面显示的数据是上次输入的num的值,请注意！！！"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
returnOK;
}
/******************************
函数名：Insert_List
功能：指定位置插入元素
******************************/
StatusInsert_List(Sq_List*L,intindex,Elem_Typee)
{
if(!(1<=index&&index<=Length_List(L)+1))
#if(NEWS)
{
cout<<"插入位置不合法"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
if(Length_List(L)>=L->list_size)
#if(NEWS)
cout<<"刚才增加了存储空间"<<endl;
#endif
L->data=(Elem_Type*)realloc(L->data,NEW_SIZE*sizeof(Elem_Type));
if(!L->data)
exit(OVER);

L->list_size+=LIST_ADD_SIZE;

for(inti=Length_List(L);i>=index-1;i--)
L->data[i+1]=L->data[i];

L->data[index-1]=e;
L->len++;
#if(NEWS)
cout<<"插入成功"<<endl;
#endif
returnOK;
}
/******************************
函数名：Delete_List
功能：指定位置删除元素
******************************/
StatusDelete_List(Sq_List*L,intindex,Elem_Type*e)
{
if(Empty_List(L)||!(1<=index&&index<=Length_List(L)))
#if(NEWS)
{
cout<<"删除位置不合法or目前是空表"<<endl;
returnERROR;
}
#else
returnERROR;
#endif
*e=L->data[index-1];
for(inti=index;i<Length_List(L);i++)
L->data[i-1]=L->data[i];
#if(NEWS)
cout<<"删除成功"<<endl;
#endif
L->len--;
returnOK;
}
/******************************
函数名：Print_List
功能：输出所有元素
******************************/
StatusPrint_List(Sq_List*L)
{
if(Empty_List(L))
returnERROR;
inttemp;
for(inti=1;i<=Length_List(L);i++)
{
Get_Elem_List(L,i,&temp);
cout<<temp<<"";
}
cout<<endl;
returnOK;
}
/******************************
函数名：print_news
功能：方便用户选择
******************************/
voidprint_news(void)
{
cout<<" ********************"
<<"*****************************"<<endl
<<" * 0建立、初始化 *"<<endl
<<" * *"<<endl
<<" * 1插入元素 *"<<endl
<<" * *"<<endl
<<" * 2删除元素 *"<<endl
<<" * *"<<endl
<<" * 3销毁 *"<<endl
<<" * *"<<endl
<<" * 4获取表长 *"<<endl
<<" * *"<<endl
<<" * 5清空 *"<<endl
<<" * *"<<endl
<<" * 6获取元素 *"<<endl
<<" * *"<<endl
<<" * 7打印 *"<<endl
<<" * *"<<endl
<<" * 8退出程序 *"<<endl
<<" ********************"
<<"*****************************"<<endl;
}
intmain(void)
{
Sq_List*test=NULL;
while(true)
{
print_news();
intchoose,index,num;
cout<<"要进行什么操作？"<<endl;
cin>>choose;
switch(choose)
{
case0:
test=Init_List();break;
case1:
cout<<"插入位置"<<endl;
cin>>index;
cout<<"插入数据"<<endl;
cin>>num;
Insert_List(test,index,num);break;
case2:
cout<<"删除的位置"<<endl;
cin>>index;
Delete_List(test,index,&num);
cout<<"被删除的元素是："<<num<<endl;break;
case3:
Destroy_List(test);break;
case4:
cout<<Length_List(test)<<endl;break;
case5:
Clear_List(test);break;
case6:
cout<<"获取哪个位置的元素"<<endl;
cin>>index;
Get_Elem_List(test,index,&num);
cout<<num<<endl;break;
case7:
Print_List(test);break;
case8:
return0;
default:
break;
}
getchar();
getchar();
system("clear");
}
return0;
}

㈥ 数据结构（C语言版） 线性表的链式存储

1、假设单链表为带头结点的单链表
int ListDelete(LinkList *L,int i)
{
LinkList *p; int j=0;
p=L;
while(p->next!=NULL && j<i-1)
{p=p->next; j++;
}
if (p->next==NULL || j>i-1)
{printf("不存在第i个结点\n");return 0;}
q=p->next;p->next; p->next=q->next;
free(q); return 1;
}
2、位置i和结点s的data成员在键盘输入，是要求写在函数中吗？一般应该是通过参数传递的才对啊，确认后再给你程序吧

㈦ 用C语言编写链式存储结构下实现线性表的创建,插入,删除,按值查找

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

typedef struct LNode{
int data; //链表数据
struct LNode* next; //链表指针
}LNode,*LinkList;

/*头插法-建立单链表*/
LinkList HeadCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode)); //建立头结点
la->next=NULL;
scanf("%d",&num);
while(num!=10)
{
LNode *p=(LinkList)malloc(sizeof(LNode));
p->data=num;
p->next=la->next;
la->next=p;
scanf("%d",&num);
}
return la;
}

/*尾插法-建立单链表*/
LinkList TailCreate(LinkList la)
{
int num;
la=(LinkList)malloc(sizeof(LNode));
la->next=NULL;
LinkList s,r=la;
scanf("%d",&num);
while(num!=10)
{
s=(LinkList)malloc(sizeof(LNode));
s->data=num;
r->next=s;
r=s;
scanf("%d",num);
}
r->next=NULL;
return la;
}

/*单链表遍历*/
void TravelList(LinkList la)
{
LinkList p=la->next;
while(p!=NULL)
{
printf("%d->",p->data);
p=p->next;
}
printf("\n");
}

/*单链表的按位查找*/
LinkList GetElem(LinkList la,int i)
{
int j=1;
LNode* p=la->next;
if(i<1)
return NULL;
while(p && j<i)
{
p=p->next;
j++;
}
return p;
}

/*单链表的按值查找*/
LinkList LocalElem(LinkList la,int e)
{
LNode* p=la->next;
while(p!=NULL && p->data!=e)
p=p->next;
return p;
}

/*单链表插入操作*/
bool InsertList(LinkList la,int i,int e)
{
//在la链表中的i位置插入数值e
int j=1;
LinkList p=la,s;
while(p && j<i)
{
p=p->next;
j++;
}
if(p==NULL)
return false;
if((s=(LinkList)malloc(sizeof(LNode)))==NULL)
return false;
s->data=e;
s->next=p->next;
p->next=s;
return true;
}

/*单链表删除操作*/
bool DeleteList(LinkList la,int i)
{
int j=1;
LinkList p=la,q;
while(p && j<i) //p指向第i-1个元素
{
p=p->next;
j++;
}
if(p==NULL || p->next==NULL) //表示不存在第i-1个和第i的元素
return false;
q=p->next;
p->next=q->next;
free(q);
return true;
}

/*单链表的表长*/
int LengthList(LinkList la)
{
int nLen=0;
LinkList p=la->next;
while(p)
{
p=p->next;
nLen++;
}
return nLen;
}

/*单链表逆置*/
LinkList Reserve(LinkList la)
{
if(la==NULL || la->next==NULL)
return la;
LinkList p=la->next,q=p->next,r=q->next;
la->next=NULL;
p->next=NULL;
while(r!=NULL)
{
q->next=p;
p=q;
q=r;
r=r->next;
}
q->next=p;
la->next=q;
return la;
}

int main()
{
LNode la;
LinkList p;
p=HeadCreate(&la); //头插法创建单链表
TravelList(p);
printf("%p\n",GetElem(p,1)); //获得第1个结点地址
InsertList(p,2,10); //在链表的第2个位置插入元素10
TravelList(p);
DeleteList(p,3); //删除链表的第3个元素
TravelList(p);
printf("%d\n",LengthList(p)); //获得链表长度
p=Reserve(p);
TravelList(p);
return 0;
}

//运行结果
//5 6 12 7 8 14 9 3 2 5 14 10 头插法创建链表
//14->5->2->3->9->14->8->7->12->6->5-> 显示链表
//00382490 第一个结点的地址
//14->10->5->2->3->9->14->8->7->12->6->5-> 插入元素值为10的结点
//14->10->2->3->9->14->8->7->12->6->5-> 删除第三个结点
//11 获得链表长度
//5->6->12->7->8->14->9->3->2->10->14-> 链表逆置
//Press any key to continue

这是我写的一个线性表链式存储的综合程序，包含了你所要的创建、删除、插入、按值查找的功能，还有一些额外的功能。下面加注释的是程序运行结果，你可以参考试着改改程序，让程序更加完美。希望对你有帮助，呵呵！

㈧ 求一个简单的线性表（链式的，用C语言）

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

/************************************************************************/
/* 常量定义 */
/************************************************************************/
#define ElemType int
#define Status int
#define TRUE 1
#define OK 1
#define FALSE 0
#define ERROR -1

/************************************************************************/
/* 线性表的单链表存储结构*/
/************************************************************************/
typedef struct LNode
{
ElemType data;
struct LNode *next;
}LNode, *LinkList;

//////////////////////////////////////////////////////////////////////////
//
// 带有头结点的单链表的基本操作(13个)
//
//////////////////////////////////////////////////////////////////////////

/************************************************************************/
/* 操作结果：构造一个空的线性表L */
/************************************************************************/
void InitList(LinkList *L)
{
*L = (LinkList)malloc(sizeof(struct LNode)); /* 产生头结点，并使L指向此头结点 */
if( !*L ) /* 存储分配失败 */
exit(OVERFLOW);
(*L)->next = NULL; /* 指针域为空 */
}

/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：销毁线性表L */
/************************************************************************/
void DestroyList(LinkList *L)
{
LinkList q;
while(*L)
{
q = (*L)->next;
free(*L);
*L=q;
}
}
/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：将L重置为空表 */
/************************************************************************/
void ClearList(LinkList L) /* 不改变L */
{
LinkList p, q;
p = L->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
q = p->next;
free(p);
p = q;
}
L->next = NULL; /* 头结点指针域为空 */
}

/************************************************************************/
/* 初始条件：线性表L已存在。*/
/* 操作结果：若L为空表，则返回TRUE，否则返回FALSE */
/************************************************************************/
Status ListEmpty(LinkList L)
{
/* 非空 */
return (L->next) ? FALSE : TRUE;
}

/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：返回L中数据元素个数 */
/************************************************************************/
int ListLength(LinkList L)
{
int i = 0;
LinkList p = L->next; /* p指向第一个结点 */
while(p) /* 没到表尾 */
{
i++;
p = p->next;
}
return i;
}

/************************************************************************/
/* L为带头结点的单链表的头指针。*/
/* 当第i个元素存在时，其值赋给e并返回OK，否则返回ERROR */
/************************************************************************/
Status GetElem(LinkList L, int i, ElemType *e) /* 算法2.8 */
{
int j = 1; /* j为计数器 */
LinkList p = L->next; /* p指向第一个结点 */
while(p && j < i) /* 顺指针向后查找，直到p指向第i个元素或p为空 */
{
p = p->next;
j++;
}
if( !p || j > i) return ERROR; /* 第i个元素不存在 */

*e = p->data; /* 取第i个元素 */
return OK;
}

/************************************************************************/
/* 初始条件: 线性表L已存在，compare()是数据元素判定函数(满足为1，否则为0)*/
/* 操作结果: 返回L中第1个与e满足关系compare()的数据元素的位序。 */
/* 若这样的数据元素不存在，则返回值为0 */
/************************************************************************/
int LocateElem(LinkList L, ElemType e, Status(*compare)(ElemType, ElemType))
{
int i = 0;
LinkList p = L->next;
while(p)
{
i++;
if(compare(p->data,e)) /* 找到这样的数据元素 */
return i;
p=p->next;
}
return 0;
}

/************************************************************************/
/* 初始条件: 线性表L已存在 */
/* 操作结果: 若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱 */
/* 返回OK；否则操作失败，pre_e无定义，返回INFEASIBLE */
/************************************************************************/
Status PriorElem(LinkList L, ElemType cur_e, ElemType *pre_e)
{
LinkList q, p = L->next; /* p指向第一个结点 */
while(p->next) /* p所指结点有后继 */
{
q = p->next; /* q为p的后继 */
if(q->data == cur_e)
{
*pre_e = p->data;
return OK;
}
p = q; /* p向后移 */
}
return ERROR;
}

/*************************************************************************/
/* 初始条件：线性表L已存在 */
/* 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继*/
/* 返回OK; 否则操作失败，next_e无定义，返回INFEASIBLE */
/*************************************************************************/
Status NextElem(LinkList L, ElemType cur_e, ElemType *next_e)
{
LinkList p = L->next; /* p指向第一个结点 */
while(p->next) /* p所指结点有后继 */
{
if(p->data == cur_e)
{
*next_e = p->next->data;
return OK;
}
p = p->next;
}
return ERROR;
}

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

s = (LinkList)malloc(sizeof(struct LNode)); /* 生成新结点 */
s->data = e; /* 插入L中 */
s->next = p->next;
p->next = s;
return OK;
}

/************************************************************************/
/* 在带头结点的单链线性表L中，删除第i个元素，并由e返回其值 */
/************************************************************************/
Status ListDelete(LinkList L, int i, ElemType *e)
{
int j = 0;
LinkList p = L, q;
while(p->next && j < i-1) /* 寻找第i个结点，并令p指向其前岖 */
{
p = p->next;
j++;
}
if( !p->next || j > i-1) /* 删除位置不合理 */
return ERROR;
q = p->next; /* 删除并释放结点 */
p->next = q->next;
*e = q->data;
free(q);
return OK;
}

/************************************************************************/
/* 初始条件：线性表L已存在。操作结果：依次对L的每个数据元素调用函数vi() */
/************************************************************************/
void ListTraverse(LinkList L, void(*vi)(ElemType))
{
LinkList p = L->next;
while(p)
{
vi(p->data);
p = p->next;
}
printf("\n");
}

/************************************************************************/
/* 初始条件：线性表L已存在。打印链表的data域 */
/************************************************************************/
void ListPrint(LinkList L)
{
LinkList p = L->next;
while(p)
{
printf("%d ", p->data);
p = p->next;
}
printf("\n");
}

void printInt(int data)
{
printf("%d ", data);
}

/************************************************************************/
/* 插入排序 */
/************************************************************************/
void ListSort(LinkList L)
{
LinkList first, p, q; //为原链表剩下用于直接插入排序的节点头指针
LinkList t; //临时指针变量：插入节点

//原链表剩下用于直接插入排序的节点链表
first = L->next;

//只含有一个节点的链表的有序链表
L->next = NULL;

//遍历剩下无序的链表
while (first != NULL)
{
//无序节点在有序链表中找插入的位置
for (t = first, q = L; ((q != NULL) && (q->data < t->data)); p = q, q = q->next);

//退出for循环，就是找到了插入的位置
first = first->next;

p->next = t;

//完成插入动作
t->next = q;
}
}

//排序，指针交换法
void ListSort1(LinkList L)
{
LinkList head = L->next;//head指向除头结点以外的链表
LinkList pre_p; //p的前驱结点
LinkList pre_q; //q的前驱结点
LinkList min; //最小的结点
LinkList p, q, temp;

for(p = head; p->next; pre_p = min, p = min->next)
{
//找出最小的结点
for(min = p, q = p; q->next; q = q->next)
{
if(q->next->data < min->data)
{
pre_q = q;
min = q->next;
}
}

//如果最小是自己 就不需要交换
if(min == p) continue;

//如果p是指向head的结点，则链表直接指向min
if(p == head)
L->next = min;
else
pre_p->next = min;

temp = min->next;
if(p->next == min)
{
min->next = p;
p->next = temp;
}
else
{
min->next = p->next;
pre_q->next = p;
p->next = temp;
}
}
}

//排序，数据选择法排序
void ListSort2(LinkList L)
{
LinkList head = L->next;//head指向除头结点以外的链表
LinkList min; //最小的结点
LinkList p, q; //遍历链表指针
int temp;
for (p = head; p->next; p = p->next)
{
//在p指针后的链表选取最小的结点
for (min = p, q = p->next; q; q = q->next)
{
if (q->data < min->data)
min = q;
}

//两者结点值不相等，数据交换
if (min->data != p->data)
{
temp = min->data;
min->data = p->data;
p->data = temp;
}
}
}

void ListSort3(LinkList L)
{
LinkList first; //指向链表L第一个结点，除头结点
LinkList pre; //指向first的前驱结点
LinkList last; //指向first指向排好序的最后一个结点
LinkList rest; //指向未排好序的第一个结点，即链表第二个结点
LinkList curr; //指向当前结点

first = L->next; //指向第一个结点
if(first == NULL) return;

pre = L ; //pre指向first的前驱结点
last = first; //last指向排好序的最后一个结点
rest = first->next; //指向剩余的结点
first->next = NULL; //first断链

while (rest) //当余下的结点不为空
{
//保存当前结点
curr = rest;

//取下一个结点
rest = rest->next;

//当结点小于第一个结点，则链接到first前面
if( curr->data < first->data )
{
pre->next = curr;
curr->next = first;
pre = curr;
}
//当前结点大于第一个结点，则链接到last后
else if(curr->data > first->data)
{
curr->next = last->next;
last->next = curr;
last = curr;
}
//当前结点与第一个结点相等，则链接到first后面
else
{
curr->next = first->next;
first->next = curr;
}
}
}

void main()
{
LinkList L;
InitList(&L);
ListInsert(L, 1, 6);
ListInsert(L, 2, 3);
ListInsert(L, 3, 67);
ListInsert(L, 4, 2);
ListInsert(L, 5, 15);
ListInsert(L, 6, 13);
ListInsert(L, 7, 10);
ListInsert(L, 8, 6);
ListInsert(L, 9, 4);

ListSort3(L);
ListTraverse(L, printInt);
}

㈨ 用C语言实现定义线性表的链式存储结构

#include<stdio.h>
#include<malloc.h>
typedef struct{
int *elem;
int length;
int listsize;}sqlist;

int init_List(sqlist &L){
L.elem=(int*)malloc(100*sizeof(int));
if(!L.elem) return 0;
else
L.length=0;
L.listsize=100;return 1;}

void main(){
sqlist l;
int *p;int a;int e;int b;
int i;
if(!init_List(l)) printf("内存分配失败");
else
p=l.elem;
printf("输入线性表的长度l.length的值:\n");
scanf("%d",&l.length);
printf("输入%d个数:\n",l.length);
for(i=0;i<l.length;i++)
scanf("%d",p++);
printf("创建的线性表为:\n");
for(i=0;i<l.length;i++)
printf("%d\n",l.elem[i]);｝