順序演算法程序

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語言做各種排序演算法比較程序怎麼做

按照程序設計的自頂向下，逐步求精的機構化程序設計思想來完成這個任務。
①大概的頂層框架是：隨機數產生模塊，文件保存模塊，排序以及統計排序過程信息的模塊。
②分別設計出隨機數產生演算法，三種排序演算法。
③按照邏輯的順序進行組裝，並給出必要的過程信息。
演算法的設計實現以及程序運行結果：