单链表的建立_范文大全

单链表的建立

【范文精选】单链表的建立

【范文大全】单链表的建立

【专家解析】单链表的建立

【优秀范文】单链表的建立

范文一:建立单链表 投稿:邵甦甧

实验一 单链表

专业班级 信息101 学号 201012030119 姓名 刘丹 报告日期 2012/12/8.

1.1 预备知识

1.11 建立动态链表的存储结构形式及其描述。

1.12 单链表的建立、查找、插入、和删除操作。

1.2 实验目的

1.21 掌握单链表的存储结构、及其形式的描述。

1.22 掌握单链表的建立、查找、插入和删除操作。

1.3 实验内容

1.31 编写函数,实现随机产生或键盘输入一组元素,建立一个带头结点的单链表(无序)。

1.32 编写函数,实现遍历单链表。

1.33 编写函数,实现把单链表中的元素逆置(不允许建立新的结点)。

1.34 编写函数,建立一个非递减的有序单链表。

1.35 编写函数,建立连个非递减的有序但序列,然后合成一个非递减表。

1.36 编写函数,实现在非递减有序链表中插入一个元素,使表仍然有序。

1.37 编写函数,实现在非递减有序数列中删除值为X的结点。

1.38 编写一个主函数,在主函数中分别设计一个简单的菜单,分别调试他们。

1.4 编写程序

(1)//头插法建立单链表

void creathead(linklist l){

Node *s;

int flag=1;

while(flag){ c=getchar(); } if(c!='$'){ s=(Node*)malloc(sizeof(Node)); s->data=c; s->next=l->next; l->next=s; } else flag=0;

}

(2)/遍历效果

void view(linklist l){

Node *s;

while(s!=NULL){ cout<data<<" "; s=s->next; }

}

(3)//就地逆置

void revise(linklist l){

Node *p,*q;

p=l->next; l->next=NULL; while(p!=NULL){ q=p->next; p->next=l->next; l->next=p; p=q;

}

}

(4)//插入程序

elemtype e; void inslist(linklist l,int i){ Node *pre,*s; cout<<"please insert position and value:"; cin>>i; cin>>e; int k; if(i<=0) cout<<"error"; pre=l->next;k=0; while(pre!=NULL&&knext; } k++; s=(Node*)malloc(sizeof(Node)); s->data=e; s->next=pre->next; pre->next=s;

}

(5)//合并两个链表

void MergeList(linklist la,linklist lb,linklist lc){

Node *pa,*pb,*r; r=lc; pa=la->next; pb=lb->next; while(pa!=NULL && pb!=NULL){

} r->next=pa; r=pa; pa=pa->next; }else{ r->next=pb; r=pb; } if(pa) r->next=pa; else r->next=pb; free(la); free(lb); pb=pb->next;

}

(6)//删除特定元素

void erase(linklist L,elemtype e){

Node *pre;

pre=L->next; while(pre->next!=NULL && pre->next->data!=e){ pre=pre->next; } if(pre->next){ Node *tem; tem=pre->next; pre->next=pre->next->next; free(tem); } else printf("所要删除的元素不存在!\n");

}

(7)int main(){

cout<<" 菜单 "<

cout<<"1.随机盘输入一组元素,建立头插法无序的单链表,以输出的形式遍历单链表"<

cout<<"2.头插法就地逆置显示"<

cout<<"3.用尾插法建立链表并显示"<

cout<<"4.用尾插法建立链表并实现就地逆置"<

int m; cin>>m; switch(m){ case 1: cout<<"please input some characters:"<

cout<<"建立第二个链表lb:"; creattail(lb); cout<<"合并链表"<

MergeList(la,lb,lc);

view(lc);

} case 7: break; cout<<"删除特定元素"<>e; erase(la,e); view(la); break; case 10: exit(1); default:cout<<"error"<

1,5调试结果

(1)建立链表

1.51建立链表

(2)遍历效果

(3)头插法就地逆置

1.52头插法建立链表显示

1.52头插法就地逆置

(4)建立非递减序列并插入一个数

1.54建立非递减序列并插入一个数

(5)合并两个递减链表

(6)删除一个元素

1.55合并两个递减链表

(7)菜单页面

1.56删除一个元素

1.57菜单页面

1.6 实验心得

本次试验是建立单链表,并了解单链表的插入、删除、合并的基本操作,在实验刚开始的时候,由于对于c不是很灵活所以有很多程序命令不会用,所以本实验中很多实验都是有c++和c的集成体。不过在同学们的帮助下,渐渐熟悉了结构体和指针,然后经过反复调试和修改终于完成了实验

范文二:用java建立的单链表 投稿:萧岴岵

import java.util.*;

//学生类

class Stu

{

} private int math;//学生的学号 private String name;//学生的名字 public Stu(int math, String name) { } //获得学生的名字 public String getName() { return name; } //修改学生的分数 public void setMath(int math) { this.math = math; } //重写toString方法 public String toString() { } return name + ": " + math; this.math = math; this.name = name;

//链表节点类

class Point

{

Stu st = null; //链表数据域 Point next = null; //链表指针域 public Point(Stu st) { } this(st, null); //调用另一个构造方法 public Point(Stu st, Point next) {

}

} this.next = next;

//建立链表类,并实现其查找,添加,修改,删除,打印的功能 class MyList

{

private Point head = null; //表头 private Point tail = null; //表尾 Scanner read = new Scanner(System.in); //构造方法,默认表头和表尾都为空 public MyList() { } this.head = null; this.tail = null; //判断链表是否为空 public boolean isEmpty() { } return head == null; //建立表头 public void addHead(Stu st) { } //建立表尾 public void addTail(Stu st) { //判断表头是否为空,为空则先建立表头 if(isEmpty()) //调用判断判断链表是否为空的方法 { this.addHead(st);//调用建立表头的方法 head = new Point(st, head); //判断表尾是否为空,这里的主要作用是让表尾指向表头 if(null == tail) { } tail = head;

} else { Point temp = new Point(st); tail.next = temp; } tail = tail.next; //按学生名字,实现查找功能 public void find(String name) { } System.out.println("/n/n/n查询结果为:"); if(isEmpty()) { System.out.println("链表为空"); } else { } //遍历查找法 for(Point temp = head; temp != null; temp=temp.next) { } if(name.equals(temp.st.getName())) { System.out.println(temp.st.toString()); } //根据学生的名字,修改其成绩 public void amend(String name) { int amendStMath = 0; if(isEmpty()) { System.out.println("链表为空"); } else { //遍历查找法 for(Point temp = head; temp != null; temp=temp.next)

}

} } } if(name.equals(temp.st.getName())) { System.out.print("请输入" + name + "的分数:"); amendStMath = read.nextInt(); } temp.st.setMath(amendStMath); //打印出链表 public void disMyList() { } for(Point temp = head; temp != null; temp=temp.next) { System.out.println(temp.st.toString()); }

public class Link {

/** * @param args */ public static void main(String[] args) { // TODO Auto-generated method stub int[] math = {90, 80, 89, 87, 95}; String[] name = {"院长", "华女", "san女", "舍长仔", "阿金"}; Stu st = null; MyList list = new MyList(); //为链表添加节点 for(int i = 0; i < math.length; i++) { } st = new Stu(math[i], name[i]); list.addTail(st);

} } //打印链表 System.out.println("建立的链表为:"); list.disMyList(); //查找名字为华女的学生的信息 list.find("华女"); //修改名字为华女的学生的信息 list.amend("华女"); System.out.println("修改后的学生信息为:"); //打印链表 list.disMyList();

范文三:一步一步建立单链表 投稿:严鋙鋚

第1步:

建立四个文件list.h, list.c,main.c ,Makefile

注意list.h头文件中的防止重复引用:

#ifndef LIST_H

#define LIST_H

#endif

注意list.c和main.c中#include “list.h”是双引号,包含自定义头文件

Makefile内容:

main: main.c list.c

gcc main.c list.c -o main

clean:

rm *.o main -rf

第2步:

创建空链表

在list.h中定义结点的结构, 为了方便演示,只有一个数据成员 int data。

定义一个结点类型LNode和结点指针类型LinkList。

struct node

{

int data;//数据成员

struct node *next;//指针

};

typedef struct node LNode; //结点类型

typedef struct node * LinkList; //结点指针

在list.h中定义函数的原型

LinkList CreateEmptyLinkList();

在list.c中实现该函数。//注意要使用calloc,故要包含头文件

LinkList CreateEmptyLinkList()

{//动态分配头结点,并使它的指针域为NULL,返回空链表的头指针

LinkList p = calloc(sizeof(LNode),1);

assert(p != NULL);

p->next = NULL;

return p;

}

在main函数调用,创建带头结点的空链表。

head = CreateEmptyLinkList();

注意

包含标准库头文件,用<>

包含自定义头文件,用“”

第3步:

建立一个函数,使用头插法建立链表,要求从标准输入输入数据。

在list.h中定义函数的原型

void InsertLinkListH(LinkList head,datatype x);

在list.c中实现该函数。

#include "list.h"

#include

void InsertLinkListH(LinkList head,datatype x)

{

LinkList p = calloc(sizeof(LNode),1);

assert(p != NULL);

p->data = x;// 插入数据保存在新创建节点的数据域

//新节点next指向头结点后续节点或NULL

p->next = head->next;

//头结点next指向新节点

head->next = p;

}

在main.c函数中调用。

for(i=0;i < 3;i++)

{

scanf("%d",&x);

InsertLinkListH(head,x);

}

输入 1 2 3

第4步:

定义一个函数,遍历链表,并打印结点中的数据到标准输出

List.c中:

void Display(LinkList head)

{

LinkList ptr = head->next;//结点指针,指向链表第一个结点

while(ptr != NULL)

{

printf("%d\n", ptr->data);//打印结点数据

ptr = ptr->next;//指向下一个结点

}

}

Main.c中:

Display(head);

结果打印3 2 1,头插法建立的链表的顺序为倒序。

第5步:

用尾插法建立链表

在list.h中定义函数的原型

void InsertLinkListT(LinkList head,datatype x);

在list.c中实现该函数。

void InsertLinkListT(LinkList head,datatype x)

{//为新数据x分配节点,并保存在它的数据域

LinkList p = calloc(sizeof(LNode),1);

assert(p != NULL);

p->data = x;

p->next = NULL;

//临时节点指针tail,通过循环遍历使它指向尾节点

LNode *tail = NULL;

tail = head;

while (tail->next!=NULL)

tail = tail->next;

//将新节点链接在为节点后面

tail->next = p;

}

在main.c函数中调用。

for(i=0;i < 3;i++)

{

scanf("%d",&x);

InsertLinkListT(head,x);

}

输入 1 2 3

Display(head);

结果打印1 2 3,尾插法建立的链表的顺序为正序。

第6步:

使用完链表之后要将链表中动态分配的结点释放,分两种情况:一种是将链表变成空链表,即将所有保存数据的节点释放,一种是将链表中所有节点(包括头结点)释放。

在list.h中定义函数的原型

void SetEmptyLinkList(LinkList head);

void DestroyLinkList(LinkList *phead);

在list.c中实现该函数。

void SetEmptyLinkList(LinkList head)

{

//p指向第一个节点,nxt指向p的下一个节点或NULL

LNode *p = head->next;

LNode *nxt = p->next;

while (p != NULL)

{//释放p指向的节点

free(p);

// 调整p和nxt指向,但二者的先后关系不变,即nxt始终指向(p指向节点的)下一个节点或NULL

p = nxt;

if (nxt!=NULL)

nxt = nxt->next;

}

//空链表标志

head->next = NULL;

}

void DestroyLinkList(LinkList *phead)

{//置空链表

SetEmptyLinkList(*phead);

//释放头结点并让头指针为NULL

free(*phead);

*phead = NULL;

}

注意:参数为什么是LinkList*?因为函数中释放头结点后要将头指针置NULL,只有传指针才能改变调用处的头指针。

第7步:

求表长,关键是链表尾节点指针域为NULL。求解思路和字符串求长度类似。

int GetLength(LinkList head)

{

LNode *p;

int length = 0;

assert(head != NULL);

//指向第一个节点

p = head->next;

while(p != NULL)

{

length++;//p不等于 NULL,说明该节点保存有数据,所以length自增1 p = p->next;

}

return length;

}

编写一函数,按序号查找,如果找到,返回该结点,如果没有找到则返回NULL LNode* GetByOrder(LinkList head,int order)

{

LNode *p = head;//初始指向头结点

int j=0;

assert(head != NULL);

assert(order>=0 &&order <=GetLength(head));

// 依次遍历链表直到链表尾或者j==order

while(p->next != NULL && j

{

p = p->next;

j++;

}

if(j==order)//找到对应序号节点

return p;

else

return NULL;

}

编写一函数,按值查找,如果找到,返回该结点,如果没有找到则返回NULL LNode* GetByValue(LinkList head,int value)

{

LNode *p ;

assert(head != NULL);

p = head->next; //初始指向第一个结点

while(p != NULL && p->data != value)

p = p->next;

return p;

}

main函数相关使用如下:

获取链表长度

printf("list has %d data nodes\n",GetLength(head));

查找链表序号为2数据节点

int order = 2;

LNode *poder = GetByOrder(head,order);

assert(poder != NULL);

printf("data in order<%d> is %d\n",order,poder->data);

查找链表是否存在数据等于10的数据节点

int search = 10;

LNode *psearch = GetByValue(head,search);

if (psearch != NULL)

{

printf("%d is found in list\n",search);

}

else

{

printf("%d is not found in list\n",search);

}

第8步:

编写一个函数,删除指定序号处的结点,成功返回0,失败返回1

编写一个函数,插入新节点到指定序号之后,成功返回0,失败返回1 编写一个函数,插入新节点到指定序号之前,成功返回0,失败返回1

函数原型见list.h

int DeleteAt(LinkList head,int order);

int InsertAfter(LinkList head,int order,datatype x);

int InsertBefore(LinkList head,int order,datatype x);

函数实现见list.c

int DeleteAt(LinkList head,int order)

{//检测序号合法性

if(!(order >= 1 && order <= GetLength(head)))

return 1;

//必须定位到前一个节点

LNode *pre = GetByOrder(head,order-1);

if(pre==NULL || pre->next==NULL)

return 1;

LNode *cur = pre->next;

//删除序号order节点脱链,使order-1节点的next指向order+1节点 pre->next = cur->next;

//释放序号为order的节点

free(cur);

return 0;

}

//后向插入新节点

int InsertAfter(LinkList head,int order,datatype x)

{

if(!(order >= 1 && order <= GetLength(head)))

return 1;

LNode *p = calloc(sizeof(LNode),1);

assert(p != NULL);

p->data = x;

//和前向插入区别,定位在order节点

LNode *pInsert = GetByOrder(head,order);

//新节点加入链表

p->next = pInsert->next;

pInsert->next = p;

return 0;

}

//前向插入新节点

int InsertBefore(LinkList head,int order,datatype x)

{

if(!(order >= 1 && order <= GetLength(head)))

return 1;

LNode *p = calloc(sizeof(LNode),1);

assert(p != NULL);

p->data = x;

//和前向插入区别,定位在order-1节点

LNode *pInsert = GetByOrder(head,order-1);

//新节点加入链表

p->next = pInsert->next;

pInsert->next = p;

return 0;

}

相关函数使用

int del = 2;

assert(0==DeleteAt(head,del));

printf("after DeleteAt\n");

DisplayLinkList(head);

int value = 8;

assert(0==InsertAfter(head,2,value));

printf("after InsertAfter\n");

DisplayLinkList(head);

value = 6;

assert(0==InsertBefore(head,2,value));

printf("after InsertBefore\n");

DisplayLinkList(head);

第九步

链表排序-冒泡排序算法

void bubble_sort(LinkList head,pCompare _func)

{

int i,k;

int n = GetLength(head);

LNode *pre,*cur,*nxt;

assert(_func != NULL);

for(k=n-1;k >0;k--)//控制排序轮数

{

for (i=1;i <= k;i++)//控制每轮排序范围

{

pre = GetByOrder(head,i-1);

cur = pre->next;

nxt = cur->next;

//if (cur->data > nxt->data)

if(_func(cur,nxt) > 0)//存在逆序关系

{

//交换相关节点指针域next指针指向 cur->next = nxt->next;

nxt->next = cur;

pre->next = nxt;

}

}

}

}

注意,第二个参数是一个函数指针,需要调用处提供比较函数 比如main.c中提供的4个比较函数,

升序比较函数

static int ascend(LNode *firstop,LNode *secondop)

{

return firstop->data - secondop->data;

}

降序比较函数

static int descend(LNode *firstop,LNode *secondop)

{

return secondop->data - firstop->data;

}

平方比较函数

static int power2(LNode *firstop,LNode *secondop) {

return pow(firstop->data,2) - pow(secondop->data,2); }

//自定义比较函数

static int mycompare(LNode *firstop,LNode *secondop) {

int result1 = pow(firstop->data,2);

int result2 = pow(secondop->data,2);

if(result1 == result2)

{

if(firstop->data >0 && secondop->data < 0) return 1;

else if(firstop->data <0 && secondop->data > 0) return -1;

else

return 0;

}

else

{

return result1 - result2;

}

}

范文四:单链表的建立、显示及归并 投稿:陈顜顝

实验二 单链表的建立、显示及归并

一、【实验目的】

1、理解和掌握单链表的类型定义方法和结点生成方法。

2、掌握利用头插法、尾插法建立单链表和显示单链表元素的算法。

3、掌握两个值有序的单链表归并的算法。

二、【实验内容】

1、利用头插法建立一个带头结点单链表,并从屏幕显示单链表元素。

2、利用尾插法建立一个带头结点单链表,并从屏幕显示单链表元素。

3、对上面建立的两个单链表归并后显示。

三、【重点和难点】

1、单链表的数据结构类型定义

typedef int datatype;

typedef struct node

{ datatype data;

struct node *next;

} LNode,*LinkList;

2、逆位序(插在表头)输入n个元素的值,建立带表头结构的单链线性表

void CreateList(LinkList &L,int n) //

{ int i;

LinkList p;

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

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

printf("请输入%d个数据\n",n);

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

{

p=(LinkList)malloc(sizeof(LNode)); // 生成新结点

scanf("%d",&p->data); // 输入元素值

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

L->next=p;

}

}

3、正位序(插在表尾)输入n个元素的值,建立带表头结构的单链线性表

void CreateList2(LinkList &L,int n)

{ int i;

LinkList p,q;

L=(LinkList)malloc(sizeof(LNode)); // 生成头结点

L->next=NULL;

q=L;

printf("请输入%d个数据\n",n);

for(i=1;i<=n;i++)

{

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

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

q->next=p;

q=q->next;

}

p->next=NULL;

}

4、已知单链线性表La和Lb的元素按值非递减排列,归并La和Lb得到新的单链线性表Lc,Lc的元素也按值非递减排列

void MergeList(LinkList La,LinkList &Lb,LinkList &Lc)

{ LinkList pa=La->next,pb=Lb->next,pc;

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); // 释放Lb的头结点

Lb=NULL;

}

5、单链表的遍历(显示)

void ListTraverse(LinkList L)

{

LinkList p=L->next;

while(p)

{

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

p=p->next;

}

printf("\n");

}

四、主程序

void main()

{

int n=5;

LinkList La,Lb,Lc;

printf("按非递减顺序, ");

CreateList2(La,n); // 正位序输入n个元素的值

printf("La="); // 输出链表La的内容

ListTraverse(La);

printf("按非递增顺序, ");

CreateList(Lb,n); // 逆位序输入n个元素的值

printf("Lb="); // 输出链表Lb的内容

ListTraverse(Lb);

MergeList(La,Lb,Lc); // 按非递减顺序归并La和Lb,得到新表Lc

printf("Lc="); // 输出链表Lc的内容

List

Traverse(Lc);

}

范文五:单链表的建立、删除、及建立递增的单链表 投稿:曹竅竆

班级: 数学112班 学号:201112010222姓名: 吕文辉 报告日期: 2012/12/9

试验一:单链表

一、实验目的

(1)掌握单链表的存储结构形式及其描述。

(2)掌握单链表的建立、查找、插入和删除操作。

二、实验要求

(1)编写函数,实现随机产生或键盘输入一组元素,建立一个带头结点的单链表(无序)。

(2)编写函数,实现遍历单链表。

(3)编写函数,实现把单向链表中元素逆置(不允许申请新的结点空间)。

(4)编写函数,建立一个非递减有序单链表。

(5)编写函数,利用以上算法,建立两个非递减有序单链表,然后合并成一个非递减链表。

(6)编写函数,在非递减有序单链表中插入一个元素使链表仍然有序。

(7)编写函数,实现在非递减有序链表中删除值为x的结点。

(8)编写一个主函数,在主函数中设计一个简单的菜单,分别调试上述算法。

三、实验代码:

#include

#include

#include

///////////////////////////////////////////

typedef char elemtype;

#define null 0

const int n=20;

int i=1;

typedef

struct node

{elemtype data;

struct node *p;

}node,*linklist;

///////////////////////////

void initlist(linklist L);//初始化单链表

void createfromhead(linklist L); //利用头插法建立单链表;

void textlinklist(linklist L); // 检测单链表;

void createfromtail(linklist L);//尾插法建立单链表;

void linklistnizhi(linklist k);//单链表的逆置;

void Lorder(elemtype a[n],int n);//给数组中元素排序;

void increaselinklist(linklist k); //给单链表中的元素排序;

linklist unittwolinklist(linklist k1,linklist k2); // 建立两个非递减有序单链表,然后合并成一个

非递减链表。

void DeleteIncreaselinklist(linklist k); //编写函数,实现在非递减有序链表中删除值为x的结点

void Insertelemtypelinklist(linklist k); //编写函数,在非递减有序单链表中插入一个元素使链表

仍然有序

void alllinklistfunctionlwh(char s); //将所有函数的整合在一个函数里面;

void textlwhplinklist(linklist lwhp);

///////////////////////////////

int main()

{

cout<<"************************"<

cout<<"头插法建立程序的眼演示实例"<

字符已经输完)退出"<

cout<<"************************"<

char s;

cout<<"如果执行程序请输入L"<

cin>>s;

alllinklistfunctionlwh(s);

////////////////////////////////////////////////

//调试程序时要用到的代码;

/* node lwh;

linklist lwhp;

lwhp=&lwh;

initlist(lwhp);

cout<<"sizeof(node) "<

cout<<"sizeof(lwhp)"<

cout<<"第一个为表头指针,不放数据,由于用的头插法,故输出链表的顺序和输入的顺

序恰好相反"<

createfromhead(lwhp);

createfromtail(lwhp);

linklistnizhi(lwhp); 1逆置单链表;

increaselinklist(lwhp); //给单链表中的元素排序;

//建立另外一个单链表;

node lwh1;

linklist lwhp1;

lwhp1=&lwh1;

initlist(lwhp1);

createfromtail(lwhp1);

linklist lwhp2;

lwhp2=unittwolinklist(lwhp,lwhp1);

DeleteIncreaselinklist(lwhp);

Insertelemtypelinklist(lwhp);

char w;

cout<<"如果想检验是否成功建立单链表,如果想检验就请输入y或Y"<

cin>>w;

if(w=='y'||w=='Y')

{

textlinklist(lwhp);

}

*/

//调试程序时要用到的代码;

//////////////////////////////////////////////////////

return 0;

}

//////////////////////////////////////////////////////////

void alllinklistfunctionlwh(char s)

{ int lwhf=1;

if('L'==s)

{ cout<<"如果想运行 初始化单链表函数 请输入0 "<

cout<<"如果想运行 利用头插法建立单链表函数 请输入1 "<

cout<<"如果想运行 尾插法建立单链表单链表 请输入2 "<

cout<<"如果想运行 单链表的逆置函数 请输入3 "<

cout<<"如果想运行 给数组中元素排序函数 请输入4 "<

cout<<"如果想运行 建立两个非递减有序单链表,然后合并成一个非递减链表函数

请输入5 "<

cout<<"如果想运行 实现在非递减有序链表中删除值为x的结点 请输入6 "<

cout<<"如果想运行 在非递减有序单链表中插入一个元素使链表仍然有序表函数 请输入7 "<

cout<<"如果想运行 退出该层函数 请输入8 "<

cout<<"请输入序号:"<

int i;

char f;

cin>>i;

while(lwhf)

{

switch(i)

{ case 0:

cout<<"初始化单链表函数"<

node lwh0;

linklist lwhp0;

lwhp0=&lwh0;

initlist(lwhp0);

textlwhplinklist(lwhp0);

cout<<"执行成功"<

break;

case 1:

cout<<"利用头插法建立单链表函数"<

cout<<"请输入字符"<

node lwh1;

linklist lwhp1;

lwhp1=&lwh1;

initlist(lwhp1);

createfromhead(lwhp1);

textlwhplinklist(lwhp1);

break;

case 2:

cout<<" 尾插法建立单链表单链表"<

cout<<"请输入字符"<

node lwh2;

linklist lwhp2;

lwhp2=&lwh2;

initlist(lwhp2);

createfromtail(lwhp2);

textlwhplinklist(lwhp2);

break;

case 3:

cout<<"单链表的逆置函数 "<

cout<<"请输入字符"<

node lwh3;

linklist lwhp3;

lwhp3=&lwh3;

initlist(lwhp3);

createfromtail(lwhp3);

linklistnizhi(lwhp3);

textlwhplinklist(lwhp3);

break;

case 4:

cout<<"给数组中元素排序函数"<

cout<<"请输入字符"<

node lwh4;

linklist lwhp4;

lwhp4=&lwh4;

initlist(lwhp4);

createfromtail(lwhp4);

increaselinklist(lwhp4);

textlwhplinklist(lwhp4);

break;

case 5:

cout<<"建立两个非递减有序单链表,然后合并成一个非递减链表函数"<

cout<<"请输入第一个单链表的字符"<

node lwh50;

linklist lwhp50;

lwhp50=&lwh50;

initlist(lwhp50);

createfromtail(lwhp50);

cout<<"请输入第二个单链表的字符"<

"<

node lwh51; linklist lwhp51; lwhp51=&lwh51; initlist(lwhp51); createfromtail(lwhp51); linklist lwhp52; lwhp52=unittwolinklist(lwhp50,lwhp51); textlwhplinklist(lwhp52); break; case 6: cout<<"实现在非递减有序链表中删除值为x的结点 "<

cout<<"请重新选择序号"<

cin>>i;

if(i!=1&&i!=2&&i!=3&&i!=4&&i!=5&&i!=6&&i!=7&&i!=8) {

cout<<"如果不想选择序号就 输入字符"<

cin>>f;

if(f=='y'||f=='Y')

{

lwhf=1;

}

else lwhf=0;

}

}

}

}

void textlwhplinklist(linklist lwhp)

{

char w;

cout<<"如果想检验是否成功建立单链表,如果想检验就请输入y或Y"<>w;

if(w=='y'||w=='Y')

{

textlinklist(lwhp);

}

}

///////////////////////////////////////////////////////////

// 所有函数的代码定义:

void initlist(linklist L)

{

// L=(linklist)malloc(sizeof(node));

L->p=null;

}

//头插法建立单链表;

void createfromhead(linklist L)

{

node *jiedian;

// jiedian=L;

char zimu;

bool flag=true;

// cin>>zimu;

/* if(zimu!='&')

{

L->data=zimu;

}*/

while(flag)

{ cin>>zimu;

if(zimu!='&')

{

jiedian=(linklist)malloc(sizeof(node));

jiedian->data=zimu;

jiedian->p=L->p;

L->p=jiedian;

// cout<<"jiedian->data"<data<

}

else flag=false;

}

}

// 一个检测单链表是否建立成功的函数;

void textlinklist(linklist L)

{ linklist p1;

int i=1;

p1=L->p; //建立指向单链表的第一个节点的指针; while(p1!=null)

{

cout<<"这是第"<data="<data <<" "<<"L->p="<p<<" "<

p1=p1->p;

i++;

}

}

//利用尾插法建立单链表

void createfromtail(linklist L)

{

linklist s,r;

bool flag=true;

r=L;

char c;

while(flag)

{ cin>>c;

if(c!='&')

{ s=(linklist)malloc(sizeof(node));

s->data=c;

r->p=s;

r=s;

}

else {

r->p=null;

flag=false;

}

}

}

//单链表中元素逆置;

void linklistnizhi(linklist k)//假设k是个由尾插法建立起来的单链表; /*算法思想:只交换元素的位置,不改变节点的指针*/

{ linklist k1,k2,k3;

k1=k->p;

k2=k1;

k3=k1;

int i=0,w;

elemtype a[n];

while(k1!=null)

{

a[i]=k1->data;

k1=k1->p;

i++;

}

w=i;

for(i=0;i

{

cout<

}

while(k3!=null)

{ k3->data=a[w-1];

k3=k3->p;

w=w-1;

}

}

//编写函数,建立一个非递减有序单链表

//编一个函数实现一个数组里的元素的逆置,该函数有2

//参数一个是指针,一个就是,数组的个数,

void Lorder(elemtype a[n],int n)

{

int i,j,k;

elemtype temp,*p;

p=a;

for(i=0;i

{ k=i;

for(j=i+1;j

if(*(p+j)<*(p+k))

k=j;

temp=*(p+i);

*(p+i)=*(p+k);

*(p+k)=temp;

}

}

//编写函数,建立一个非递减有序单链表

void increaselinklist(linklist k)

{

linklist k1,k2,k3;

k1=k->p;

k2=k1;

k3=k1;

int i=0,w;

elemtype a[n];

while(k1!=null)

{

a[i]=k1->data;

k1=k1->p;

i++;

}

w=i;

Lorder(a,w);

for(i=0;i

{

cout<

}

int j=0;

while(k3!=null&&j

{

k3->data=a[j];

k3=k3->p;

j++; }

}

//编写函数,建立一个非递减有序单链表

//建立两个非递减有序单链表,然后合并成一个非递减链表。 /*思路:想想办法把2个单链表中

的元素先排成有序的然后去出来在和并*/

linklist unittwolinklist(linklist k1,linklist k2)

{

increaselinklist(k2);

increaselinklist(k1);

linklist k3,p0,k4;

k3=(linklist)malloc(sizeof(node));

k4=k3;

/*由于让k3不停的向链表的末尾跑

所以设置一个k4把它的值保留下来,最后当函数的返回值*/ k2=k2->p;

k1=k1->p;

while(k1!=null&&k2!=null)

{

p0=(linklist)malloc(sizeof(node));

k3->p=p0;

if(k1->data>k2->data)

{

p0->data=k2->data;

k2=k2->p;

}

else{ p0->data=k1->data;

k1=k1->p;

}

k3=p0;

}

while(k1!=null)

{

p0=(linklist)malloc(sizeof(node));

k3->p=p0;

p0->data=k1->data;

k1=k1->p;

k3=p0;

}

while(k2!=null)

{

p0=(linklist)malloc(sizeof(node));

k3->p=p0;

p0->data=k2->data;

k2=k2->p;

k3=p0;

}

k3->p=null;

/* 当k3跑完时已经指向链表的最后一个单元

由于在把p0的值往单链表里连的时候用的 k3->p=p0;

及每次在k3指向的那个单元赋值,当为最后一个单元的时候应该给 其富null,这是为了单链表能通过 textlinklist函数的检验

*/

k3=k4;

cout<<"~~~~~~~~~~~~~~~~~~~"<

textlinklist(k4);

cout<<"~~~~~~~~~~~~~~~~~~~~~~~~"<

return k4;

}

//编写函数,在非递减有序单链表中插入一个元素使链表仍然有序 void Insertelemtypelinklist(linklist k)

{

increaselinklist(k);

linklist k2,k3,k4;

k4=k;

int i=0;

elemtype a1,a2;

cout<<"请输入要插入的元素"<

cin>>a2;

k2=(linklist)malloc(sizeof(node));

k2->data=a2;

while((k->p!=null)&&i==0)

{

a1=k->p->data;

if(a2

{ i=1;

k3=k->p;

k2->p=k3;

k->p=k2;

}

k=k->p;

}

if(i==0)

while(k->p==null)

{

k->p=k2;

k2->p=null;

}

k=k4;

}

//编写函数,实现在非递减有序链表中删除值为x的结点

void DeleteIncreaselinklist(linklist k)

{ increaselinklist(k);

linklist k2;

/*引入i的作用是为了判断是否成功删除

如果成功删除后,就终止while循环

及目的已经达到,可以退出循环了

*/

int i=0;

elemtype a,b,c;

bool flag=true;

while(flag)

{ cout<<"输入你想删除的元素"<

cin>>a;

while((k->p!=null)&&(i==0))

{ b=k->p->data;

if(a==b)

{ k2=k->p->p;

free(k->p);

k->p=k2;

i=1;

cout<<"删除成功"<

}

else

k=k->p;

}

if(i==0)

cout<<"删除失败!"<

cout<<"是否再次输入删除的元素如果想继续删除的话"; cout<<"就输入y或者Y"<

cin>>c;

if(c=='y'||c=='Y')

flag=true;

else flag=false;

}

}

范文六:链表的建立 投稿:杨尵尶

看一下链表节点的数据结构定义:

struct node

{

int num;

struct node *p;

} ;

在链表节点的定义中,除一个整型的成员外,成员p是指向与节点类型完全相同的指针。

在链表节点的数据结构中,非常特殊的一点就是结构体内的指针域的数据类型使用了未定义成功的数据类型。这是在C中唯一规定可以先使用后定义的数据结构。

• 单链表的创建过程有以下几步:

1 ) 定义链表的数据结构。

2 ) 创建一个空表。

3 ) 利用m a l l o c ( )函数向系统申请分配一个节点。

4 ) 将新节点的指针成员赋值为空。若是空表,将新节点连接到表头;若是非空表,将新

节点接到表尾。

5 ) 判断一下是否有后续节点要接入链表,若有转到3 ),否则结束。 • 单链表的输出过程有以下几步

1) 找到表头。

2) 若是非空表,输出节点的值成员,是空表则退出。

3 ) 跟踪链表的增长,即找到下一个节点的地址。

4) 转到2 )。

[例7-5] 创建一个存放正整数(输入- 9 9 9做结束标志)的单链表,并打印输出。

#include /包*含ma l l o c ( ) 的头文件*/

#include

struct node /*链表节点的结构* /

{

int num;

struct node *next;

} ;

m a i n ( )

{

struct node *creat(); / *函数声明* /

void print();

struct node *head; / * 定义头指针* /

head=NULL;/*建一个空表*/

head=creat(head);/*创建单链表*/

print(head);/*打印单链表*/

}

/******************************************/

struct node*creat(structnode*head)函/数*返回的是与节点相同类型的指针

*/

{

struct node*p1,*p2;

p1=p2=(structnode*)malloc(sizeof(structnode));申请/*新节点*/ scanf("%d",&p1->num);/*输入节点的值*/

p1->next=NULL;/*将新节点的指针置为空*/

while(p1->num>0)/*输入节点的数值大于0*/

{

if(head==NULL)head=p1;/*空表,接入表头*/

elsep2->next=p1;/*非空表,接到表尾*/

p2=p1;

p1=(structnode*)malloc(sizeof(structnode));申/请*下一个新节点*/ scanf("%d",&p1->num);/*输入节点的值*/

}

return head;/*返回链表的头指针*/

}

/*******************************************/

void print(struct node*head)输/*出以head为头的链表各节点的值*/ {

struct node *temp;

temp=head;/*取得链表的头指针*/

while(temp!=NULL)/*只要是非空表*/

{

printf("%6d",temp->num);/*输出链表节点的值*/

temp=temp->next;/*跟踪链表增长*/

}

}

在链表的创建过程中,链表的头指针是非常重要的参数。因为对链表的输出和查找都要从链表的头开始,所以链表创建成功后,要返回一个链表头节点的地址,即头指针。

7.4.2 单链表的插入与删除

在链表这种特殊的数据结构中,链表的长短需要根据具体情况来设定,当需要保存数据时向系统申请存储空间,并将数据接入链表中。对链表而言,表中的数据可以依此接到表尾或连结到表头,也可以视情况插入表中;对不再需要的数据,将其从表中删除并释放其所占空间,但不能破坏链表的结构。这就是下面将介绍的链表的插入与删除。

1. 链表的删除

在链表中删除一个节点,用图7 - 4描述如下:

[例7-6] 创建一个学生学号及姓名的单链表,即节点包括学生学号、姓名及指向下一个节点的指针,链表按学生的学号排列。再从键盘输入某一学生姓名,将其从链表中删除。

首先定义链表的结构:

struct

从图7 - 4中看到,从链表中删除一个节点有三种情况,即删除链表头节点、删除链表的中

间节点、删除链表的尾节点。题目给出的是学生姓名,则应在链表中从头到尾依此查找各节

点,并与各节点的学生姓名比较,若相同,则查找成功,否则,找不到节点。由于删除的节

点可能在链表的头,会对链表的头指针造成丢失,所以定义删除节点的函数的返回值定义为

返回结构体类型的指针。

struct node *delet(head,pstr)以/*he a d 为头指针,删除ps t r 所在节点*/

struct node *head;

char *pstr;

{

struct node *temp,*p;

t e m p = h e a d ; / * 链表的头指针* /

if (head==NULL) / *链表为空* /

printf("\nList is null!\n");

else /*非空表* /

{

t e m p = h e a d ;

while (strcmp(temp->str,pstr)!=0&&temp->next!=NULL)

/ * 若节点的字符串与输入字符串不同,并且未到链表尾* /

{

p = t e m p ;

t e m p = t e m p - > n e x t ; / * 跟踪链表的增长,即指针后移* / }

if(strcmp(temp->str,pstr)==0 ) / *找到字符串* /

{

if(temp==head) { / * 表头节点* /

printf("delete string :%s\n",temp->str);

h e a d = h e a d - > n e x t ;

f r e e ( t e m p ) ; / *释放被删节点* /

}

e l s e

{

p->next=temp->next; /表*中节点*/

printf("delete string :%s\n",temp->str);

f r e e ( t e m p ) ;

}

}

else printf("\nno find string!\n");没/找* 到要删除的字符串*/ }

r e t u r n ( h e a d ) ; / *返回表头指针* /

}

2. 链表的插入

首先定义链表的结构:

struct

{

int num; /*学生学号* /

char str[20]; /*姓名* /

struct node *next;

} ;

在建立的单链表中,插入节点有三种情况,如图7 - 5所示。

插入的节点可以在表头、表中或表尾。假定我们按照以学号为顺序建立链表,则插入的节点依次与表中节点相比较,找到插入位置。由于插入的节点可能在链表的头,会对链表的头指针造成修改,所以定义插入节点的函数的返回值定义为返回结构体类型的指针。节点的

插入函数如下:

struct node *insert(head,pstr,n) / *插入学号为n、姓名为p s t r 的节点* /

struct node *head; / *链表的头指针* /

char *pstr;

int n;

{

struct node *p1,*p2,*p3;

p1=(struct node*)malloc(sizeof(struct node))分;配/*一个新节点*/

s t r c p y ( p 1 - > s t r , p s t r ) ; / * 写入节点的姓名字串* / p 1 - > n u m = n ; / * 学号* /

p 2 = h e a d ;

if (head==NULL) / * 空表* /

{

head=p1; p1->next=NULL;/ *新节点插入表头* /

}

e l s e

{ /*非空表* /

while(n>p2->num&&p2->next!=NULL)

/ *输入的学号小于节点的学号,并且未到表尾* /

{

p 3 = p 2 ;

p 2 = p 2 - > n e x t ; / * 跟踪链表增长* /

}

if (n<=p2->num) / *找到插入位置* /

if (head==p2) / * 插入位置在表头* /

{

h e a d = p 1 ;

p 1 - > n e x t = p 2 ;

}

e l s e

{ /*插入位置在表中* /

p 3 - > n e x t = p 1 ;

p 1 - > n e x t = p 2 ;

}

e l s e

{ /*插入位置在表尾* /

p 2 - > n e x t = p 1 ;

p 1 - > n e x t = N U L L ;

}

}

r e t u r n ( h e a d ) ; / * 返回链表的头指针* /

}

3. 实例[例7 - 7 ]

创建包含学号、姓名节点的单链表。其节点数任意个,表以学号为序,低学号的在前,高学号的在后,以输入姓名为空作结束。在此链表中,要求删除一个给定姓名的节点,并插入一个给定学号和姓名的节点。

# include "stdlib.h"

# include "malloc. h"

struct node /*节点的数据结构* /

{

int num;

char str[20];

struct node *next;

} ;

/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * /

main( )

{

/ *函数声明* /

struct node *creat();

struct node *insert();

struct node *delet();

void print( );

struct node *head;

char str[20];

int n;

head=NULL; /*做空表* /

head=creat (head); / *调用函数创建以head 为头的链表* /

p r i n t ( h e a d ) ;/ *调用函数输出节点* /

printf("\n input inserted num,name:\n");

gets(str); /*输入学号* /

n=atoi (str);

gets(str); /*输入姓名* /

head=insert (head, str, n); 将/*节点插入链表*/

print (head); / *调用函数输出节点*/

printf("\n input deleted name:\n");

gets(str); /*输入被删姓名* /

head=delet(head,str); /调*用函数删除节点*/

print (head); /*调用函数输出节点* /

r e t u r n ;

}

/ * * * * * * * * * * * * * * * * * * * * * * /

/ * * * 创建链表* * * * * * * * * * * * /

struct node *creat(struct node *head)

{

char temp[30];

struct node *pl,*p2;

pl=p2=(struct node*) malloc(sizeof(struct node));

printf ("input num, name: \n;")

printf("exit:double times Enter!\n");

g e t s ( t e m p ) ;

gets (p1->str);

pl->num=atoi (temp);

p l - > n e x t = N U L L ;

while (strlen (pl->str)>0

{

if (head==NULL) head=pl;

else p2->next=p1;

P 2 = p l ;

pl=(struct node *)malloc(sizeof(struct node));

printf ("input num, name: \n");

printf("exit:double times Enter!\n");

g e t s ( t e m p ) ;

gets(pl ->str);

p1->num=atoi (temp);

P 1 - > n e x t = N U L L ;

}

return head;

}

/ * * * * * * * * * * * * * * * * * * * * /

/ * * * * * * * * * * 插入节点* * * * * * * * * * /

struct node *insert (head, pstr,n);

struct node *head;

char *pstr;

int n;

{

struct node *pl,*p2,*p3;

p1=(struct node*)malloc(sizeof(struct node));

strcpy (p1->str, pstr);

p 1 - > n u m = n ;

p 2 = h e a d ;

i f ( h e a d = = N U L L )

{

h e a d = p l ; p l - > n e x t = N U L L ;

}

e l s e

{

while (n>p2->num&&p2->next!=NULL)

{

p 3 = P 2

p 2 = p 2 - > n e x t ;

}

if (n<=p2->num)

if (head==p2)

{

h e a d = p l ;

p l - > n e x t = p 2 ;

}

else

{

p 3 - > n e x t = p l ;

p l - > n e x t = p 2 ;

}

else

{

p 2 - > n e x t = p l ;

p l - > n e x t = N U L L ;

}

}

r e t u r n ( h e a d ) ;

}

/ * * * * * * * * * * * * * * * * * * * * * * * * * /

/ * * * * * 删除节点* * * * * * * * * * * * * /

struct node *delet (head, pstr)

struct node *head;

char *pstr;

{

struct node *temp,*p;

t e m p = h e a d ;

if (head==NULL)

printf("\nList is null!\n");

else

{

t e m p = h e a d ;

while (strcmp(temp->str,pstr)!=O&&temp->next!=NULL)

{

p = t e m p ;

t e m p = t e m p - > n e x t ,

}

i f ( s t r c m p ( t e m p - > s t r , p s t r ) = = 0 )

{

if (temp== head)

{

h e a d = h e a d - > n e x t ;

f r e e ( t e m p ) ;

}

else

{

p->next =temp->next;

printf("delete string :%s\n",temp->str);

f r e e ( t e m p ) ;

}

}

else printf("\nno find string!\n");

}

return(head);

}

/ * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * / / * * * * * * * * * * 链表各节点的输出* * * * * * * * * * /

void print (struct node *head)

{

struct node *temp;

t e m p = h e a d ;

printf("\n output strings:\n");

while (temp!=NULL)

{

p r i n t f ( " \ n % d - - - - % s \ n " , t e m p - > n u m ,t e m p - > s t r ) ;

t e m p = t e m p - > n e x t ;

}

r e t u r n ;

}

类别:默认分类 | | 添加到搜藏 | 分享到i贴吧 | 浏览(1161) | 评论 (2)

上一篇:graph cut (转) 下一篇:链表的创建只能用new,不能用结...

最近读者:

登录后,您

就出现在

这里。

范文七:数据结构顺序表与单链表的建立 投稿:贾徐徑

封面:

安徽大学

网络工程

数据结构顺序表与单链表的建立

——2012/4/7

一 实验目的

1.熟练掌握线性表的基本操作在顺序存储和链式存储上的实现。

2.以线性表的各种操作(建立、插入、删除、遍历等)的实现为重点。

3.通过本章实验加深对c语言的使用(特别是函数的参数调用、指针类型的应用

和链表的建立等各种基本操作)。

二 实验内容

1. 顺序表的基本操作的实现.包括:

(1).顺序表的类型定义;

(2).创建一个元素为1,10,9,5的顺序表;

(3) .向(2)中表的指定位置插入一个元素;

(4).删除(3)中顺序表中指定位置的元素;

(5).依次输出(2)~(4)顺序表中的元素.

2. 链表的基本操作的实现.包括:

(1).链表的类型定义;

(2).创建一个元素为5,-4,9,10,3的链表;

(3) .向(2)表中指定位置插入一个元素;

(4).删除(3)表中指定位置的元素;

(5).依次输出(2)~(4)表中的元素.

三、实验步骤

1.本实验用到的数据结构

(1)逻辑结构:线性结构

(2)存储结构;顺序存储结构,链式存储结构

2.各程序的功能和算法设计思想

程序一 // 数据结构实验.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include

#include

#include

# define OK 1

# define ERROR 0

# define OVERFLOW -2

# define LISTINITSIZE 100

# define LISTINCREMENT 10

typedef int status;

typedef struct {

int * elem;

int length;

int listsize;

}sqlist;

void Initlist (sqlist *l)

{

(*l).elem= (int*)malloc(LISTINITSIZE * sizeof(int));

if(!(*l).elem)

exit (OVERFLOW);

(*l).length=0;

(*l).listsize=LISTINITSIZE;

}

status ListInsert (sqlist *l, int i, int h)

{

int *newbase,*q,*p;

if (i<1|| i>(*l).length+1)

{

printf("插入位置不合法!\n");

return ERROR;

}

if ((*l).length>= (*l).listsize)

{

newbase = (int *)realloc((*l).elem , ((*l).listsize + LISTINCREMENT) * sizeof(int)); if (! newbase)

exit (OVERFLOW);

(*l).elem = newbase;

(*l).listsize+=LISTINCREMENT;

}

q =(*l).elem + i-1;

for (p=(*l).elem + (*l).length-1;p>=q;--p)

{

*(p+1)=*p;

}

*q=h;

++(*l).length;

return OK;

}

status Getelem(sqlist l, int i,int *e)

{

if (i<1||(i>l.length))

{

printf("输入位置不合法!\n");

return ERROR;

}

*e= *(l.elem +i-1);

printf("第%d个元素的值是:%d\n",i,*e);

printf("\n");

return OK;

}

status ListDelete(sqlist *l, int i)

{

int *p,*q;

if (i<1||i>((*l).length))

{

printf("删除元素位置不合法!\n");

return ERROR;

}

p = (*l).elem+i-1;

printf("删除第%d个元素%d\n",i,*p);

q= (*l).elem+ (*l).length-1;

for (++p;p<=q;++p)

*(p-1)=*p;

(*l).length--;

return OK;

}

void ListTraverse(sqlist l)

{

int *p;

int i ;

p= l.elem;

for ( i=1; i<=l.length; i++)

printf("%d\n",*p++);

printf("\n");

}

void main()

{

int n,i,j,k,e,h,m=1;

sqlist la;

Initlist(&la);

printf("请输入顺序表的长度n\n");

scanf ("%d",&n);

printf("请输入%d个数据\n",n);

for (j =1;j<=n;j++)

{

scanf("%d",&e);

ListInsert(&la,j,e);

}

printf("输出各元素\n");

printf ("la=");

ListTraverse(la);

fflush(stdin);

printf("\n");

printf ("请依次输入插入元素的位置i,插入元素的值h\n");

scanf("%d",&i);

scanf("%d",&h);

printf("在第%d个元素前面插入元素%d\n",i,h);

ListInsert(&la,i,h);

printf("输出各元素\n");

printf("la=");

ListTraverse(la);

fflush(stdin);

printf("\n");

while(m)

{

printf ("请输入查找元素的位置k\n");

scanf ("%d",&k);

if (Getelem(la,k,&e))

m=0;

fflush(stdin);

}

printf("请输入删除元素的位置\n");

scanf ("j=%d",&j);

printf ("删除的第%d各元素是\n",j);

ListDelete(&la,j);

printf("la=");

ListTraverse(la);

printf("\n");

}

功能:建立一个线性顺序结构,能够实现初始化顺序表,查找元素,插入元素,删除元素和输出顺序表等。

算法设计思想:单独建立具有初始化,插入,删除,查找,输出功能的函数,其后按照合理的顺序构建一个主函数。

调试情况如下:

输入/输出要求

输入数据:

数据类型:有符号整型((signed) int )

值域范围:-32768~32767

程序二// shuju2.cpp : 定义控制台应用程序的入口点。

//

// shuju2.cpp : 定义控制台应用程序的入口点。

//

#include "stdafx.h"

#include

#include

#include

# define OK 1

# define ERROR 0

typedef int status;

typedef struct LNode{

int data;

struct LNode *next;

}Lnode,*Linklist;

void Createlist(Linklist *l,int n){

int i;

Linklist p;

*l=(Linklist) malloc(sizeof(Lnode));

(*l)->next=NULL;

printf("请输入%d个元素\n",n);

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

p=(Linklist) malloc(sizeof(Lnode));

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

p->next=(*l)->next;

(*l)->next=p;

}

}

status Getelem(Linklist *l,int i, int *e){

int j=1;

Linklist p;

p=(*l)->next;

while (p && j

p=p->next;

++j;

}

if(!p||j>i){

printf("第%d个元素不存在\n",i);

return ERROR;

}

*e=p->data;

printf("第%d个元素是%d\n",i,*e);

return OK;

}

status Listinsert(Linklist l,int i,int e){

int j=0;

p=l;

while(p&&j

p=p->next;

++j;

}

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

{

printf("插入位置不合法\n");

return ERROR;

}

s=(Linklist) malloc (sizeof(Lnode));

s->data = e;

s->next=p->next;

p->next=s;

return OK;

}

status ListDelete(Linklist l,int i){

int j=0,h;

Linklist p,q;

p=l;

while(p->next&& j

{

p=p->next;

++j;

}

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

{

printf("删除位置不合法\n");

return ERROR;

}

q=p->next;

p->next=q->next;

h=q->data;

printf("删除的元素是%d",h);

free(q);

return OK;

}

void ListTraverse(Linklist l){

Linklist p;

p=l->next;

while(p){

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

p=p->next;

}

}

void main (){

int i,j,n,k,e,m=1;

printf("请输入单链表的长度\n");

scanf("%d",&n);

printf("逆位序建表\n");

Createlist(&la,n);

printf("输出各元素\n");

printf("la=");

ListTraverse(la);

fflush(stdin);

printf("\n");

while(m){

printf("请输入查找元素的位置k\n");

scanf("%d",&k);

if(Getelem(&la,k,&e))

m=0;

fflush(stdin);

printf("\n");

}

m=1;

while(m){

printf("请输入要插入元素的位置i及数值e\n");

scanf("%d",&i);

scanf("%d",&e);

if(Listinsert(la,i,e))

m=0;

printf("输出各元素\n");

printf("la=");

ListTraverse(la);

fflush(stdin);

printf("\n");

}

m=1;

while(m){

printf("请输入删除元素的位置j\n");

scanf("%d",&j);

if(ListDelete(la,j))

m=0;

printf("输出各元素\n");

printf("la=");

ListTraverse(la);

printf("\n");

}

}

功能:建立一个单链表,能够实现初始化单链表,查询,删除,插入以及输出个功能。

算法设计思想:利用逆序的方法构建一个Createlist子函数,再分别建立具有插入,查询,删除,输出功能的

子函数,最后建立一个main函数按一定顺序调用各个子函数,实现程序设计。

调试情况如下:

输入/输出要求

输出数据:

数据类型:有符号整型((signed) int ) 值域范围:-32768~32767

实验总结:

(1) 实验时碰到过函数指针调用错误,以及

结构体类数据调用错误,如将(*L)的形式写成L。缺乏部分数据类型定义也常遇等……

(2) 通过本次实验,加深了对函数指针调用

和结构体内部成员调用的认识,进一步熟悉了构建顺序表,单链表和删除,查询,插入元素等方法。

(3) 实验前应该编号基本的程序,尽量熟悉。

范文八:顺序建立单链表并输出 投稿:莫萆萇

//顺序建立单链表并输出

#include

#include

#define NULL 0

#define LEN sizeof(struct list)

struct list

{

int data;

struct list *next;

};

void main()

{

void createlist();

createlist();

}

void createlist()

{struct list *head,*p1,*p2,*p;int i;

p1=p2=(struct list *)malloc(LEN);

printf("请你输入7个链表的值\n");

for(i=0;i<8;++i){

if(i==1)

{

head=p1;

}

else

{

p1=(struct list *)malloc(LEN); scanf("%d",&p1->data); p2->next=p1;

p2=p1;

}

p2->next=NULL;

}

p=head;

//while(!p->next==NULL) for(i=0;i<7;i++)

{

} printf("%d\n",p->data); p=p->next; }

范文九:建立单链表c语言程序2 投稿:侯错锚

实现功能:

1. 创建一个新链表。

2. 插入节点。

3. 删除节点。

4. 插入法排序链表(从小到大)。

5. 选择法排序链表(从小到大)。

6. 显示当前链表。

0. 退出程序。

.

.

.

/*单向链表的相关操作*/

/* 2010.03.27 */

.

.

#include "stdio.h"

#include "malloc.h"

#include "stdlib.h"

#define null 0

int length;

struct List

{

int data;

struct List *next;

}List;

struct List * InitList()

{

struct List *head,*p,*q;

int d;

printf("\n创建一个链表:\n\n");

head=(struct List *)malloc(sizeof(struct List));

head->next=null;

q=head;

scanf("%d",&d);

while(d<=0)

{

printf("\n您所输入的数据有误,请重新输入\n\n");

scanf("%d",&d);

}

while(d>0)

{

p=(struct List *)malloc(sizeof(struct List));

p->next=null;

p->data=d;

q->next=p;

q=p;

scanf("%d",&d);

length++;

}

return head;

}

void ListInsert(struct List *head,int i,int e)

{

struct List *p,*q;

int j=1;

if(i>0&&i<=length+1&&e>0)

{

p=head;

while(j

{

p=p->next;

j++;

}

q=(struct List *)malloc(sizeof(struct List));

q->data=e;

q->next=p->next;

p->next=q;

length+=1;

}

else printf("\n对不起您所输入的节点位置或数据出错,数据插入失败!\n"); }

int ListDelete(struct List *head,int i,int e)

{

struct List *p,*q;

int j=0;

if(i>0&&i<=length)

{

p=head;

while(j

{

p=p->next;

j++;

}

e=p->next->data;

q=p->next;

p->next=q->next;

free(q);

length-=1;

return e;

}

else {

printf("\n对不起您所输入的节点位置出错,数据删除失败!\n"); return null;

}

}

void ListInsertSort (struct List *head)

{

struct List *p,*q,*s;

q=head->next->next;

head->next->next=null;

while(q)

{

s=q->next;

p=head;

while(p->next&&p->next->datadata)

p=p->next;

q->next=p->next;

p->next=q;

q=s;

}

}

void ListChooseSort (struct List *head)

{

struct List *p,*q;

int t;

for(p=head->next;p->next;p=p->next)

for(q=p->next;q;q=q->next)

if(p->data>q->data)

{

t=p->data;

p->data=q->data;

q->data=t;

}

}

void print(struct List *head)

{

struct List *p;

if(head)

{

p=head->next;

while(p)

{

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

p=p->next;

}

printf("\n");

}

}

void main()

{

struct List *head;

int i,e,n;

head=null;

do

{

system("cls");

printf("\n\n

printf(" 1.

printf(" 2.

printf(" 3.

printf(" 4. 单向链表的相关操作\n\n\n"); 创建一个新链表。\n\n"); 插入节点。\n\n"); 删除节点。\n\n"); 插入法排序链表(从小到大)。

\n\n");

printf(" 5. 选择法排序链表(从小到大)。\n\n");

printf(" 6. 显示当前链表。\n\n"); printf(" 0. 退出程序。\n\n\n\n"); printf(" 请选择所要操作的项目:"); scanf("%d",&n);

switch(n)

{

case 1: system("cls");

head=InitList();

printf("\n您所创建的链表为:");

print(head);

printf("\n");

system("pause");

break;

case 2: system("cls");

if(length)

{

printf("\n当前链表为:");

print(head);

printf("\n请输入要插入的节点位置及要插入的数据:"); scanf("%d%d",&i,&e);

ListInsert(head,i,e);

printf("\n插入节点后的链表为:");

print(head);

}

else printf("\n请先创建链表,再执行此操作!\n\n"); printf("\n");

system("pause");

break;

case 3: system("cls");

if(length)

{

printf("\n当前链表为:");

print(head);

printf("\n请输入要删除的节点位置:");

scanf("%d",&i);

e=ListDelete(head,i,e);

printf("\n您所删除的节点处的数据为%d\n\n",e);

if(length) printf("删除节点后的链表为:");

else printf("删除节点后的链表为空表。");

print(head);

}

else printf("\n请先创建链表,再执行此操作!\n\n"); printf("\n");

system("pause");

break;

case 4: system("cls");

if(length)

{

printf("\n当前链表为:");

print(head);

ListInsertSort(head);

printf("\n排序后的链表为:");

print(head);

}

else printf("\n请先创建链表,再执行此操作!\n\n"); printf("\n");

system("pause");

break;

case 5: system("cls");

if(length)

{

printf("\n当前链表为:");

print(head);

ListChooseSort(head);

printf("\n排序后的链表为:");

print(head);

}

else printf("\n请先创建链表,再执行此操作!\n\n"); printf("\n");

system("pause");

break;

case 6: system("cls");

if(length)

{

printf("\n当前链表为:");

print(head);

}

else printf("\n请先创建链表,再执行此操作!\n\n"); printf("\n");

system("pause");

break;

case 0: printf("\n");

exit(0);

break;

default : system("cls");

printf("\n输入错误!\n\n"); system("pause");

}

}while(1);

}

范文十:单链表的建立、插入和删除 投稿:谭嫘嫙

单链表的建立、插入和删除

单链表的建立 插入 删除 #include

#include

/*线性表*/

struct TLink {

int data;

struct TLink * next;

};/*end struct TLink*/

/*生成新元素*/

struct TLink * new_item(int number)

{

struct TLink * r = 0;

r = (struct TLink *)malloc(sizeof(struct TLink));

r->data = number;

r->next = 0;

return r;

}/*end new_item*/

/*在线性表中查询数据*/

struct TLink * lookup(struct TLink * root, int number) {

struct TLink * h = root;

while(h) {

if (h->data == number) return h;

h = h->next ;

}/*end lookup*/

return 0;

}

/*在线性表中追加一个数据*/

void append(struct TLink * * root, int number)

{

struct TLink * r = 0, * n = 0;

if (!root) return ;

/*不记录重复元素*/

if (lookup(*root, number)) return;

/*如果表为空则新建表*/

r = *root;

if (!r) {

*root = new_item(number);

return ;

}/*end if*/

/*为保证为有序线性表,如果数据比表头还小则作为表头*/ if (number < r->data ) {

n = new_item(number);

n->next = r;

*root = n;

return ;

}/*end if*/

/*在有序线性表中查找位置插入元素*/

while(r) {

n = r->next ;

/*如果已经是表尾则直接追加*/

if (!n) {

n = new_item(number);

r->next = n;

return ;

}/*end if*/

/*在中央某处插入*/

if (number < n->data ) {

r->next = new_item(number);

r->next->next = n;

return ;

}/*end if*/

r = n;

}/*end while*/

}/*end append*/

/*打印有序线性表*/

void print(struct TLink * root)

{

struct TLink * r = root;

printf("【");

while(r) {

printf("%d ", r->data );

r = r->next ;

}/*end while*/

printf("\b】\n");

}/*end print*/

/*将有序线性表h1合并至有序线性表h0,并销毁线性表h1*/ void merge(struct TLink ** h0, struct TLink ** h1)

{

struct TLink * h = 0, * k = 0;

if (!h0 || !h1) return ;

h = *h1;

while(h) {

append(h0, h->data );

k = h;

h = h->next ;

free(k);

}/*end h*/

h1 = 0;

}

int main(void)

{

int i = 0; struct TLink * x=0, *y = 0;

int a[] = {8,4,3,9,5,1};

int b[] = {7,2,1,5,6,0};

printf("原数据为:\n数组A:【");

for(i = 0; i < 6; i++) {

printf("%d ", a[i]);

append(&x, a[i]);

}/*next*/

printf("\b】\n数组B:【");

for(i = 0; i < 6; i++) {

printf("%d ", b[i]);

append(&y, b[i]);

}/*next*/

printf("\b】\n转换为有序线性表\nA:");

print(x);

printf("B:");

print(y);

printf("AB合并后为:");

merge(&x, &y);

print(x);

return 0;

}

字典词典立秋的句子立秋的句子【范文精选】立秋的句子【专家解析】小公司管理制度大全小公司管理制度大全【范文精选】小公司管理制度大全【专家解析】全国环保会议全国环保会议【范文精选】全国环保会议【专家解析】