顺序查找、直接查找、折半查找算法

内蒙古科技大学

题目：数据结构课程设计学生姓名：保祥

学号：0865138236

专业：信息管理与信息系统班级：信管2班

指导教师：杨振华

一．顺序表的操作

（1）插入元素操作：将新元素x插入到顺序表a中第i个位置。

（2）删除元素操作：删除顺序表a中第i个元素。

操作代码如下：

#include

#define MAX 20

typedef int datatype;

typedef struct

{datatype data[MAX]; int list;} sequenlist; /*顺序表*/ int main()

{int insert( sequenlist *L, int x, int i );

int deletee( sequenlist *L, int i );

int input( sequenlist *L ); /

int output( sequenlist *L );

sequenlist s,*p=&s;

int indata,inlocate,deletedx;

input(p);

printf("请输入要插入的数：");

scanf("%d",&indata);

printf("请输入要插入的位置：");

scanf("%d",&inlocate);

insert( p,indata,inlocate );

printf("插入后的数据：");

output(p);

printf("请输入要删除的位置：");

scanf("%d",&deletedx);

deletee( p, deletedx );

printf("删除后的数据：");

output(p);

return 0;}

int output(sequenlist *L)

{int i; for ( i=0; i<=L->list; i++ ) printf("%d ",L->data[i]);printf("\n\n");return(1);} int input( sequenlist *L )

{int i; printf("请输入原始数据个数：");

scanf("%d",&(L->list));L->list--; printf("请输入原始数据：");

for ( i=0; i <= L->list; i++ ) scanf("%d",&(L->data[i]));

printf("原始数据为：");

output(L);

return (1);

}

int insert( sequenlist *L, int x, int i )

{ int j;

if ( ((*L).list)>=MAX-1 )

{ printf("overflow"); return 0; }

else

{if ( (i<1) || ( i > ((*L).list)+1 ) )

{ printf("error"); return 0; }

else

{ for ( j=L->list; j>=i-1; j-- )

L->data[j+1]=L->data[j];L->data[i-1]=x; L->list++; } }

return(1);}

int deletee( sequenlist *L, int i ) /*定义删除函数*/

{ int j;if ( (i<1) || ( i > (L->list)+1 ) )

{ printf("error");

return 0;

} else { for ( j=i; j<=L->list; j++ )

L->data[j-1]=L->data[j]; L->list--; }

return (1);｝

图一

二、单链表的操作

（1）创建一个带头结点的单链表；

（2）插入元素操作：将新元素x插入到单链表中第i个元素之后；（3）删除元素操作：删除单链表中值为x的元素；

代码如下：

#include

#include

typedef struct node //定义链表

{ int data;

struct node *next;

}snode;

snode* creat() //创建链表的函数

{ snode *head, *p, *q;

head = (snode *)malloc(sizeof(snode));

p = head;

int x;

printf("请输入创建链表的值，用-1结束输入");

printf("x = ");

scanf("%d", &x);

while (x != -1)

{ q = (snode *)malloc(sizeof(snode));

q->data = x;

p->next = q;

p = q;

printf("x = ");

scanf("%d", &x); }

p->next = NULL; return head;}

int length(snode *head)//测链表的结点数

{ int i = 0; snode *p = head->next;

while (p != NULL)

{ p = p->next; i++; } return i;}

void display(snode *head)

{ snode *p = head->next;

for(int i = 0; i < length(head); i++)

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

p = p->next; }

printf(" ");

}

int locate(snode *head, int x)

{snode *p = head->next;

int i = 1;

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

{ p = p->next; i++; }

if (p == NULL) return 0;

else return i;

}

int insnode(snode *head, int x, int i) //把x插入到链表的第i的位置{ int j;

snode *p = head->next, *s;

if(i < 1 || i > (length(head) + 1))

return 0;

else if (i == 1)

{ s = (snode *)malloc(sizeof(snode)); s->next = p;

head->next = s; s->data = x;

}

else

{ for (j = 1; j < i - 1; j++)

p = p->next;

s = (snode *)malloc(sizeof(snode));

s->next = p->next;

p->next = s;

s->data = x;

}

return 1;

}

int delnode(snode *head, int i)//删除链表中第i个结点

{

snode *p = head->next, *q = head;

if(i < 1 || i > length(head))

return 0;

else if (i == 1)

{ head->next = p->next;

free(p);

} else

{ for (int j = 1; j < i; j++)

{

p = p->next; q = q->next; }

q->next = p->next;

free(p); }

return 1;

}

void sort(snode *head) //把链表中每个结点的值按从小到大排列

{

snode *p, *q;

int k;

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

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

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

{ k = p->data; p->data = q->data; q->data = k; }

}

void insert(snode *head, int x) //在有序链表中插入x,插入后仍保持有序

{ snode *p = head->next, *s, *q = head;

while (p != NULL && p->data < x)

{ q = q->next;

p = p->next;

}

s = (snode *)malloc(sizeof(snode));

s->next = q->next; s->data = x; q->next = s;

}

void del_min_max(snode *head, int min, int max) //删除有序链表中值min到值max 中的结点

{ snode *p = head->next, *q = head;

while (p != NULL && p->data <= min)

{ q = p;

p = p->next; }

while (p != NULL && p->data < max)

{ q->next = p->next;

free(p);

p = q->next;

}

}

void del_min(snode *head)

{

snode *p = head->next, *q = head;

snode *p_min, *q_min;

p_min = p;

q_min = q;

while (p != NULL)

{

q = p; p = p->next;

if (p != NULL && p->data < p_min->data)

{ q_min = p_min;

p_min = p;

}

}

q_min->next = p_min->next;

free(p_min);

}

int main()

{ int min, max;

snode *headl = creat(); //创建链表

printf("最初的链表如下：");

display(headl);

int num, location;

printf("请输入您要查找的数：");

scanf("%d", &num);

if (locate(headl, num))

printf("数字%d在链表中的位置为%d ", num, locate(headl, num));

else

printf("数字%d在链表中不存在", num);

printf("请分别输入您要插入到链表中的数以及想插入的位置：");

scanf("%d %d", &num, &location);

if (insnode(headl, num, location))

{ printf("插入新值以后的链表如下：");

display(headl);

} else printf("输入有误");

printf("请输入您想删除的结点位置：");

scanf("%d", &location);

if (delnode(headl, location))

{ printf("删除第%d个结点后的链表如下：", location);

display(headl);

} else

printf("输入有误！");

}

图二

三、在顺序栈上实现将非负十进制数转换成二进制数代码：#include

#include

#define TRUE 1

#define FALSE 0

#define OK 0

#define ERROR -1

typedef struct SNode{

int data;

struct SNode *next;

}SNode;

typedef struct{

int length;

SNode *top;

}STACK;

void InitStack(STACK *S){

S->top=NULL;S->length=0;

}

int Push(STACK *S,int e){

SNode *p;

p=(SNode *)malloc(sizeof(SNode)); if(!p) return ERROR;

p->data=e;p->next=S->top;

S->top=p;S->length++;

return OK;

}

int Pop(STACK *S,int *e){

SNode *p;

if(S->top==NULL) return ERROR; p=S->top;*e=p->data;

S->top=p->next;S->length--; return OK;

}

int Empty(STACK S){

if(S.top==NULL) return TRUE; return FALSE;

}

int main(){

int j,k,n;

STACK S;

do{

printf("请输入一个正整数:"); scanf("%d",&n);

}while(!(n>0&&n<32767)); InitStack(&S);

for(k=n;k>0;k=k/2)

Push(&S,k%2);

while(Pop(&S,&j)!=ERROR) printf("%d",j);

return OK;｝

图三

四、在顺序表中采用顺序查找算法和折半查找算法寻找关键字X在顺序表中的位置

代码：#include

#include

#define MAXL 1000

#define INF 32767

int process[MAXL],pn;

//顺序表的存储结构

typedef int KeyType;

typedef int InfoType;

typedef struct

{ KeyType key;

InfoType data;

} NodeType;

typedef NodeType SeqList[MAXL];

//索引表的存储结构

typedef struct

{ KeyType key;

int link;

} IdxType;

typedef IdxType IDX[MAXL];

//顺序查找算法

int SeqSearch(SeqList R,int n,KeyType k)

{

int i=0;

pn=0;

while(i

{ process[pn++]=R[i].key;

i++;

}

if(i>=n) return -1;

else return i;

}

//折半查找算法

int BinSearch(SeqList R,int n,KeyType k)

{ int low=0,high=n-1,mid;

pn=0;

while(low<=high)

{

mid=(low+high)/2;

if(R[mid].key==k) return mid;

if(R[mid].key>k)

{

process[pn++]=R[mid].key;

high=mid-1;

} else

{ process[pn++]=R[mid].key;

low=mid+1;

}

}

return -1;

}

int main()

{

int n,i,k,m;

SeqList R;

IDX I;

printf("请输入无序顺序表的元素个数：");//10

while(scanf("%d",&n)!=EOF)

{

printf("请输入无序顺序表的%d个元素：\n",n);

//3 6 2 10 1 8 5 7 4 9

for(i=0;i

printf("请输入要查找的关键字：");scanf("%d",&k);//5

printf("使用顺序查找算法，");

if(SeqSearch(R,n,k)!=-1)

{

printf("关键字%d的下标为：%d\t查找过程为：",k,SeqSearch(R,n,k));

for(i=0;i

printf("%d\n\n",k);

}

else printf("要查找的关键字%d不在无序顺序表中\n\n",k);

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

printf("请输入有序顺序表的元素个数：");//10

scanf("%d",&n);printf("请输入有序顺序表的%d个元素：\n",n);

//1 2 3 4 5 6 7 8 9 10

for(i=0;i

printf("请输入要查找的关键字：");scanf("%d",&k);//9

printf("折半查找算法");

if(BinSearch(R,n,k)!=-1)

{

printf("关键字%d的下标为：%d\t查找过程为：",k,BinSearch(R,n,k));

for(i=0;i

printf("%d\n\n",k);

}

else printf("要查找的关键字%d不在有序顺序表中\n\n",k);

return 0;

}

}

图四

五．将无序数列使用直接插入排序算法和快速排序算法将其排成递增有序数列代码：1：直接插入：#include

#define M 100

int L[M];

void InseLt_SoLt(int n) {

int i, j;

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

if (L[i]

{

L[0] = L[i];

for(j=i-1;L[0]

L[j+1]=L[j];

L[j+1]=L[0];

}

}

int main() {

int i, n;

puts("请输入要排序的数的个数:");

scanf("%d", &n);

if(n <= 0 || n > M) {

printf("n must moLe than 0 and less than %d.\n", M);

return 0;

}

puts("请输入要排序的数:");

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

scanf("%d", &L[i]);

puts("你输入的数为:");

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

printf("%4d", L[i]);

InseLt_SoLt(n); // 直接插入排序

puts("\n排序后的数为:");

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

printf("%4d", L[i]);

return 0;

}

图五快速插入代码：#include

void quicksort(int a[], int low, int high);

int split(int a[], int low, int high);

int main(void)

{ int n;

int a[100], i;

printf("请输入待排序的数的个数: ");

scanf("%d",&n);

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

scanf("%d", &a[i]);

quicksort(a, 0, n - 1);

printf("采用快速查找排序后的结果是: ");

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

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

printf("\n");

return 0;

}

void quicksort(int a[], int low, int high)

{

int middle;

if (low >= high) return;

middle = split(a, low, high);

quicksort(a, low, middle - 1);

quicksort(a, middle + 1, high); }

int split(int a[], int low, int high)

{ int part_element = a[low];

for (;;)

{ while (low < high && part_element <= a[high]) high--;

if (low >= high) break;

a[low++] = a[high];

while (low < high && a[low] <= part_element)

low++;

if (low >= high) break;

a[high--] = a[low]; }

a[high] = part_element;

return high;

}

图六