顺序算法程序

A. 实现顺序表的基本操作，编写将两个顺序表合并的算法或程序

将A表中元素依次拿出，每拿出一个元素，将它插入到B表结尾并进行排序，直到将所有A表中所有元素都拿出完为止

B. 顺序查找算法

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

#define MAX_LENGTH 100
typedef int KeyType;

typedef struct {
KeyType *elem;
int length;
}SSTable; //顺序表的存储结构

/*
此算法比第二个算法多了一个判定i是否出界的流程，对于查找数目较少的情况，
二者查找时间相差不大，对于存在大量数据时，该算法的主要查找时间消耗再判
定是否出界上，所以第二个算法明显比第一个算法好，唯一增加的就是一个“哨兵”
数据。
int Search_Seq(SSTable ST, KeyType key){
int i;
for(i=1; i<=ST.length && ST.elem[i] != key; i++ )
;
if(i<=ST.length)
return i;
else
return 0;
}
*/

int Search_Seq(SSTable ST, KeyType key){
int i;
ST.elem[0] = key; //“哨兵”，如果顺序表中不存在要查找的数据的话，则查找指针必定指向该哨兵
for(i = ST.length; ST.elem[i] != key; i--)
;
return i; //找到的话，则i != 0,否则i = 0
}

void main()
{
int i, key;
SSTable T;
T.elem = (KeyType *)malloc(sizeof(KeyType));
printf("How Many Entries Do You Want input\n");
scanf("%d", &T.length);
for(i=1; i<=T.length; i++){
printf("Please input the %dth entries \n", i);
scanf("%d", &T.elem[i]);
}
for (i=1; i<=T.length; i++)
printf("%5d",T.elem[i]); //显示已经输入的所有数据
printf("\nPlease input the data you want to search\n");
scanf("%d", &key);
i = Search_Seq(T,key);
printf("the search data is locate the %dth(0 indicate can not find)\n",i);
}

C. 索引顺序查找算法

索引查找是在索引表和主表(即线性表的索引存储结构)上进行的查找。索引查找的过程是：首先根据给定的索引值K1，在索引表上查找出索引值等于KI的索引项，以确定对应予表在主表中的开始位置和长度，然后再根据给定的关键字K2，茬对应的子表中查找出关键字等于K2的元素(结点)。对索引表或子表进行查找时，若表是顺序存储的有序表，则既可进行顺序查找，也可进行二分查找，否则只能进行顺序查找。
设数组A是具有mainlist类型的一个主表，数组B是具有inde)dist类型的在主表A 上建立的一个索引表，m为索引表B的实际长度，即所含的索引项的个数，KI和K2分别为给定待查找的索引值和关键字(当然它们的类型应分别为索引表中索引值域的类型和主表中关键字域在索引存储中，不仅便于查找单个元素，而且更便于查找一个子表中的全部元素。当需要对一个子袁中的全部元素依次处理时，只要从索引表中查找出该子表的开始位置即可。由此开始位置可以依次取出该子表中的每一个元素，所以整个查找过程的时间复杂度为，若不是采用索引存储，而是采用顺序存储，即使把它组织成有序表而进行二分查找时，索引查找一个子表中的所有元素与二分查找一个子表中的所有元素相比。
若在主表中的每个子表后都预留有空闲位置，则索引存储也便于进行插入和删除运算，因为其运算过程只涉及到索引表和相应的子表，只需要对相应子表中的元素进行比较和移动，与其它任何子表无关，不像顺序表那样需涉及到整个表中的所有元素，即牵一发而动全身。
在线性表的索引存储结构上进行插入和删除运算的算法，也同查找算法类似，其过程为：首先根据待插入或删除元素的某个域(假定子表就是按照此域的值划分的)的值查找索引表，确定出对应的子表，然后再根据待插入或删除元素的关键字，在该子表中做插入或删除元素的操作。因为每个子表不是顺序存储，就是链接存储，所以对它们做插入或删除操作都是很简单的。

不知道答案与兄台的问题是否一致，也是网上找的，不对请见谅哈~~

D. 程序设计中有哪些排序算法用c语言分别怎样实现

冒泡排序法，折半查找法。折半是有一定的顺序的中找，利用折半减少查找次数。
、没优化的冒泡我就不说了，优化的说是拿第一个元素跟后面的一个个比较，大的或小的放到第一个，这样第一次比较出来的就是最大的或最小的，然后第二个在跟后面的元素一个个比较，找出第二大或第二小，依此到完，用到二个FOR循环。

E. c语言简单顺序程序设计原理是什么

什么顺序程序啊？是
（1）顺序结构
顺序结构的程序设计是最简单的，只要按照解决问题的顺序写出相应的语句就行，它的执行顺序是自上而下，依次执行。
例如；a = 3，b = 5，现交换a，b的值，这个问题就好像交换两个杯子水，这当然要用到第三个杯子，假如第三个杯子是c，那么正确的程序为： c = a； a = b； b = c； 执行结果是a = 5，b = c = 3如果改变其顺序，写成：a = b； c = a； b = c； 则执行结果就变成a = b = c = 5，不能达到预期的目的，初学者最容易犯这种错误。 顺序结构可以独立使用构成一个简单的完整程序，常见的输入、计算，输出三步曲的程序就是顺序结构，例如计算圆的面积，其程序的语句顺序就是输入圆的半径r，计算s = 3.14159*r*r,输出圆的面积s。不过大多数情况下顺序结构都是作为程序的一部分，与其它结构一起构成一个复杂的程序，例如分支结构中的复合语句、循环结构中的循环体等

F. 利用选择法，描述将 N 个数按从小到大顺序排列的基本思路与算法流程。

把未排序的数放在右边，已排序的放左边，算法就是，不断地从右边选取最小者放到左边。

选择排序法是一种不稳定的排序算法。它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。

选择排序法的第一层循环从起始元素开始选到倒数第二个元素，主要是在每次进入的第二层循环之前，将外层循环的下标赋值给临时变量。

接下来的第二层循环中，如果发现有比这个最小位置处的元素更小的元素，则将那个更小的元素的下标赋给临时变量，最后，在二层循环退出后，如果临时变量改变，则说明，有比当前外层循环位置更小的元素，需要将这两个元素交换。

(6)顺序算法程序扩展阅读：

选择法的稳定性

选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。

那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。

比较拗口，举例如下，序列5、8、5、2、9，知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。

G. 数据结构 顺序表的五种算法写成能执行的c语言程序

没运行过，我也不知道可不可以。voidfun(LinkList*L,LinkList*&a,LinkList*&b,LinkList*&c){LinkLIst*p,*q,*tailofa,*tailofb,*tailofc;p=L;tailofa=a;tailofb=b;tailofc=c;while(p!=NULL){q=p->next;if(('A'data&&p->datadata&&p->datanext=p;tailofa=tailofa->next;}elseif('0'data&&p->datanext=p;tailofb=tailofb->next;}else{tailofc->next=p;tailofc=tailofc->next;}p=q;}tailofc->next=NULL;tailofa->next=NULL;tailofb->next=NULL;}

H. 编写顺序查找算法的程序

查找算法集：顺序查找、二分查找、插值查找、动态查找(数组实现、链表实现)

// search.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "LinkTable.h"
#define MAX_KEY 500

//------------------------------数组实现部分----------------------------------
/**//*
无序数组顺序查找算法函数nsq_Order_Search<用数组实现>
参数描述：
int array[] :被查找数组
int n :被查找数组元素个数
int key :被查找的关键值
返回值:
如果没有找到: nsq_Order_Search = -1
否则: nsq_Order_Search = key数组下标
*/
int nsq_Order_Search(int array[],int n,int key)
...{
int i;
array[n] = key;
/**//*for循环后面的分号必不可少*/
for(i=0;key!=array[i];i++);
return(i<n?i:-1);
}
/**//*
有序数组顺序查找算法函数sq_Order_Search<用数组实现>
参数描述：
int array[] :被查找数组
int n :被查找数组元素个数
int key :被查找的关键值
返回值:
如果没有找到: sq_Order_Search = -1
否则: sq_Order_Search = key数组下标
*/
int sq_Order_Search(int array[],int n,int key)
...{
int i;
array[n] = MAX_KEY;
/**//*for循环后面的分号必不可少*/
for(i=0;key>array[i];i++);
if(i<n && array[i] == key)
return(i);
else
return(-1);
}
/**//*
有序数组二分查找算法函数sq_Dichotomy_Search0<用数组实现>
参数描述：
int array[] :被查找数组
int n :被查找数组元素个数
int key :被查找的关键值
返回值:
如果没有找到: sq_Dichotomy_Search0 = -1
否则: sq_Dichotomy_Search0 = key数组下标
*/
int sq_Dichotomy_Search0(int array[],int n,int key)
...{
int low,high,mid;
low = 0;
high = n - 1;

while(low<=high)
...{
mid = (high+low)/2;
if(array[mid] == key)
return(mid);
/**//*key>array[mid] 表明要求查找的值在[mid+1,high]*/
/**//*否则,在[low,mid-1]*/
if(key > array[mid])
low = mid + 1;
else
high = mid - 1;
}
return(-1);
}
/**//*
有序数组插值查找算法函数sq_Dichotomy_Search1<用数组实现>
(插值查找算法是二分查找算法的改进)
参数描述：
int array[] :被查找数组
int n :被查找数组元素个数
int key :被查找的关键值
返回值:
如果没有找到: sq_Dichotomy_Search1 = -1
否则: sq_Dichotomy_Search1 = key数组下标
*/
int sq_Dichotomy_Search1(int array[],int n,int key)
...{
int low,high, //二分数组的上,下标
pos; //查找码的大致(估算)位置
low = 0;
high = n-1;
while(low <= high)
...{
pos = (key-array[low])/(array[high]-array[low])*(high-low)+low;
/**//*找到关键值,中途退出*/
if(key == array[pos])
return(pos);
if(key > array[pos])
low = pos + 1;
else
high = pos - 1;
}
/**//*没有找到,返回-1*/
return(-1);
}
//------------------------------数组实现部分----------------------------------
//------------------------------链表实现部分----------------------------------
/**//*
无序链表顺序查找算法函数nlk_Order_Serach<用链表实现>
[查找思想:遍历链表的所有节点]
参数描述：
Node *head :被查找链表的首指针
int key :被查找的关键值
返回值:
如果没有找到: nlk_Order_Serach = NULL
否则: nlk_Order_Serach = 键值为key的节点的指针
*/
Node *nlk_Order_Serach(Node *head,int key)
...{
for(;head!=NULL && head->data != key;head = head->link);
return(head);
}
/**//*
有序链表顺序查找算法函数lk_Order_Serach<用链表实现>
[查找思想:依次遍历链表的节点,发现节点不在key的范围时提前结束查找]
参数描述：
Node *head :被查找链表的首指针
int key :被查找的关键值
返回值:
如果没有找到: lk_Order_Serach = NULL
否则: lk_Order_Serach = 键值为key的节点的指针
*/
Node *lk_Order_Search(Node *head,int key)
...{
for(;head!=NULL && head->data < key;head=head->link);
/**//*当遍历指针为NULL或没有找到键值为key的节点,返回NULL(表明没有找到)*/
/**//*否则,返回head(表明已经找到)*/
return(head==NULL || head->data != key ? NULL : head);
}
/**//*
有序链表动态查找算法函数lk_Dynamic_Search<用链表实现>
[查找思想:依次遍历链表的节点,发现节点不在key的范围时提前结束查找]
参数描述：
Node *head: 被查找链表的首指针
Node **p; 键值为key的节点的前驱指针(回传参数)
Node **q: 键值为key的节点指针(回传参数)
int key : 被查找的关键值
注意:
当 *p == NULL 且 *q != NULL,链表的首节点键值为key
当 *p != NULL 且 *q != NULL,链表的中间(非首,尾)节点键值为key
当 *p != NULL 且 *q == NULL,链表的尾节点键值为key
当 *p == NULL 且 *q == NULL,链表是空链表
*/
void lk_Dynamic_Search(Node *head,Node **p,Node **q,int key)
...{
Node *pre,*cur;
pre = NULL;
cur = head;
for(;cur != NULL && cur->data < key;pre = cur,cur = cur->link)
*p = pre;
*q = cur;
}
/**//*
有序链表动态插入算法函数lk_Dynamic_Insert<用链表实现>
参数描述：
Node *head: 被插入链表的首指针
int key : 被插入的关键值
返回值:
lk_Dynamic_Search = 插入键值为key的节点后的链表首指针
*/
Node *lk_Dynamic_Insert(Node *head,int key)
...{
Node
*x, //插入节点的前驱节点
*y, //插入节点的后续节点
*p; //插入的节点
p = (Node *)malloc(sizeof(Node));
p->data = key;
p->link = NULL;
lk_Dynamic_Search(head,&x,&y,key);
if(x==NULL)
...{
p->link = x;
head = p;
}
else
...{
p->link = x->link;
x->link = p;
}
ListLinkTable(head,"插入节点");
return(head);
}
/**//*
有序链表动态删除算法函数lk_Dynamic_Delete<用链表实现>
参数描述：
Node *head: 被删除链表的首指针
int key : 被删除的关键值
返回值:
lk_Dynamic_Delete = 删除键值为key的节点后的链表首指针
*/
Node *lk_Dynamic_Delete(Node *head,int key)
...{
Node *x, //删除节点的前驱节点
*y; //删除的节点
lk_Dynamic_Search(head,&x,&y,key);
if(x==NULL)
/**//*因为x=NLLL时,y指向首指针*/
head = y->link;
else
x->link = y->link;
free(y);
ListLinkTable(head,"删除节点");
return(head);
}
//------------------------------链表实现部分----------------------------------
int main(int argc, char* argv[])
...{
Node *head;
//Node *p,*x,*y;
int KEY;
int count,i;
//int result;
KEY = 11;
//PrintArrayValue(TestArray2,DEFAULT_ARRAY_SIZE,"原始");
//result = sq_Dichotomy_Search1(TestArray2,DEFAULT_ARRAY_SIZE,KEY);
//printf("查找结果是：数组[%d] = %d ",result,TestArray2[result]);
head = CreateLinkTable(DEFAULT_ARRAY_SIZE,TestArray2);
ListLinkTable(head,"原始");
/**//*
p = lk_Order_Search(head,KEY);
if(p==NULL)
printf(" 查找结果是：指定链表中没有[数据域 = %d]的节点! ",KEY);
else
printf(" 查找结果是：节点.Data = %d 节点.Link = %d 节点.Addr = %d ",p->data,p->link,p);
*/
printf("输入插入节点的个数： ");
scanf("%d",&count);
for(i=0;i<count;i++)
...{
printf("输入插入节点的数据域： ");
scanf("%d",&KEY);
lk_Dynamic_Insert(head,KEY);
}
do
...{
printf("输入删除节点的数据域： ");
scanf("%d",&KEY);
lk_Dynamic_Delete(head,KEY);
}while(head!=NULL);
printf(" 应用程序正在运行...... ");
return 0;
}

I. c语言做各种排序算法比较程序怎么做

按照程序设计的自顶向下，逐步求精的机构化程序设计思想来完成这个任务。
①大概的顶层框架是：随机数产生模块，文件保存模块，排序以及统计排序过程信息的模块。
②分别设计出随机数产生算法，三种排序算法。
③按照逻辑的顺序进行组装，并给出必要的过程信息。
算法的设计实现以及程序运行结果：