基于链表的排序和查找算法的设计与实现
《第三单元基于算法的编程基础 第6课 生活中的算法-查找与排》教学设计教学反思-2023-2024学
《生活中的算法-查找与排》教学设计方案（第一课时）一、教学目标1. 理解查找和排序算法的基本原理。
2. 掌握使用条件语句进行查找和排序的方法。
3. 能够应用所学知识解决生活中的实际问题。
二、教学重难点1. 教学重点：学习使用条件语句进行查找和排序。
2. 教学难点：在实际生活中运用所学算法解决实际问题。
三、教学准备1. 准备教学PPT和相关视频素材。
2. 准备计算机和相关软件，如Excel、Scratch等。
3. 准备一些实际问题，供学生实践。
4. 安排小组讨论和展示的时间。
5. 准备一些练习题，供学生巩固所学知识。
四、教学过程：本节课我们主要通过以下四个环节来完成教学任务：1. 引入环节首先，我会通过一个简单的例子来引入查找和排序的概念。
例如，假设我们有一个班级的名单，我们需要找到某个学生的名字，或者将某个学生排在前面。
这个过程就是查找和排序。
通过这个例子，可以让学生们对算法有一个初步的认识，并且能够激发他们的学习兴趣。
2. 探究环节接下来，我会给学生们一些具体的任务，让他们自己动手实践查找和排序算法的实现。
我会给出一些常见的查找和排序算法，例如线性查找、二分查找、冒泡排序、插入排序等，并给出一个简单的代码示例。
学生们可以通过阅读代码、调试代码来理解这些算法的实现过程，并且能够自己动手编写代码进行实践。
在探究过程中，我会引导学生们思考一些问题，例如：* 这些算法的优缺点是什么？* 如何优化这些算法以提高效率？* 查找和排序算法在哪些情况下适用？通过这些问题，可以让学生们更好地理解算法的本质，并且能够培养他们的思考能力和解决问题的能力。
3. 实践环节在学生们掌握了基本的查找和排序算法之后，我会给他们一些实际生活中的问题，例如：* 如何快速查找手机号码簿中的某个电话号码？* 如何将购物清单按照价格从低到高进行排序？* 如何快速定位网站中的某个关键字？学生们需要自己动手编写代码来实现这些算法，并且能够在实践中应用所学知识。
C语言算法设计与分析排序查找和算法
C语言算法设计与分析排序查找和算法C语言算法设计与分析：排序、查找和算法C语言作为一门广泛应用于计算机领域的编程语言，算法设计与分析是每个程序员都需要掌握的重要技能之一。
本文将介绍C语言中常用的排序算法、查找算法以及一些常见的算法技巧，并详细分析它们的原理和实现方法。
一、排序算法1. 冒泡排序（Bubble Sort）冒泡排序是最简单的排序算法之一。
它的基本思想是通过相邻元素之间的比较和交换来将序列中的较大元素逐步向右移动。
具体实现时，从待排序序列的左侧开始，将较大的元素向右冒泡，直至序列有序。
冒泡排序的时间复杂度为O(n^2)。
2. 插入排序（Insertion Sort）插入排序的思想是将待排序序列分为已排序和未排序两部分，从未排序序列中选择元素并插入到已排序序列的适当位置。
具体实现时，从待排序序列的左侧开始，逐个将元素插入到已排序序列中的正确位置，直至序列有序。
插入排序的时间复杂度为O(n^2)，但在部分有序的序列中具有较好的性能。
3. 快速排序（Quick Sort）快速排序是一种高效的排序算法，它的基本思想是通过每一趟排序将待排序序列分割成独立的两部分，其中一部分的所有元素小于另一部分的所有元素，并分别对这两部分进一步排序。
具体实现时，选择一个基准元素，将小于基准的元素放到左侧，大于基准的元素放到右侧，然后对左右两部分分别进行递归排序。
快速排序的平均时间复杂度为O(nlogn)。
二、查找算法1. 顺序查找（Sequential Search）顺序查找是一种简单直观的查找算法。
它的基本思想是从待查找的序列的左侧开始，逐个比较序列中的元素和待查找元素，直到找到匹配的元素或查找结束。
顺序查找的时间复杂度为O(n)。
2. 二分查找（Binary Search）二分查找是一种高效的查找算法，但要求待查找序列必须是有序的。
它的基本思想是通过每一次查找将待查找序列划分为两部分，并将中间元素与待查找元素进行比较，进而确定下一次查找的范围。
数据结构与算法实验报告5-查找与排序
北京物资学院信息学院实验报告
课程名_数据结构与算法
实验名称查找与排序
实验日期年月日实验报告日期年月日姓名______ ___ 班级_____ ________ 学号___
一、实验目的
1.掌握线性表查找的方法；
2.了解树表查找思想；
3.掌握散列表查找的方法.
4.掌握插入排序、交换排序和选择排序的思想和方法；
二、实验内容
查找部分
1.实现顺序查找的两个算法（P307）, 可以完成对顺序表的查找操作, 并根据查到和未查到两种情况输出结果；
2.实现对有序表的二分查找；
3.实现散列查找算法(链接法)，应能够解决冲突；
排序部分
4.分别实现直接插入排序、直接选择排序、冒泡排序和快速排序算法
三、实验地点与环境
3.1 实验地点
3.2实验环境
(操作系统、C语言环境)
四、实验步骤
（描述实验步骤及中间的结果或现象。
在实验中做了什么事情, 怎么做的, 发生的现象和中间结果, 给出关键函数和主函数中的关键段落）
五、实验结果
六、总结
（说明实验过程中遇到的问题及解决办法；个人的收获；未解决的问题等）。
链表排序算法的python实现
链表排序算法的python实现⼀、链表排序1、归并排序（递归版）这个算法要采⽤递归，空间复杂度没办法达到O(n),时间复杂度为O(nlog(n)# -*- coding: utf-8 -*-'class ListNode(object):def __init__(self, x):self.val = xself.next = Noneclass Solution(object):def sortList(self, head):if not head or not head.next:return headprev, slow, fast = None, head, headwhile fast and fast.next:prev, slow, fast = slow, slow.next, fast.nextprev.next = None # 将链表切断，分为head和slow两条⼦链"""等价以下代码l1 = self.sortList(head)l2 = self.sortList(slow)return self.merge(l1, l2)"""return self.merge(*map(self.sortList, (head, slow)))def merge(self, l1, l2):dummy = l = ListNode(None)while l1 and l2:if l1.val < l2.val:l.next, l, l1 = l1, l1, l1.nextelse:l.next, l, l2 = l2, l2, l2.nextl.next = l1 or l2"""l1,l2长度不⼀样时，l.next为l1,l2中⽐另⼀个长度长的⼦链如 l1: 1->2 l2: 3->4->5, l.next为5等价于以下代码if l1:l.next = l1else:l.next = l2"""return dummy.nextif __name__ == "__main__":s = Solution()l = head = ListNode(None)for val in [0, 4, 1, 6, 7]:l.next = ListNode(val)l = l.nextli = s.sortList(head.next)while li:print li.valli = li.next2、快速排序这个算法⽐归并排序复杂，速度⽐归并排序快50%左右，但是没看懂，以后再细细研究class Solution(object):def sortList(self, head):""":type head: ListNode:rtype: ListNode"""def partition(start, end):node = start.next.nextpivotPrev = start.nextpivotPrev.next = endpivotPost = pivotPrevwhile node != end:temp = node.nextif node.val > pivotPrev.val:node.next = pivotPost.nextpivotPost.next = nodeelif node.val < pivotPrev.val:node.next = start.nextstart.next = nodeelse:node.next = pivotPost.nextpivotPost.next = nodepivotPost = pivotPost.nextnode = tempreturn [pivotPrev, pivotPost]def quicksort(start, end):if start.next != end:prev, post = partition(start, end)quicksort(start, prev)quicksort(post, end)newHead = ListNode(0)newHead.next = headquicksort(newHead, None)return newHead.next3、投机取巧法（但是速度真的很快，leetcode打败98.59%）此算法⽐较取巧，使⽤⼀个列表临时存储链表中的值。
基于链表的排序和查找算法的设计与实现
基于链表的排序和查找算法的设计与实现摘要：该程序的主要功能是对以链表为存储结构的数值型数据进行查找和排序。
关键字：存储结构链表排序。
0.引言查找是求出一个数据元素在序列中的索引或指针，将其返回，本程序返回的为指针。
排序是将一个数据元素(或记录)的任意序列，重新排列成一按关键字(或排序码)有序的序列，以便于进行数据查询。
1.需求分析本程序是基于链表的排序和查找，所以数据的存储结构为连式存储结构。
文件中记录用节点来表示，其物理位置任意，节点之间用指针相连，链表结构的有点在于排序是无需移动记录，只需修改相应记录的指针即可。
排序本程序用交换排序。
2.数据结构设计2.1建立单链表2.1.1 链表节点定义：整形元素 data存储数据，节点指针 next指向下一个节点typedef struct Cnode{int data;struct Cnode *next;}Cnode;2.1.2 链表数据的存储:函数insert（）在表尾插入数据：void insert(Cnode *p,int e){Cnode *s=new Cnode;s->data=e;s->next =NULL ;p->next =s;}因为insert（）函数如代码所示只是在一个指针后面连接一个指针，想要完成一组数据的链式存储，在主函数中还有相应的存储代码：int i,n,f,a[100];//={3,1,7,2,5,6,4};Cnode *h= new Cnode;Cnode *r,*p,*s;h->data=0;h->next =NULL;r=h;cout<<"请输入数据数目：";cin>>n;for(i=0;i<n;i++){cout<<i+1<<": ";cin>>a[i];insert(h,a[i]);h=h->next ;}h=r;h为头指针，将h赋给r，r记录h初始指向地址，在存完数据后，再将r 赋给h。
c语言链表排序算法
c语言链表排序算法在C语言中，链表的排序可以使用多种算法，如插入排序、归并排序、快速排序等。
以下是一个简单的插入排序算法的示例，用于对链表进行排序：C：#include<stdio.h>#include<stdlib.h>struct Node {int data;struct Node* next;};void insert(struct Node** head, int data) {struct Node* newNode= (struct Node*)malloc(sizeof(struct Node));newNode->data = data;newNode->next = NULL;if (*head == NULL) {*head = newNode;return;}struct Node* current = *head;while (current->next != NULL) {current = current->next;}current->next = newNode;}void sortList(struct Node** head) { struct Node* current = *head;while (current != NULL) {struct Node* next = current->next; while (next != NULL) {if (current->data > next->data) { int temp = current->data;current->data = next->data;next->data = temp;}next = next->next;}current = current->next;}}void printList(struct Node* head) { while (head != NULL) {printf("%d ", head->data);head = head->next;}}int main() {struct Node* head = NULL;insert(&head, 5);insert(&head, 2);insert(&head, 4);insert(&head, 1);insert(&head, 3);printf("Before sorting: ");printList(head);sortList(&head);printf("\nAfter sorting: ");printList(head);return0;}这个程序定义了一个链表节点结构体Node，其中包含一个整型数据data 和一个指向下一个节点的指针next。
链表的创建、删除、逆置、查找及排序
实验一链表的建立及删除要求：函数调用实现源程序：#include<stdio.h>#include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //记录创建的链表的长度linklist*creat(); //函数声明void dele(linklist *head,int x);void main(){linklist *head,*p;unsigned int x;head=creat();p=head->next;printf("建立的链表为：\n");while(p){printf("%f—>",p->data);p=p->next;}printf("\b\b\b");printf(" ");printf("\n");printf("请输入要删除第几个结点：第个"); printf("\b\b\b\b");scanf("%d",&x);dele(head,x);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r 所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}void dele(linklist *head,int x) //删除结点子函数{linklist *p,*q,*s;int i;if(x>length){printf("此节点不存在\n");}else{if(x==1) //删除第一个节点{s=head->next; //s指向第一个节点地址head=s->next; //头指针head的指针域中存放第二个结点的地址q=head; //使删除后从第一个结点开始输出链表元素printf("删除的第1个结点为：%f\n",s->data);}else //删除第一个节点以外的结点{p=head;q=head->next; //使删除后从第一个结点开始输出链表元素for(i=1;i<=x;i++){s=p; //s指向所删除的结点的前一结点p=p->next; //p指向所删除的结点}printf("删除的第%d个结点为：%f\n",x,p->data);s->next=p->next; //s的指针域存放所删除的结点的下一节点的地址}printf("删除该节点后的链表为：\n");while(q){printf("%f—>",q->data);q=q->next;}printf("\b\b\b"); printf(" "); printf("\n");}}一次执行结果：实验二链表的逆置要求：.函数调用实现源程序：#include<stdio.h>#include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //链表的长度linklist*creat(); //函数声明linklist *nizhi(linklist *head);void display(linklist *head);void main(){linklist *head,*s;head=creat();printf("建立的链表为：\n");display(head);head=nizhi(head);printf("逆置后链表为：\n");display(head);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}linklist *nizhi(linklist *head) //逆置子函数{linklist *s,*q=head,*p=head,*r;unsigned int i;if(length>1){for(i=0;i<length;i++) //p指向最后一个节点p=p->next;q=q->next; //头结点放到尾节点之后变成尾节点，新的尾节点指针域指向空s=(linklist *)malloc(sizeof(linklist));s->data=q->data;p->next=s;s->next=NULL;for(i=0;i<length-2;i++){q=q->next;r=(linklist *)malloc(sizeof(linklist));r->data=q->data;p->next=r;r->next=s;s=r;}r=(linklist *)malloc(sizeof(linklist));//建立新的头结点r->next=p;return r;}}void display(linklist *head) //输出链表子函数{linklist *p;p=head->next;while(p){printf("%f—>",p->data);p=p->next;}printf("\b\b\b"); printf(" "); printf("\n");}一次执行结果：实验三链表的查找要求：函数调用实现源程序：#include<stdio.h> #include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //链表的长度linklist*creat(); //函数声明void search(linklist *head,float a);void display(linklist *head);void main(){linklist *head,*s;float a;head=creat();printf("建立的链表为：\n");display(head);printf("请输入搜索值：");scanf("%f",&a);printf("查找结果：\n");search(head,a);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}void search(linklist *head,float a) //查找子函数{int i=length,j,k=0; //k记录找到查找查找项的个数linklist *p=head;p=p->next;for(j=1;j<=i;j++){if(p->data==a){printf("第%d个节点：%f\n",j,a);k++;}p=p->next;}if(k!=0)printf("共找到%d个搜索项\n",k);elseprintf("此链表中没有所查找的内容\n");}void display(linklist *head) //输出链表子函数{linklist *p;p=head->next;while(p){printf("%f—>",p->data);p=p->next;}printf("\b\b\b");printf(" ");printf("\n");}一次执行结果：实验四链表冒泡排序要求：函数调用实现源程序：#include<stdio.h>#include<stdlib.h>typedef struct node //定义节点类型{float data; //节点的值为浮点型struct node *next;}linklist;unsigned int length=0; //链表的长度linklist*creat(); //函数声明void sort(linklist *head);void display(linklist *head);void main(){linklist *head;head=creat();printf("建立的链表为：\n");display(head);sort(head);printf("从小到大排序后链表为：\n");display(head);}linklist *creat() //建立带头结点的单链表子函数，返回表头指针{float a;unsigned int k=0;linklist *head,*s,*r; //head为头结点，s,r为临时指针，建立链表是用到head=(linklist *)malloc(sizeof(linklist)); //生成头结点headr=head;printf("请输入链表长度：\n");scanf("%d",&length);printf("请输入数字创建链表:\n");for(k=0;k<length;k++){scanf("%f",&a);s=(linklist *)malloc(sizeof(linklist)); //生成头新的结点s,用于存放此次输入的数据s->data=a; //s的数据域存放ar->next=s; //此刻r所指向的结点的指针域存放s结点的地址r=s;}r->next=NULL; //最后一个节点的指针域为“空”return head; //返回表头指针}void sort(linklist *head) //排序子函数{unsigned int i,j;linklist *p=head,*q=head,*r=head;for(i=0;i<length-1;i++){p=head;q=head;q=q->next;for(j=i+1;j<length;j++){p=p->next;q=q->next;if(p->data>q->data){r->data=p->data;p->data=q->data;q->data=r->data;}}}}void display(linklist *head) //输出链表子函数{linklist *p;p=head->next;while(p){printf("%f—>",p->data); p=p->next;}printf("\b\b\b");printf(" ");printf("\n");}一次执行结果：。
基于链表的排序与查找
基于链表的排序与查找摘要：链表是程序设计中的一种重要的动态数据结构，它是动态地进行存储分配的一种结构。
链表即采用链式存储结构的线性表。
对线性表，我们主要对其的操作有：建立，插入，删除，查找，排序等。
此次实践主要是针对于链表的排序和查找进行。
关键字：链表排序查找1引言排序是计算机程序设计中的一种重要操作，它的功能是将一个数据元素（或记录）的任意序列，重新排列成一个按关键字有序的序列，以便于进行数据的查询。
而基于链表的查找是采用的动态查找表，是求出一个数据元素在序列中的索引或指针，将其返回。
2需求分析（1）建立链表；（2）基于链表的排序算法实现；（3）基于链表的查找算法实现。
3数据结构3.1建立链表3.1.1节点定义typedef struct node//定义节点{int data;struct node *next;}lnode, *linklist;3.1.2链表尾部插入void insertlist(linklist l,int i)//链表尾部插入{linklist p,s;s=(linklist)malloc(sizeof(lnode));s->data=i;s->next=NULL;p->next=s;}此时，相应的主函数中应该有存储代码，才能完成数据的链式存储。
int i,n,f,a[100];h=(lnode)malloc(sizeof(lnode));lnode *r,*p,*s;h->data=0;h->next =NULL;r=h;printf("请输入数据的数目：");scanf("%d",&n);for(i=0;i<n;i++){printf("%d:",i+1);scanf("%d",&a[i]);insert(h,a[i]);h=h->next ;}h=r;h为头指针，将h赋给r，r记录h初始指向地址，在存完数据后，再将r赋给h。
《数据结构》实验报告三：几种查找算法的实现和比较
第三次实验报告：几种查找算法的实现和比较//2019-12-4//1.随机生成5万个整数，存入一个文件；//2.算法实现：（1）顺序查找：读入文件中的数据，查找一个key，统计时间；// （2）二分查找：读入文件，排序，二分查找key，统计时间；// （3）分块查找：读入文件，分100块，每块300+数字，查找key，统计时间// （4）二分查找树：读入文件，形成BST，查找key，统计时间//二叉排序树：建立，查找#include "stdio.h"#include "time.h"#include "stdlib.h"struct JD{//定义分块查找的链表结点结构int data;JD *next;};struct INDEX_T{//定义分块查找中，索引表结构int max;//这一块中最大的数字，<maxJD *block;//每一块都是一个单向链表，这是指向块的头指针};INDEX_T myBlock[100];//这是索引表的100项struct NODE{//定义的二分查找树结点结构int data;NODE *left;NODE *right;};const int COUNT=50000;//结点个数int key=666;//待查找的关键字int m=1;//int *array2;void createData(char strFileName[]){//产生随机整数，存入文件srand((unsigned int)time(0));FILE *fp=fopen(strFileName,"w");for(int i=1;i<=COUNT;i++)fprintf(fp,"%d,",rand());fclose(fp);}void createBST(NODE* &bst){//产生5万个随机整数，创建二叉排序树FILE *fp=fopen("data.txt","r");for(int i=1;i<=COUNT;i++){int num;fscanf(fp,"%d,",&num);//从文件中读取一个随机整数//若bst是空子树，第一个结点就是根结点//若bst不是空子树，从根结点开始左小右大，查找这个数字，找到了直接返回，//找不到，就插入到正确位置//创建一个结点NODE* p=new NODE;p->data=num;p->left=0;p->right=0;if(0==bst)//空子树{bst=p;continue;}//非空子树,//在bst中，查找给结点，NODE *q=bst;//总是从根结点开始查找while(1){if(p->data == q->data)//找到了，直接退出break;if(p->data < q->data && q->left==0){//小，往左找，且左边为空，直接挂在q之左q->left=p;break;}if(p->data < q->data && q->left!=0){//小，往左找，且左边非空，继续往左边找q=q->left;continue;}if(p->data > q->data && q->right==0){//大，往右找，且右边为空，直接挂在q之右q->right=p;break;}if(p->data > q->data && q->right!=0){//大，往右找，且右边非空，继续往右边找q=q->right;continue;}}}}int BST_Search(NODE *bst,int key){//在bst中找key，if(0==bst)return -1;//非空子树,//在bst中，查找给结点，NODE *q=bst;//总是从根结点开始查找while(1){if(key == q->data)//找到了，直接退出return 1;if(key < q->data && q->left==0)//小，往左找，且左边为空，找不到return -1;if(key < q->data && q->left!=0)//小，往左找，且左边非空，继续往左边找{q=q->left;continue;}if(key > q->data && q->right==0)//大，往右找，且右边为空，找不到return -1;if(key > q->data && q->right!=0){//大，往右找，且右边非空，继续往右边找q=q->right;continue;}}}void inOrder(NODE *bst){if(bst!=0){inOrder(bst->left);array2[m]=bst->data;//反写回array数组，使数组有序// printf("%7d",array2[m]);m++;inOrder(bst->right);}}int getBSTHeight(NODE *bst){if(bst==0)return 0;else{int hl=getBSTHeight(bst->left);int hr=getBSTHeight(bst->right);int h=hl>hr?hl:hr;return h+1;}}void makeArray(int array[],char strFileName[]) {//生成5万个随机整数FILE *fp=fopen(strFileName,"r");int i=1;while(!feof(fp)){fscanf(fp,"%d,",&array[i]);// printf("%6d",array[i]);i++;}}int Seq_Search(int array[],int key){//在无序顺序数组中，找data是否存在，-1=不存在，存在返回位置下标//监视哨：把要找的那个数放到首部array[0]=key;//for(int i=COUNT;array[i]!=key;i--);if(i>0)//找到了，返回下标return i;return -1;//查找不成功，返回-1}int Bin_Search(int array[],int key){//在有序存储的数组中查找key，找到返回位置，找不到返回-1 int low=1,high=COUNT,mid;while(1){if(low>high)//找不到return -1;mid=(low+high)/2;if(key == array[mid])return mid;else if(key<array[mid])high=mid-1;elselow=mid+1;}}void makeBlock(INDEX_T myBlock[],char strFileName[]) {//从文件中读取整数，分配到块中去//1.初始化块索引表，分100块，400,800,1200，for(int i=0;i<=99;i++){myBlock[i].max=400+400*i;//400,800,1200, (40000)myBlock[i].block=0;}//2.打开文件，读取整数，把每一个整数分配到相应的块中去FILE *fp=fopen(strFileName,"r");while(!feof(fp)){int num=0;fscanf(fp,"%d,",&num);//把num分配到num/400块中，挂到该块链表第一个int blockID=num/400;//求出应该挂在的块号//生成一个新节点，把num放进去，挂上JD *p=new JD;p->data=num;p->next=myBlock[blockID].block;myBlock[blockID].block=p;}fclose(fp);}int Block_Search(INDEX_T myBlock[],int key){int blockID=key/400;//找到块号JD* p=myBlock[blockID].block;while(p!=0){if(p->data==key)return blockID;//能找到p=p->next;}return -1;//找不到}void main(){clock_t begin,end;int pos=-1;//1.生成文件，存入5万个随机整数createData("data.txt");//2.顺序查找int *array=new int[COUNT+1];makeArray(array,"data.txt");//从文件中读取数据begin=clock();for(int k=1;k<=10000;k++)pos=Seq_Search(array,key);end=clock();printf("顺序查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//3.二分查找树NODE *bst=0;createBST(bst);//产生5万个随机数字，建立一个二叉排序树begin=clock();for(k=1;k<=10000;k++)pos=BST_Search(bst,key);//在bst中找key，找到返回1，找不到返回-1end=clock();printf("二叉排序树查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);array2=new int[COUNT+1];inOrder(bst);//中序输出bst// int height=getBSTHeight(bst);//求出bst的高度// printf("BST高度=%d.\n\n",height);//4.二分查找，利用前面二叉排序树产生的array2，查找key begin=clock();for(k=1;k<=10000;k++)pos=Bin_Search(array2,key);end=clock();printf("二分查找：%d所在的位置=%d.时间=%d毫秒\n",key,pos,end-begin);//5.分块查找，关键字范围[0,32767],分配到100块中去，每一块中存400个数字makeBlock(myBlock,"data.txt");//从文件中读取数据，产生块begin=clock();for(k=1;k<=10000;k++)pos=Block_Search(myBlock,key);//在block中查找key，找到返回块号，找不到返回-1end=clock();printf("分块查找：%d所在的块=%d.时间=%d毫秒\n",key,pos,end-begin);/*for(k=0;k<=99;k++){printf("\n\n\n第%d块<%d:\n",k,myBlock[k].max);JD *q=myBlock[k].block;//让q指向第k块的第一个结点while(q!=0){//输出第k块中所有数字printf("%7d ",q->data);q=q->next;}}*/}。
链表排序算法总结
这个星期做数据结构课设，涉及到两个基于链表的排序算法，分别是基于链表的选择排序算法和归并排序算法。
写出来跟大家一起分享一下，希望对数据结构初学朋友有所帮助，高手就直接忽视它吧。
话不多说，下面就看代码吧。
[c-sharp]view plaincopy1.node *sorted(node *sub_root)2.{3.if (sub_root->next)4. {5. node * second_half = NULL;6. node * first_half = sub_root;7. node * temp = sub_root->next->next;8.while (temp)9. {10. first_half = first_half->next;11. temp = temp->next;12.if(temp)13. temp = temp->next;14. }15. second_half = first_half->next;16. first_half->next = NULL;17. node * lChild = sorted(sub_root);18. node * rChild = sorted(second_half);19.if (lChild->data < rChild->data)20. {21. sub_root = temp = lChild;22. lChild = lChild->next;23. }24.else25. {26. sub_root = temp = rChild;27. rChild = rChild->next;28. }29.while (lChild&&rChild)30. {31.if (lChild->data < rChild->data )32. {33. temp->next = lChild;34. temp = temp->next;35. lChild = lChild->next;36. }37.else38. {39. temp->next = rChild;40. temp = temp->next;41. rChild = rChild->next;42. }43. }44.if (lChild)45. temp->next = lChild;46.else47. temp->next = rChild;48. }49.return sub_root;50.51.}上面贴出来的就是归并排序的算法，刚开始写的时候，由于考虑不够周到，出现许多错误，经过调式之后，才能运行成功。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
《数据结构》实践任务书学生姓名：专业班级：指导教师：题目: 基于链表的排序与查找要求：（1）熟练掌握基本的数据结构；（2）熟练掌握各种算法；（3）运用高级语言编写质量高、风格好的应用程序。
主要任务:1、系统应具备的功能：（1）建立链表（2）基于链表的排序算法实现（3）基于链表的查找算法实现2、数据结构设计；3、主要算法设计；4、编程及上机实现；5、撰写数据结构实践报告，包括：（1）设计题目；（2）摘要和关键字；（3）正文，包括引言、需求分析、数据结构设计、算法设计、程序实现及测试等；（4）结束语；（5）参考文献。
时间安排：2014年-2015年第1学期第15周-第17周15周星期五 1-4节系统设计，数据结构设计，算法设计16周星期四 5-8节编程并上机调试16周星期五 1-4节编程并上机调试17周星期四 5-8节验收程序，提交数据结构实践报告书指导教师签名：2014年11月基于链表的排序和查找算法的设计与实现摘要：该程序的主要功能是对以链表为存储结构的数值型数据进行查找和排序。
排序和查找是链表中的一个重要应用。
本文对输入的n个整数进行内部排序，使用交换排序来实现。
在本程序中应用链式存储结构，对数据进行了基本的查找和排序。
关键字：存储结构链表排序排序。
1.引言查找是求出一个数据元素在序列中的索引或指针，将其返回，本程序返回的为指针。
排序是将一个数据元素(或记录)的任意序列，重新排列成一按关键字(或排序码)有序的序列，以便于进行数据查询。
2.需求分析本程序是基于链表的排序和查找，所以数据的存储结构为连式存储结构。
文件中记录用节点来表示，其物理位置任意，节点之间用指针相连，链表结构的有点在于排序是无需移动记录，只需修改相应记录的指针即可。
排序本程序选用交换排序。
3.数据结构设计3.1建立单链表3.1.1 链表节点定义：整形元素 data存储数据，节点指针 next指向下一个节点typedef struct Cnode{int data;struct Cnode *next;}Cnode;3.1.2 链表数据的存储:函数insert（）在表尾插入数据：void insert(Cnode *p,int e){Cnode *s=new Cnode;s->data=e;s->next =NULL ;p->next =s;}因为insert（）函数如代码所示只是在一个指针后面连接一个指针，想要完成一组数据的链式存储，在主函数中还有相应的存储代码：int i,n,f,a[100];//={3,1,7,2,5,6,4};Cnode *h= new Cnode;Cnode *r,*p,*s;h->data=0;h->next =NULL;r=h;cout<<"请输入数据数目：";cin>>n;for(i=0;i<n;i++){cout<<i+1<<": ";cin>>a[i];insert(h,a[i]);h=h->next ;}h=r;h为头指针，将h赋给r，r记录h初始指向地址，在存完数据后，再将r 赋给h。
4 算法设计4.1 排序算法的设计4.1.1 排序的定义设含有n个记录（R）的文件f=(R1,R2······Rn)，相应记录关键字（key）的集合k={k1,k2······kn}.若对1，2······n的一种排序：P1P2······Pn(1≤Pi≤n，i≠j时，Pi≠Pj)有：kp1≤kp2≤······≤kpn 递增关系或 kp1≥kp2≥······≥kpn 递减关系则使文件f按key线性有序：（Rp1,Rp2······Rpn）称这种运算为排序（或分类）。
值得提出的是，关系符“≥”“≤”并不一定是数学意义上的“小于或等于”或“大于或等于”，而是一种次序关系。
为了讨论方便，一般取整形数作为记录的key,故“≤”或“≥”可作为通常意义上的符号看待。
2.排序方法截至目前，根据各种排序方法的思路，内排序可归纳为以下5类：（1）插入排序（2）交换排序（3）选择排序（4）归并排序（5）基数排序本程序所选择的排序为（2）交换排序。
4.1.2 排序算法的设计void sort(Cnode *h)//排序{int len=count(h);for(int j=0;j<len;j++){int flag=0; //排序完成与否标志Cnode *p=h,*tem,*cur=h->next ,*nex=cur->next,*pre=h;while(cur->next !=NULL){if(cur->data > nex->data){tem=nex->next;cur->next=tem;nex->next=cur;pre->next=nex;}pre=cur;cur=nex;nex=nex->next ;}}}排序中所要用的计算链表长度count（）函数int count(Cnode *p){int i=0;Cnode *r=p;while(r->next!=NULL){r=r->next ;i++;}return i;}4.2数据元素的查找Cnode *find(Cnode *p,int e){Cnode *r;r=p;while(r!=NULL && r->data!=e){r=r->next ;}return r;}4.3 程序主函数void main(){int i,n,f,a[100];Cnode *h= new Cnode;Cnode *r,*p,*s;h->data=0;h->next =NULL;r=h;cout<<"请输入数据数目：";cin>>n;for(i=0;i<n;i++){cout<<i+1<<": ";cin>>a[i];insert(h,a[i]);h=h->next ;}h=r;cout<<"请输要查找的元素：";cin>>f;cout<<"排序前数据顺序：";for(i=0;i<n;i++){h=h->next ;cout<<h->data<<" " ;}cout<<endl;h=r;s=find(h,f);cout<<"要查元素的下一元素的数据：";if(s->next !=NULL)cout<<s->next->data<<endl ;elsecout<<"所查元素在队尾！";sort(h);cout<<"排序后数据顺序：";for(i=0;i<n;i++){ h=h->next ;cout<<h->data<<" " ;}cout<<endl;h=r;s=find(h,f);cout<<"要查元素的下一元素的数据：";if(s->next !=NULL)cout<<s->next->data<<endl ;elsecout<<"所查元素在队尾！";}5.运行结果6.设计体会这次数据结构课程设计，我切身的体会到程序必须满足整体严谨，思路清晰，方法合理三个方面，对于综合性的程序更是如此，编程是一个很烦琐的过程，每一小步都要以整体为出发点稍有不慎即导致整个程序出错。
这几个日日夜夜的奋战终于获得一点的成果。
但是遗憾也是很多的，这次数据结构课程设计为我今后的学习指明了方向。
通过这次数据结构课程设计，我对内部排序和查找这两块的知识有了更深的领会，同时加强了对链式存储结构的认识，对C++语言的运用能力有了质的飞跃。
虽然程序还有很多不足之处，但作为我写的一个综合型程序，我还是觉得受益匪浅。
7.结束语在本程序中，我用链式存储结构，对数据进行了基本的查找和排序。
虽然有许多查找和排序方法没使用到，但还是有不小收获。
对于指针的使用一直是我担心的地方，通过上次的实验报告和这次的课程设计，我对于指针用法有了新的体会。
对于指针的排序也略微掌握了一些。
总之这次课程设计的收获还是不小的。
8.参考文献[1]严蔚敏，吴伟民. 《数据结构（C语言版）》, 清华大学出版社，2004年[2]徐绪松，《数据结构与算法导论》, 电子工业出版社，2005年[3]苏世华.《数据结构与算法解析》, 国防工业出版社，2005年[4]宁正元，王秀丽. 《算法与数据结构》 , 清华大学出版社，2004年[5]高小兵.《数据结构实验教程》 , 清华大学出版社，2005年《数据结构》实践成绩评定表班级：姓名：学号：序号评分项目满分实得分1 学习态度认真、遵守纪律102 设计分析合理性103 设计方案正确性、可行性204 设计结果正确性405 设计报告的规范性106 设计验收10总得分/等级评语：注：最终成绩以五级分制记。
优（90-100分）、良（80-89分）、中（70-79分）、及格（60-69分）、60分以下为不及格指导教师签名：年月日11。