数据结构单链表代码

数据结构单链表代码
数据结构单链表代码

#include

#include

#define TRUE 1

#define FALSE 0

#define OK 1

#define ERROR 0

#define NULL 0

#define OVERFLOW -2

typedef int status;

typedef int ElemType;

typedef struct LNode

{

ElemType data;

struct LNode *next;

}LNode,*LinkList;

status InitList_Link(LinkList &L)//构造空的链表-----------

{

L=(LinkList)malloc(sizeof(LNode));

if(!L) exit( OVERFLOW);

L->next=NULL;

return OK;

}

status ListInsert_Link(LinkList &L,int i,ElemType e)//在L中第i个位置插入元素e----------------- {

LinkList p=L;int j;

while(p && j

{

p=p->next;

++j;

}

if(!p || j>i-1) return ERROR;//不存在P或者指向的位置超过的i

LinkList s=(LinkList)malloc(sizeof(LNode));//创建新的节点

s->data=e;

s->next=p->next;

p->next=s;

return OK;

}

status DestroyList_Link(LinkList &L,int i,ElemType &e)//在L中删除第i个元素,由e返回值{

LinkList p=L; int j=0;

while(p->next && j

{

p=p->next;

++j;

}

if(!(p->next) ||j>i-1 )return ERROR;

LinkList q=p->next;//重新定义指针使其指向的是所要删除的位置

p->next=q->next;

e=q->data;free(q);

return OK;

}

status CreateList_Link(LinkList &L,int n)//逆序输入n个元素的值,建立带表头的单链表L {

//LinkList L;

L=(LinkList)malloc(sizeof(LNode));

L->next=NULL;//先建立的是一个带头结点的空的单链表

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

{

LinkList p;//生成新结点

p=(LinkList)malloc(sizeof(LNode));

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

p->next=L->next;//插入表头

L->next=p;

}

return OK;

}

void print(LinkList &L)

{

while(L->next !=NULL)

{

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

L=L->next;

}

printf("\n");

}

status DestroyList_Link(LinkList &L)//销毁链表

{

LinkList p,q;

p=L;q=L;//同时指向带头结点

while(p->next)//如果的L链表存在数值

{

q=p;

p=p->next;

free(q);

}

return OK;

}

status ClearList_Link(LinkList &L)//清空链表

{

LinkList p=L->next;

while(p)

{

p->data=NULL;

p=p->next;//指针下移

}

return OK;

}

status ListEmpty_Link(LinkList L)

{

LinkList p=L;

if(p->next) return TRUE;

else return FALSE;

}

int ListLength_Link(LinkList L)

{

int len=0;

LinkList p=L;

while(p->next)

{

len++;

p=p->next;

}

return len;

}

void MergeList_Link(LinkList &La,LinkList &Lb,LinkList &Lc) {//合并两个有序的单链表

LinkList pa,pb,pc;

pa=La->next; pb=Lb->next;

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);

}

/******删除线性表中重复的元素*********/ void main()

{

LinkList L;

InitList_Link(L);

CreateList_Link(L,5);

printf("为删除前的表是:");

print(L);

LinkList p,s;

p=L->next;

s=L->next->next;

while(p)

{

while(s)

{

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

{

p->next=s->next;

free(s);

}

s=s->next;

}

p=p->next;

s=p->next;

}

printf("删除重复元素后的表是:");

print(L);

DestroyList_Link(L);

}

/*void main()

{

LinkList La,Lb,Lc;

//int e;

InitList_Link(La);

InitList_Link(Lb);

CreateList_Link(La,5);

CreateList_Link(Lb,8);

MergeList_Link(La,Lb,Lc);

//DestroyList_Link(L);

//DestroyList_Link(L,2,e);

//printf("%d",e);

print(La);

print(Lb);

print(Lc);

printf("\n");

}*/

数据结构 单链表基本操作代码

实验一单链表 #include "stdio.h" #include "stdlib.h" typedef int ElemType; typedef struct LNode { ElemType data; struct LNode *next; }LNode,*LinkList; void creatLNode(LinkList &head) { int i,n; LNode *p; head=(LNode*)malloc(sizeof(LNode)); head->next=NULL; printf("请输入链表的元素个数:"); scanf("%d",&n); for(i=n;i>0;i--) { p=(LNode*)malloc(sizeof(LNode)); printf("第%d个元素:",i); scanf("%d",&p->data); p->next=head->next; head->next=p; } } void InsertLNode(LinkList &L) { LNode *p=L; int i,j=0,e; printf("请输入你要插入的位置(超过链表长度的默认插在最后!):"); scanf("%d",&i); printf("请输入你要插入的元素:"); scanf("%d",&e); while (p->next&&jnext; ++j; }

LNode *s; s=(LNode*)malloc(sizeof(LNode)); s->data=e; s->next=p->next; p->next=s; } int DeleteLNode(LinkList &L,int i,int &e) { LNode *p; p=L; LNode *q; int j=0; while (p->next&&jnext; ++j; } if(!(p->next)||j>i-1) { printf("删除位置不合理!\n"); return 0; } q=p->next; p->next=q->next; e=q->data; free(q); return e; } void DeleteCF(LinkList &L) { LNode *p,*s,*r; p=L->next; while(p!=NULL) { r=p; s=r->next; while(s!=NULL) { if(p->data==s->data) { r->next=s->next; s=s->next;

数据结构题目及c语言代码

目题程设计《数据结构》课)C语言程序实现采用():3选王(学时目 题1:猴子一堆猴子都有编号,编号是1,2,3 ...m,这群猴子(m个)按照1-m 的顺序围坐一圈,从第1开始数,每数到第n个,该猴子就要离开此圈,这样依次下来,直到圈中只剩下最后一只猴子,则该猴子为大王。 要求:m及n要求从键盘输入,存储方式采用向量及链表两种方式实现该问题求解。 //链表 #include #include // 链表节点 typedef struct _RingNode { int pos; struct _RingNode *next; }RingNode, *RingNodePtr; // 创建约瑟夫环,pHead:链表头指针,count:链表元素个数 void CreateRing(RingNodePtr pHead, int count) { RingNodePtr pCurr = NULL, pPrev = NULL; int i = 1; pPrev = pHead; while(--count > 0) {

pCurr = (RingNodePtr)malloc(sizeof(RingNode)); i++; pCurr->pos = i; pPrev->next = pCurr; pPrev = pCurr; } pCurr->next = pHead; // 构成环状链表 } void KickFromRing(RingNodePtr pHead, int n) { RingNodePtr pCurr, pPrev; int i = 1; // 计数 pCurr = pPrev = pHead; while(pCurr != NULL) { if (i == n) { // 踢出环 printf(\ %d, pCurr->pos); // 显示出圈循序 pPrev->next = pCurr->next;

数据结构课程设计单链表操作汇总

《数据结构课程设计》报告 题目:单链表操作 专业:计算机科学与技术 班级: 单链表操作 针对带头结点的单循环链表,编写实现以下操作的算法函数。

实现要求: ⑴单链表建立函数create:先输入数据到一维数组A[M]中,然后根据一维 数组A[M]建立一个单循环链表,使链表中个元素的次序与A[M]中各元素的次序相同,要求该函数的时间复杂度为O(m); ⑵定位查找函数Locate:在所建立的单循环链表中查找并返回值为key的 第1个元素的结点指针;若找不到,则返回NULL; ⑶求出该链表中值最大和次大的元素值,要求该算法的时间复杂度为O(m), 最大和次大的元素值通过指针变量带回,函数不需要返回值; ⑷将链表中所有值比key(值key通过形参传入)小的结点作为值为key的结 点前驱,所有值比key大的结点作为值为key的结点后继,并尽量保持原有结点之间的顺序,要求该算法的时间复杂度为O(m); ⑸设计一个菜单,具有上述处理要求和退出系统功能。 ⒈本人完成的工作: 一、定义结构体:LNode 二、编写以下函数: (1)建立单循环链表 (2)建立定位查找函数 (3)求出链表中最大和次大值 (4)将链表中的值和输入的Key比较,小的作为key前驱结点,大的作为key 的后继结点 三、设计具有上述处理要求和退出系统菜单 ⒉所采用的数据结构:单链表 数据结构的定义: typedef struct Node //定义结点的结构体 { DataType data; //数据域 struct Node *next; //指针域

}LNode; //结点的类型 ⒊所设计的函数 (1)Create(void) LNode *Create(void) //建立单循环链表,链表头结点head作为返回值{ int i,j,n,A[M]; //建立数组A【M】 LNode *head,*p,*move; head=(LNode*)malloc(sizeof(LNode)); //创建空单循环链表head->next=head; move=head; printf("请输入数组元素的个数:"); //输入数组 scanf("%d",&n); printf("请输入数组:"); for(i=0;idata=A[j]; p->next=move->next; move->next=p; move=move->next; } return head; //返回头指针

数据结构 单链表详解

数据结构的概念: 数据的逻辑结构+ 数据的存储结构+ 数据的操作; 数据的数值:=====》数据===》数值型数据整形浮点数ASCII 非数值型数据图片声音视频字符 =====》数据元素=====》基本项组成(字段,域,属性)的记录。 数据的结构: 逻辑结构 ----》线性结构(线性表,栈,队列) ----》顺序结构 ----》链式结构 ----》非线性结构(树,二叉树,图) ----》顺序结构 ----》链式结构 存储结构 -----》顺序存储 -----》链式存储 -----》索引存储 -----》哈希存储==散列存储 数据的操作: 增 删 改 查 DS ====》数据结构===》DS = (D,R); 数据结构中算法: 1、定义:有穷规则的有序集合。 2、特性: 有穷性 确定性

输入 输出 3、算法效率的衡量 时间复杂度计算===》算法中可执行依据的频度之和,记为:T(n)。 是时间的一种估计值不是准确值。 计算结果的分析:1 将最终结果的多项式中常数项去掉 2 只保留所有多项式中最高阶的项 3 最后的最高阶项要去掉其常数项 时间复杂度的量级关系: 常量阶====》对数阶===》线性阶===》线性对数阶====》平方阶===》立方阶===》指数阶 以上关系可以根据曲线图来判断算法对时间复杂度的要求 空间复杂度计算====》算法执行过程中所占用的存储空间的量级,记为:D(n)。 计算方法是在运行过程中申请的动态内存的量级计算。 ///////////////////////////////////////////////////////////////////////////////////////////////// 线性表 顺序存储====》顺序表(数组) 链式存储====》单链表 特征:对于非空表,a0是表头没有前驱。 an-1 是表尾没有后继 ai的每个元素都有一个直接前驱和直接后继 基本操作:创建表=====》增加元素====》删除元素====》改变元素值====》查询元素 1、顺序表的操作 1.1 创建顺序表=====》定义个指定类型的数组====》int a[100] ={0};

数据结构:树形结构完整代码,各种遍历方法,直接能跑

#include #include #define TElemType int typedef struct BiTNode { TElemType data; struct BiTNode *lchild, *rchild; } BiTNode, *BiTree; typedef BiTree DataType; typedef struct queuenode{ DataType data; struct queuenode *next; } QueueNode; //LINKQUEUE //HEAD POINTER, AND REAR POINTER ARE A V ALIBALE typedef struct { QueueNode *front; QueueNode *rear; } LinkQueue; int InitQueue(LinkQueue *Q); int DestroyQueue(LinkQueue *Q); int QueueEmpty(LinkQueue Q); int EnQueue(LinkQueue *Q, DataType e); DataType DeQueue(LinkQueue *Q); int CreateBiTree(BiTree *T); int PreOrderTraverse(BiTree T, int (*visit)(TElemType e)); int PreOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int InOrderTraverse(BiTree T, int (*visit)(TElemType e)); int InOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int PostOrderTraverse(BiTree T, int (*visit)(TElemType e)); int PostOrderTraverse2(BiTree T, int (*visit)(TElemType e)); int LevelOrderTraverse(BiTree T, int (*visit)(TElemType e)); int printElem(TElemType e); int InitBiTree(BiTree *T); int DestroyBiTree(BiTree *T); int ClearBiTree(BiTree *T); int BiTreeEmpty(BiTree T); int BiTreeDepth(BiTree T);

c数据结构单链表的建立与基本应用

#include"stdio.h" #include"stdlib.h" typedef struct node { int data; struct node *next; }Lnode,*Linklist; input(Lnode *p,int n)//实现用键盘顺序输入链表数据{ Lnode *s;int i,d; printf("请输入数据:"); for(i=1;i<=n;i++) { if(i==1) { scanf("%d",&d); p->data=d; continue; } if(n==1)break; scanf("%d",&d);

s=(Linklist)malloc(sizeof(Lnode)); s->data=d; p->next=s; s->next=NULL; p=s;//使当前指针指向链表尾部节点 } } output(Lnode *p,int n)//实现输出当前链表所有数据 { int i=1; printf("当前链表的值为:"); while(p->next!=NULL) { printf("%d ",p->data); p=p->next; i++; } if(i==n)//当是最后一个节点时,其next已经是空,所以最后一个节点数据无法用while循环写出,所以另用了一个计数器i printf("%d",p->data); }

insert(Lnode *p,int i,int e)//实现在第i个元素之后插入新元素{ int j=0;Lnode *s; while(p&&jnext;++j;}if(!p||j>i-1)return 0; s=(Linklist)malloc(sizeof(Lnode)); s->data=e;s->next=p->next;p->next=s; return 1; } delet(Lnode *p,int i)//实现删除链表中第i+1个元素 { int j=0;Lnode *q; while(p->next&&jnext;++j; } if(!(p->next)||j>i-1)return 0; q=p->next;p->next=q->next; free(q); return 1; } search(Lnode *p,int e,int n) {

数据结构源代码(清华大学+严蔚敏)

void Union(List &La, List Lb) { // 算法2.1 // 将所有在线性表Lb中但不在La中的数据元素插入到La中 int La_len,Lb_len,i; ElemType e; La_len = ListLength(La); // 求线性表的长度 Lb_len = ListLength(Lb); for (i=1; i<=Lb_len; i++) { GetElem(Lb, i, e); // 取Lb中第i个数据元素赋给e if (!LocateElem(La, e, equal)) // La中不存在和e相同的数据元素 ListInsert(La, ++La_len, e); // 插入 } } // union void MergeList(List La, List Lb, List &Lc) { // 算法2.2 // 已知线性表La和Lb中的元素按值非递减排列。 // 归并La和Lb得到新的线性表Lc,Lc的元素也按值非递减排列。int La_len, Lb_len; ElemType ai, bj; int i=1, j=1, k=0; InitList(Lc); La_len = ListLength(La); Lb_len = ListLength(Lb); while ((i <= La_len) && (j <= Lb_len)) { // La和Lb均非空 GetElem(La, i, ai); GetElem(Lb, j, bj); if (ai <= bj) { ListInsert(Lc, ++k, ai); ++i; } else { ListInsert(Lc, ++k, bj); ++j; } } while (i <= La_len) { GetElem(La, i++, ai); ListInsert(Lc, ++k, ai); } while (j <= Lb_len) { GetElem(Lb, j++, bj); ListInsert(Lc, ++k, bj); } } // MergeList Status InitList_Sq(SqList &L) { // 算法2.3 // 构造一个空的线性表L。 L.elem = (ElemType *)malloc(LIST_INIT_SIZE*sizeof(ElemType)); if (!L.elem) return OK; // 存储分配失败 L.length = 0; // 空表长度为0 L.listsize = LIST_INIT_SIZE; // 初始存储容量 return OK; } // InitList_Sq Status ListInsert_Sq(SqList &L, int i, ElemType e) { // 算法2.4 // 在顺序线性表L的第i个元素之前插入新的元素e, // i的合法值为1≤i≤ListLength_Sq(L)+1 ElemType *p; if (i < 1 || i > L.length+1) return ERROR; // i值不合法 if (L.length >= L.listsize) { // 当前存储空间已满,增加容量 ElemType *newbase = (ElemType *)realloc(L.elem, (L.listsize+LISTINCREMENT)*sizeof (ElemType)); if (!newbase) return ERROR; // 存储分配失败 L.elem = newbase; // 新基址 L.listsize += LISTINCREMENT; // 增加存储容量 } ElemType *q = &(L.elem[i-1]); // q为插入位置 for (p = &(L.elem[L.length-1]); p>=q; --p) *(p+1) = *p; // 插入位置及之后的元素右移 *q = e; // 插入e ++L.length; // 表长增1 return OK; } // ListInsert_Sq Status ListDelete_Sq(SqList &L, int i, ElemType &e) { // 算法2.5 // 在顺序线性表L中删除第i个元素,并用e返回其值。 // i的合法值为1≤i≤ListLength_Sq(L)。 ElemType *p, *q; if (i<1 || i>L.length) return ERROR; // i值不合法 p = &(L.elem[i-1]); // p为被删除元素的位置 e = *p; // 被删除元素的值赋给e q = L.elem+L.length-1; // 表尾元素的位置 for (++p; p<=q; ++p) *(p-1) = *p; // 被删除元素之后的元素左移--L.length; // 表长减1 return OK; } // ListDelete_Sq int LocateElem_Sq(SqList L, ElemType e, Status (*compare)(ElemType, ElemType)) { // 算法2.6 // 在顺序线性表L中查找第1个值与e满足compare()的元素的位序。// 若找到,则返回其在L中的位序,否则返回0。 int i; ElemType *p; i = 1; // i的初值为第1个元素的位序 p = L.elem; // p的初值为第1个元素的存储位置 while (i <= L.length && !(*compare)(*p++, e)) ++i; if (i <= L.length) return i; else return 0; } // LocateElem_Sq void MergeList_Sq(SqList La, SqList Lb, SqList &Lc) { // 算法2.7 // 已知顺序线性表La和Lb的元素按值非递减排列。 // 归并La和Lb得到新的顺序线性表Lc,Lc的元素也按值非递减排列。ElemType *pa,*pb,*pc,*pa_last,*pb_last; pa = La.elem; pb = Lb.elem; Lc.listsize = Lc.length = La.length+Lb.length; pc = Lc.elem = (ElemType *)malloc(Lc.listsize*sizeof(ElemType)); if (!Lc.elem) exit(OVERFLOW); // 存储分配失败 pa_last = La.elem+La.length-1; pb_last = Lb.elem+Lb.length-1;

数据结构课程设计单链表

目录 1 选题背景 (2) 2 方案与论证 (3) 2.1 链表的概念和作用 (3) 2.3 算法的设计思想 (4) 2.4 相关图例 (5) 2.4.1 单链表的结点结构 (5) 2.4.2 算法流程图 (5) 3 实验结果 (6) 3.1 链表的建立 (6) 3.2 单链表的插入 (6) 3.3 单链表的输出 (7) 3.4 查找元素 (7) 3.5 单链表的删除 (8) 3.6 显示链表中的元素个数(计数) (9) 4 结果分析 (10) 4.1 单链表的结构 (10) 4.2 单链表的操作特点 (10) 4.2.1 顺链操作技术 (10) 4.2.2 指针保留技术 (10) 4.3 链表处理中的相关技术 (10) 5 设计体会及今后的改进意见 (11) 参考文献 (12) 附录代码: (13)

1 选题背景 陈火旺院士把计算机60多年的发展成就概括为五个“一”:开辟一个新时代----信息时代,形成一个新产业----信息产业,产生一个新科学----计算机科学与技术,开创一种新的科研方法----计算方法,开辟一种新文化----计算机文化,这一概括深刻影响了计算机对社会发展所产生的广泛而深远的影响。 数据结构和算法是计算机求解问题过程的两大基石。著名的计算机科学家P.Wegner指出,“在工业革命中其核心作用的是能量,而在计算机革命中其核心作用的是信息”。计算机科学就是“一种关于信息结构转换的科学”。信息结构(数据结构)是计算机科学研究的基本课题,数据结构又是算法研究的基础。

2 方案与论证 2.1 链表的概念和作用 链表是一种链式存储结构,链表属于线性表,采用链式存储结构,也是常用的动态存储方法。链表中的数据是以结点来表示的,每个结点的构成:元素(数据元素的映象) + 指针(指示后继元素存储位置),元素就是存储数据的存储单元,指针就是连接每个结点的地址数据。 以“结点的序列”表示线性表称作线性链表(单链表) 单链表是链式存取的结构,为找第 i 个数据元素,必须先找到第 i-1 个数据元素。 因此,查找第 i 个数据元素的基本操作为:移动指针,比较 j 和 i 单链表 1、链接存储方法 链接方式存储的线性表简称为链表(Linked List)。 链表的具体存储表示为: ① 用一组任意的存储单元来存放线性表的结点(这组存储单元既可以是连续的,也可以是不连续的) ② 链表中结点的逻辑次序和物理次序不一定相同。为了能正确表示结点间的逻辑关系,在存储每个结点值的同时,还必须存储指示其后继结点的地址(或位置)信息(称为指针(pointer)或链(link)) 注意: 链式存储是最常用的存储方式之一,它不仅可用来表示线性表,而且可用来表示各种非线性的数据结构。 2、链表的结点结构 ┌───┬───┐ │data │next │ └───┴───┘ data域--存放结点值的数据域 next域--存放结点的直接后继的地址(位置)的指针域(链域) 注意: ①链表通过每个结点的链域将线性表的n个结点按其逻辑顺序链接在一起的。 ②每个结点只有一个链域的链表称为单链表(Single Linked List)。

数据结构课程设计文章编辑(附录中有全部代码)

课程设计任务书 专业名称:计算机科学与技术(软件工程) 课程名称:数据结构课程设计 设计题目:文章编辑问题 起止时间:2013年6 月24 日至2013年7 月12 日 问题描述 静态存储一页文章,每行最多不超过80个字符,共N行,程序可以统计出文字、数字、空格的个数,并且可以对文章中特定内容进行查找及替换,同时也可以删除指定内容。 基本要求 (1)分别统计出其中英文字母数和空格数及整篇文章总字数; (2)统计某一字符串在文章中出现的次数,并输出该次数; (3)查找出文章中某一段文字,并用其他文字进行替换; (4)删除某一子串,并将后面的字符前移。 输出形式: (1)分行输出用户输入的各行字符; (2)分4行输出"全部字母数"、"数字个数"、"空格个数"、"文章总字数"; (3)查找出指定字符串在文章中出现的所有地方并替换,输出替换后结果; (4)输出删除某一字符串后的文章; 实现提示 存储结构使用线性表,分别用几个子函数实现相应的功能,并且使用菜单的形式,可以选择所要进行的操作(查找、替换、删除、统计等)。

文章编辑系统 1概要设计 本次课程设计的题目是文章编辑系统,本系统的功能描述如下:用户新建文本、浏览新建文本、文本字符统计、指定字符串统计、指定字符串删除、指定字符串替换等操作。 1.新建文本 2.浏览输入文本 3.文本字符统计 4.指定字符串统计 5.指定字符串删除 6.指定字符串替换 7.退出系统 本系统包含七个功能模块,分别为:新建文本模块,浏览输入文本模块,指定字符串统计模块,指定字符串删除模块,指定字符串删除模块,指定字符串替换模块以退出系统模块。新建文本模块实现用户录入文本信息,并且系统自动保存录入信息。浏览输入文本模块实现了显示用户录入信息的功能。指定字符串统模块实现了对英文字母数和空格数及整篇文章总字数的统计。指定字符串统计实现了统计用户自定义字符串个数的功能。指定字符串删除模块实现了对用户自定义字符串的删除。指定字符串替换模块实现了替换用户自定义字符串为用户定义的新字符功能。退出系统模块实现了退出系统功能。

单链表的建立及其基本操作的实现(完整程序)

#include "stdio.h"/*单链表方式的实现*/ #include "malloc.h" typedef char ElemType ; typedef struct LNode/*定义链表结点类型*/ { ElemType data ; struct LNode *next; }LNode,*LinkList;/*注意与前面定义方式的异同*/ /*建立链表,输入元素,头插法建立带头结点的单链表(逆序),输入0结束*/ LinkList CreateList_L(LinkList head) { ElemType temp; LinkList p; printf("请输入结点值(输入0结束)"); fflush(stdin); scanf("%c",&temp); while(temp!='0') { if(('A'<=temp&&temp<='Z')||('a'<=temp&&temp<='z')) { p=(LinkList)malloc(sizeof(LNode));/*生成新的结点*/ p->data=temp; p->next=head->next; head->next=p;/*在链表头部插入结点,即头插法*/ } printf("请输入结点值(输入0结束):"); fflush(stdin); scanf("%c",&temp); } return head; } /*顺序输出链表的内容*/ void ListPint_L(LinkList head) { LinkList p; int i=0; p=head->next; while(p!=NULL) { i++; printf("单链表第%d个元素是:",i);

数据结构单链表输入输出(c++)

#include template class link { public: T date; link *next; link(const T info, link *nextvalue=NULL) { date=info; next=nextvalue; } link(link *nextvalue) { next=nextvalue; } }; templateclass inklist{ private: link *head,*tail; link *setpos(const int p); public: inklist(); ~inklist(); bool append(const T value); bool insert(const int p,const T value); bool remove(const int p); void print(); }; template inklist::inklist() { head=tail=new link(NULL); } template inklist::~inklist() { link *tmp; while(head!=NULL) { tmp=head; head=head->next; delete tmp; }

} template link *inklist::setpos(int i) { int count=0; if(i==-1) return head; link *p=new link(head->next); while( p!=NULL && countnext; count++; } return p; } template bool inklist::insert(const int i,const T value) { link *p,*q; if((p=setpos(i-1))==NULL){ cout<<"非法插入点"<(value,p->next); p->next=q; if(p==tail) tail=q; return true;} template bool inklist::remove(const int i) { link *p,*q; if((p=setpos(i-1))==NULL||p==tail) { cout<<"非法删除点"; return false; } q=p->next; if(q==tail) { tail=p; p->next=NULL; delete q; }

数据结构-单链表实验报告

单链表实验报告 一、实验目的 1、帮助读者复习C++语言程序设计中的知识。 2、熟悉线性表的逻辑结构。 3、熟悉线性表的基本运算在两种存储结构上的实现,其中以熟悉链表的操作为侧重点。 二、实验内容 [问题描述] 实现带头结点的单链表的建立、求长度,取元素、修改元素、插入、删除等单链表的基本操作。 [基本要求] (1)依次从键盘读入数据,建立带头结点的单链表; (2)输出单链表中的数据元素 (3)求单链表的长度; (4)根据指定条件能够取元素和修改元素; (5)实现在指定位置插入和删除元素的功能。 三、算法设计 (1)建立带表头结点的单链表;首先输入结束标志,然后建立循环逐个输入数据,直到输入结束标志。 (2)输出单链表中所有结点的数据域值;首先获得表头结点地址,然后建立循环逐个输出数据,直到地址为空。 (3)输入x,y在第一个数据域值为x的结点之后插入结点y,若无结点x,则在表尾插入结点y;建立两个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,建立循环扫描链表。当当前结点指针域不为空且数据域等于x的时候,申请结点并给此结点数据域赋值为y,然后插入当前结点后面,退出函数;当当前结点指针域为空的时候,申请结点并给此结点数据域赋值为y,插入当前结点后面,退出函数。 (4)输入k,删除单链表中所有的结点k,并输出被删除结点的个数。建立三个结构体指针,一个指向当前结点,另一个指向当前结点的上一结点,最后一个备用;建立整形变量l=0;建立循环扫描链表。当当前结点指针域为空的时候,如果当前结点数据域等于k,删除此结点,l++,跳出循环,结束操作;如果当前结点数据域不等于k,跳出循环,结束操作。当当前结点指针域不为空的时候,如果当前结点数据域等于k,删除此结点,l++,继续循环操作;如果当前结点数据域不等于k,指针向后继续扫描。循环结束后函数返回变量l的值,l便是删除的结点的个数。

数据结构算法大全有代码

排序算法有:插入排序,合并排序,冒泡排序,选择排序,希尔排序,堆排序,快速排序,计数排序,基数排序,桶排序(没有实现) 。比较一下学习后的心得。我不是很清楚他们的时间复杂度,也真的不知道他们到底谁快谁慢,因为书上的推导我确实只是小小了解,并没有消化。也没有完全理解他们的精髓,所以又什么错误的还需要高手指点。呵呵。 1. 普及一下排序稳定,所谓排序稳定就是指:如果两个数相同,对他们进行的排序结果为他们的相对顺序不变。例如A={1,2,1,2,1}这里排序之后是 A = {1,1,1,2,2}稳定就是排序后第一个 1 就是排序前的第一个1,第二个1 就是排序前第二个1,第三个1 就是排序前的第三个1。同理 2 也是一样。这里用颜色标明了。不稳定呢就是他们的顺序不应和开始顺序一致。也就是可能会是A={1,1,1,2,2}这样的结果。 2. 普及一下原地排序:原地排序就是指不申请多余的空间来进行的排序,就是在原来的排序数据中比较和交换的排序。例如快速排序,堆排序等都是原地排序,合并排序,计数排序等不是原地排序。 3. 感觉谁最好,在我的印象中快速排序是最好的,时间复杂度:n*log(n) ,不稳定排序。原 地排序。他的名字很棒,快速嘛。当然快了。我觉得他的思想很不错,分治,而且还是原地排序,省去和很多的空间浪费。速度也是很快的,n*log(n) 。但是有一个软肋就是如果已经是排好的情况下时间复杂度就是n*n, 不过在加入随机的情况下这种情况也得以好转,而且他可以做任意的比较,只要你能给出两个元素的大小关系就可以了。适用范围广,速度快。 4. 插入排序:n*n 的时间复杂度,稳定排序,原地排序。插入排序是我学的第一个排序,速 度还是很快的,特别是在数组已排好了之后,用它的思想来插入一个数据,效率是很高的。因为不用全部排。他的数据交换也很少,只是数据后移,然后放入要插入的数据。(这里不 是指调用插入排序,而是用它的思想) 。我觉得,在数据大部分都排好了,用插入排序会给你带来很大的方便。数据的移动和交换都很少。 插入排序主要思想是:把要排序的数字插入到已经排好的数据中。(我自己理 解的哈)。例如12356 是已经排好的序,我们将4插入到他们中,时插入之后也是排好序的。这里显而易见是插入到 3 的后面。变为123456. 实现思路:插入排序就是先是一个有序的数据,然后把要插入的数据插到指定的位置,而排序首先给的就是无序的,我们怎么确定先得到一个有序的数据呢?答案就是:如果只有一个,当然是有序的咯。我们先拿一个出来,他是有序的,然后把数据一个一个插入到其中,那么插入之后是有序的,所以直到最后都是有序的。。哈哈。结果就出来了! 当然在写的时候还是有一个技巧的,不需要开额外的数组,下标从第二个元素开始遍历直到最后一个,然后插入到前面已经有序的数据中。这样就不会浪费空间了。插入排序用处还是 很多的,特别是链表中,因为链表是指针存放的,没有数组那么好准确的用下标表示,插入是简单有效的方法。嘻嘻。。废话少说, 源代码奉上: 1 #include 2 #include 3 4 // 插入排序从小到大,nData 为要排序的数据,nNum 为数据的个数,该排序是稳定的排序 5 bool InsertionSort(int nData[], int nNum) 6 { 7 for (int i = 1; i < nNum; ++i) // 遍历数组,进行插入排序 8 { 9 int nTemp = nData[i];

(完整版)数据结构线性表的主要程序代码

数据结构顺序表的主要代码(LIZHULIN) 1./***有头结点的单链表的初始化、建立(表头插入、表尾插入)、求长度、插入、删除、输出***/ /***********单链表的初始化、建立、输出*****************/ #include #include typedef struct Lnode { /*定义线性表的单链表存储结构*/ int data; struct Lnode *next; }LinkList; /****************单链表的初始化*************************/ Initlist(LinkList *L) { /*动态申请存储空间*/ L = (LinkList *)malloc(sizeof(struct Lnode));/*建立头结点*/ L->next = NULL; } /*************建立一个带头结点的单链表,在表尾插入***************/ Create_L(LinkList *L,int n) { LinkList *p,*q; int i; Initlist(L); /*单链表初始化*/ q=L; printf("input the value\n"); for(i = n;i>0;--i) { p = (LinkList*)malloc(sizeof(struct Lnode)); scanf("%d",&p->data); /*输入元素值*/ q->next = p; p->next = NULL; q=p; /*插入到表尾*/ } } /* Create_L */ /*************建立一个带头结点的单链表,在表头插入************** Create_L(LinkList *L,int n) { LinkList *p; int i;

《数据结构Java版》线性表之单链表的建立及操作

《数据结构Java》线性表之单链表的建立及操作 package sjjg3; //单链表结点类,T指定结点的元素类型 public class Node { public T data;//数据域,存储数据元素 public Node next;//地址域,引用后继结点 public Node(T data,Node next) {//构造结点,data指定数据元素,next指定后继结点 this.data=data;//T对象引用赋值 this.next=next;//Node对象引用赋值 } public Node() { this(null, null); } public String toString() {//返回结点数据域的描述字符串 return this.data.toString(); } } package sjjg3; //单链表类,实现ADT List声明方法,T表示数据元素的数据类型 public class SinglyList extends Object{ public Node head;//头指针,指向单链表的头结点 //(1)构造方法 public SinglyList() {//构造空单链表 this.head=new Node();//创建头结点,data和next值均为null } public SinglyList(T[] values) {//构造单链表,由values数组提供元素this();//创建空单链表,只有头结点 Node rear=this.head;//rear指向单链表最后一个结点 for(int i=0;i(values[i],null);//尾插入,创建结点链入rear结点之后 rear=rear.next;//rear指向新的链尾结点 } } public boolean isEmpty() {//判断单链表是否空,O(1) return this.head.next==null; } //(2)存取 public T get(int i) {//返回第i个元素,0<=i<表长度。若i越界,则返回null。O(n) Node p=this.head.next; for(int j=0;p!=null && j

数据结构单链表实验报告

数据结构单链表实验报告

一、设计人员相关信息 1.设计者姓名、学号和班号:12地信李晓婧12012242983 2.设计日期:2014. 3.上机环境:VC++6.0 二、程序设计相关信息 1.实验题目:编写一个程序,实现单链表的各种基本运算(假设单链表的元素类型为 char),并在此基础上设计一个程序,完成如下功能: (1)初始化单链表; (2)采用尾插法依次插入元素a,b,c,d,e; (3)输出单链表 (4)输出单链表长度 (5)判断单链表是否为空 (6)输出单链表第3个元素 (7)输出元素a的位置 (8)在第4个元素位置上插入元素f (9)输出单链表 (10)删除第三个元素 (11)输出单链表 (12)释放单链表 2.实验项目组成: (1)插入和删除节点操作 (2)建立单链表 尾插法建表 (3)线性表基本运算在单链表中的实现 初始化线性表 销毁线性表 判断线性表是否为空表 求线性表的长度

3.实验项目的程序结构(程序中的函数调用关系图): Main LinkList InitList CreateListR DispList ListLength ListEmpty GetElem LocateElem ListInsert ListDelete DestroyList 4.实验项目包含的各个文件中的函数的功能描述: ●尾插法建表CreateListR:将新节点插到当前链表的表尾上,为此必须增加一个尾指针 r,使其始终指向当前链表的尾节点。 ●初始化线性表InitList:该运算建立一个空的单链表,即创建一个头节点; ●销毁线性表DestroyList:释放单链表占用的内存空间,即逐一释放全部节点的空间; ●判断线性表是否为空表ListEmpty:若单链表没有数据节点,则返回真,否则返回假; ●求线性表的长度ListLength:返回单链表中数据节点的个数; ●输出线性表DispList:逐一扫描单链表的每个数据节点,并显示各节点的data域值;

相关文档
最新文档