表排序c语言

① 顺序表的排序，二分法查找的c语言程序

#include<stdio.h>
int fun(int a[],int n,int key)
{i
nt low,mid,high;//low、mid、high是三个索引分别指向数组的下标low=0;//low指向数组a[]的第一个元素，即下表为0的元素
high=n-1;//lhigh指向数组a[]的最一个元素，即下表为n-1的元素，n为数组的长度
while(low<=high)//循环终止条件是low>high的时候
{
mid=(low+high)/2;//所谓二分查找就在这里，每次都让mid指向数组下标等于low和high之和的一半的元素i
f(key<a[mid])//如果a【mid】大于要查找的元素，说明要查找的元素在low和mid之间，这是需要把high重新置为mid-1
(high=mid-1);//这里应该是{}，不能使（）吧
else if(key>a[mid])//这里同理，如果a【mid】小于要查找的元素，说明要查找的元素在mid和high之间，这是需要把low重新置为mid+1
(low=mid+1);
else
return mid;//剩下的就是相等的情况，直接返回mid就是查找到的结果
}
return -1;//执行到这一步就说明，low>high，没有找到要查找的元素，返回-1表示没有结果
}
main()
{
int a[10]={1,2,3,4,5,6,7,8,9,10};
int a,b,c;
b=4;
c=fun(a,10,b);
if(c==1)
printf("not found");
else
printf("psition %d\n",c);
}

② C语言排序有哪些方法 详细点

排序方法吗应该和语言没有太紧密的关系，关键看数据类型和结构，一般常用的排序方法有：
1 插入排序——细分的话还可有（1）直接插入排序（2）折半插入排序（3）希尔排序（4）2-路插入排序（5）表插入排序 等
2 比较排序——如冒泡排序，快速排序 等
3 选择排序——如简单选择排序，树形选择排序，堆排序 等
4 归并排序——简单的如 2-路归并排序 等
5 基数排序
等等
一般情况下，如果数据不大，只是简单的自己练习或简单的几个十几个或几十个数据的话，效率分不出多少来，常用冒泡，直接插入，简单选择这几种简单的时间复杂度为O（n2）的排序方法就可以。这里举一个简单的小例子——比较排序中的——冒泡排序 如下：

//其中a[]是用于排序的数组变量的首地址，也即数组名,a[0]不放数据，
//用于交换时的辅助存储空间，数据从a[1]开始存放，n表示存放的数据个数
void bubble_sort(int a[], int n){
int i = 0, j = 0, change = 0;//change用于记录当前次比较是否进行了交换
for(i = n - 1, change = 1; i >= 1 && change; i--){//如果change是0，即已经排好序不用再进行比较了
change = 0;//将当前次的change赋值为0，记录不交换即下次不用比较了
for(j = 1; j <= i; j++){//内循环依次将相邻的两个记录进行比较
if(a[j] > a[j+1]){//小的前移，最大的移动到本次的最后一项去
a[0] = a[j+1];
a[j+1] = a[j];
a[j] = a[0];
change = 1;//进行了交换的标记
}
}
}
}

③ C语言链表排序

＃include＂stdafx．h＂

＃include＜stdlib．h＞

／／创建一个节点，data为value，指向NULL

Node＊Create（intvalue）｛

Node＊head＝（Node＊）malloc（sizeof（Node））；

head－＞data＝value；

head－＞next＝NULL；

returnhead；

｝

／／销毁链表

boolDestroy＿List（Node＊head）｛

Node＊temp；

while（head）｛

temp＝head－＞next；

free（head）；

head＝temp；

｝

head＝NULL；

returntrue；

｝

／／表后添加一个节点，Create（value）

boolAppend（Node＊head，intvalue）｛

Node＊n＝Create（value）；

Node＊temp＝head；

while（temp－＞next）｛

temp＝temp－＞next；

｝

temp－＞next＝n；

return0；

｝

／／打印链表

voidPrint＿List（Node＊head）｛

Node＊temp＝head－＞next；

while（temp）｛

printf（＂％d－＞＂，temp－＞data）；

temp＝temp－＞next；

｝

printf（＂＼n＂）；

｝

／／在链表的第locate个节点后（头节点为0）插入创建的节点Create（value）

boolInsert＿List（Node＊head，intlocate，intvalue）｛

Node＊temp＝head；

Node＊p；

Node＊n＝Create（value）；

if（locate＜0）

returnfalse；

while（locate－－）｛

if（temp－＞next＝＝NULL）｛

temp－＞next＝Create（value）；

returntrue；

｝

temp＝temp－＞next；

｝

p＝temp－＞next；

temp－＞next＝n；

n－＞next＝p；

returntrue；

｝

／／删除第locate个节点后（头节点为0）的节点

boolDelete＿List（Node＊head，intlocate）｛

Node＊temp＝head；

Node＊p；

if（locate＜0）

returnfalse；

while（locate－－）｛

if（temp＝＝NULL）｛

returnfalse；

｝

temp＝temp－＞next；

｝

p＝temp－＞next－＞next；

free（temp－＞next）；

temp－＞next＝NULL；

temp－＞next＝p；

returntrue；

｝

／／获取链表长度（不包括头节点）

intSize＿List（Node＊head）｛

Node＊temp＝head；

intsize＝0；

while（temp－＞next）｛

temp＝temp－＞next；

size＋＋；

｝

returnsize；

｝

／／链表的三种排序（选择，插入，冒泡）

boolSort＿List（Node＊head）｛

intt＝0；

intsize＝Size＿List（head）；

／／选择排序

／＊for（Node＊temp＝head－＞next；temp！＝NULL；temp＝temp－＞next）｛

for（Node＊p＝temp；p！＝NULL；p＝p－＞next）｛

if（temp－＞data＞p－＞data）｛

printf（＂换％d和％d＼n＂，temp－＞data，p－＞data）；

t＝temp－＞data；

temp－＞data＝p－＞data；

p－＞data＝t；

｝

｝

｝＊／

／／插入排序

／＊for（Node＊temp＝head－＞next－＞next；temp！＝NULL；temp＝temp－＞next）｛

for（Node＊p＝head；p－＞next！＝NULL；p＝p－＞next）｛

if（p－＞next－＞data＞temp－＞data）

｛

printf（＂换％d和％d＼n＂，temp－＞data，p－＞next－＞data）；

t＝temp－＞data；

temp－＞data＝p－＞next－＞data；

p－＞next－＞data＝t；

｝

｝

｝＊／

／／冒泡排序

for（Node＊temp＝head－＞next；temp－＞next！＝NULL；temp＝temp－＞next）｛

for（Node＊p＝head－＞next；p－＞next！＝NULL；p＝p－＞next）｛

if（p－＞data＞p－＞next－＞data）｛

t＝p－＞data；

p－＞data＝p－＞next－＞data；

p－＞next－＞data＝t；

｝

｝

｝

return0；

｝

(3)表排序c语言扩展阅读：

return表示把程序流程从被调函数转向主调函数并把表达式的值带回主调函数，实现函数值的返回，返回时可附带一个返回值，由return后面的参数指定。

return通常是必要的，因为函数调用的时候计算结果通常是通过返回值带出的。如果函数执行不需要返回计算结果，也经常需要返回一个状态码来表示函数执行的顺利与否（-1和0就是最常用的状态码），主调函数可以通过返回值判断被调函数的执行情况。

④ C语言动态列表排序

链表吗？以前练习的时候做过一个，你参考下

#include<stdio.h>

#include<stdlib.h>

#include<iostream.h>

#define OK 1;

#define ERROR 0;

typedef int ElemType;

typedef int Status;

typedef struct LNode{

ElemType data;

struct LNode *next;

}LNode,*LinkList;

void CreateList(LinkList &L,int n) //创建表

{

int i;

LNode *p;

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

L->next=NULL;

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

{

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

printf("输入第%d个元素的值 ",i);

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

p->next=L->next;

L->next=p;

}

printf("创建成功! ");

}

Status GetElem(LinkList &L,int i) //得到第i个元素

{

ElemType j=1,e;

LNode *p;

p=L->next;

while(j<i&&p)

{

p=p->next;

j++;

}

if(!p||j>i)

{

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

return ERROR;

}

e=p->data;

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

return OK;

}

Status ListInsert(LinkList &L,int i,ElemType e) //插入元素

{

ElemType j;

LNode *p,*s;

p=L;

j=1;

while(p&&j<i)

{

p=p->next;

++j;

}

if(!p||j>i)

{

printf("不能在第%d中插入 ",i);

}

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

s->data=e;

s->next=p->next;

p->next=s;

return OK;

}

Status ListDelete(LinkList &L,int i) //删除元素

{

LNode *p,*q;

p=L;

int j=0;

while(p->next&&j<i-1)

{

p=p->next;

j++;

}

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

{

printf("查找失败! ");

return ERROR;

}

q=p->next;

p->next=q->next;

free(q);

printf("删除成功! ");

return OK;

}

void MergeList(LinkList &La,LinkList &Lb,LinkList &Lc) //归并

{

LNode *pa,*pb,*pc;

Lc=pc=La;

pa=La->next;

pb=Lb->next;

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;

printf("归并成功! ");

}

void PList(LinkList &L) //打印

{

LNode *p;

p=L->next;

while(p)

{

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

p=p->next;

}

printf(" ");

}

Status CList(LinkList &L) //排序

{

LNode *p;

int flag,e;

p=L;

while(1)

{

flag=0;

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

{

if(p->next->data>p->next->next->data)

{

e=p->next->data;

p->next->data=p->next->next->data;

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

flag=1;

}

}

if(flag==0)

{

printf("排序成功! ");

return OK;

}

}

}

int main()

{

int count=1,m,n,k,sum,i,j,g;

LinkList list[10];

printf("输入创建表的个数 ");

scanf("%d",&m);

for(;count<=m;count++)

{

printf("输入第%d个表的元素个数 ",count);

scanf("%d",&n);

printf("逆序输入n个元素 ");

CreateList(list[count],n);

printf("第%d个表创建成功 ",count);

}

sum=m+1;

while(1)

{

printf("功能: 1.查找某位置元素的值 2.插入元素 3.删除元素 4.元素排序 5.两表合并 6.显示表内元素 7.退出 ");

scanf("%d",&k);

switch(k)

{

case 1:

printf("输入查找的表 ");

scanf("%d",&i);

if(i>m)

{

printf("不存在表%d ",i);

break;

}

printf("输入查找位置 ");

scanf("%d",&j);

GetElem(list[i],j);

break;

case 2:

printf("输入要插入的表 ");

scanf("%d",&i);

if(i>m)

{

printf("不存在表%d ",i);

break;

}

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

scanf("%d",&j);

printf("输入要插入的值 ");

scanf("%d",&g);

ListInsert(list[i],j,g);

break;

case 3:

printf("输入要删除的表 ");

scanf("%d",&i);

if(i>m)

{

printf("不存在表%d ",i);

break;

}

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

scanf("%d",&j);

ListDelete(list[i],j);

break;

case 4:

printf("输入要排序的表 ");

scanf("%d",&i);

if(i>m)

{

printf("不存在表%d ",i);

break;

}

CList(list[i]);

break;

case 5:

printf("输入表1 ");

scanf("%d",&i);

if(i>m)

{

printf("不存在表%d ",i);

break;

}

printf("输入表2 ");

scanf("%d",&j);

if(i>m)

{

printf("不存在表%d ",j);

break;

}

MergeList(list[i],list[j],list[sum]);

printf("已经将合并的标放入第%d个表中",sum);

sum++;

m++;

break;

case 6:

printf("输入要显示的表 ");

scanf("%d",&i);

if(i>m)

{

printf("不存在表%d ",i);

break;

}

PList(list[i]);

break;

case 7:

return 0;

default:

printf("错误的指令!/n");

break;

}

}

}

⑤ C语言 链表如何进行排序！

//排序( 参数为链表头 )
void Sorting( student* pHead )
{
//参数判断(如果是空就返回)
if ( pHead == NULL )
{
return;
}

//临时变量..做冒泡循环用..
student* pTempA = pHead;
student* pTempB = pHead;
//这两个while相当于冒泡的嵌套for循环
while( pTempA != NULL )
{
while ( pTempB != NULL )
{
//判断结构体里面int类型(学号)大小
if ( pTempA->iNum < pTempB->iNum )
{
//将结构体里int类型(学号)值进行交换
int Num = pTempA->iNum;
pTempA->iNum = pTempB->iNum;
pTempB->iNum = Num;

//将char类型(名字)做交换
char Name[ 16 ];
strcpy ( Name, pTempA->strName );
strcpy ( pTempA->strName, pTempB->strName );
strcpy ( pTempB->strName, Name );

//因为指针变量不做交换...所以不做结构体的直接交换
//除了指向下一个结点的指针变量外所有的值进行交换
}
//做链表遍历(相当于循环的i++)
pTempB = pTempB->pNext;
}
//因为for每次进来i = 0; 这里while循环结束..要让pTempB重新回到头..
pTempB = pHead;
//做链表遍历(相当于循环的i++)
pTempA = pTempA->pNext;
}
}

连接晚上回来给你写...

⑥ 关于C语言链表排序的问题

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

structnumber//链表节点
{
	intnum;
	structnumber*next;
};

intn;

structnumber*creat()//创建链表
{
	structnumber*head;//头节点
	structnumber*p1,*p2;
	n=0;
	p1=p2=(structnumber*)malloc(sizeof(structnumber));
	scanf("%d",&p1->num);
	head=NULL;
	while(p1->num!=0)//循环输入链表数据，当输入为0时结束，链表数据不包括0
	{
		n=n+1;
		if(n==1)
			head=p1;
		else
			p2->next=p1;
		p2=p1;
		p1=(structnumber*)malloc(sizeof(structnumber));
		scanf("%d",&p1->num);
	}
	p2->next=NULL;
	return(head);
}

voidprint(structnumber*head)//链表从小到大排序，并输出
{
	structnumber*p1,*p2,*p;
	inti,j,t;
	printf("这%d个数从小到大的排序为：
",n);
	if(head!=NULL)
	{
		//冒泡排序
		for(j=0;j<n-1;j++)
		{
			p1=head;p2=head;
			for(i=0;i<n-1-j;i++)
			{
				p2=p1->next;
				if(p1->num>=p2->num)
				{
					t=p1->num;
					p1->num=p2->num;
					p2->num=t;
				}
				p1=p1->next;
			}
		}
	}		
	p=head;
	if(head!=NULL)
	{
		//输出链表值
		do
		{
			printf("%3d",p->num);
			p=p->next;
		}while(p!=NULL);
	}
}

voidmain()
{
	structnumber*head;
	head=creat();
	print(head);
}

⑦ c语言中如何将顺序表排序并实现二分法查找

voidInsertSort(sqR)

这个函数是按值传递参数的。换句话说，你的顺序表在传递的时候被复制了一遍，然后这个函数收到的是一个副本，然后这个程序也许成功排序了这个副本，但是你原来的顺序表并没有改变。你可以考虑传递这个顺序表的指针。比如这样

voidInsertSort(sq*pR)
{
sqR=*pR;
//以下不变
...
}

调用的时候传递R的地址

InsertSort(&R);

⑧ C语言做链表的排序

主要修改了sort函数，采用冒泡排序算法进行排序的。
你其他的两个函数写的不错，就sort函数写的有问题，已经很不错了。
注意：程序结束，最好对链表进行销毁，否则，内存永远也不会释放，导致内存泄漏了。

修改如下：

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

#define N 5
typedef struct node
{
char name[20];
int score;
struct node *link;
}stud;

stud *sort(stud *head) /*排序函数*/
{
stud *temp=NULL; //默认为NULL,也就是链表的结尾
stud *ptr1=head;
stud *ptr2=head->link;

while(ptr1->link!=temp)//(ptr1!=NULL)
{
//ptr2=ptr1->link; //放在循环体下面了
while(ptr2->link!=temp)//(ptr2!=NULL)
{
if(ptr1->link->score > ptr2->link->score) //(ptr1->score > ptr2->score)
{//交换 ptr1->link和ptr2->link，而不是ptr1和ptr2，否则无法交换
ptr1->link=ptr2->link;
ptr2->link=ptr2->link->link;//temp->link=ptr2;
ptr1->link->link=ptr2;//ptr2->link=ptr1;
}
ptr1=ptr1->link;//ptr2=ptr2->link;
ptr2=ptr1->link;//从上面移动下来的
}
temp=ptr2;//新加的
ptr1=head;//ptr1=ptr1->link;
ptr2=ptr1->link;//从上面移动下来的
}
return (head);
}

stud * creat(int n)
{
stud *p,*h,*s;
int i;

if((h=(stud *)malloc(sizeof(stud)))==NULL)
{
printf("不能分配内存空间!");
exit(0);
}
h->name[0]='\0';
h->link=NULL;
p=h;
for(i=0;i<n;i++)
{
if((s= (stud *) malloc(sizeof(stud)))==NULL)
{
printf("不能分配内存空间!");
exit(0);
}
s->link=NULL;//p->link=s; //跟下句对调了一下，为了把相关的代码放在一起
printf("请输入第%d个人的姓名",i+1);
scanf("%s",s->name);
printf("请输入第%d个人的分数",i+1);
scanf("%d",&s->score);
p->link=s; //s->link=NULL;//跟上句对调了一下，为了把相关的代码放在一起
p=s;
}
return(h);
}

void print(stud *h)
{
stud *p;

p=h->link;
printf("数据信息为：\n");
while(p!=NULL)
{
printf("%s ",&*(p->name));
printf("的分数为%d\n",p->score);
p=p->link;
}
}

void main()
{
stud *head;
head=creat(N);
head=sort(head);
print(head);
getchar();
}

⑨ c语言 顺序表 排序

///是不是要这样，
#include
<stdio.h>
#define
MAXSIZE
10
//
待排顺序表最大长度
typedef
int
KeyType;
//
关键字类型为整数类型
typedef
struct
sqlist
{
KeyType
r[MAXSIZE+1];
//
r[0]闲置
int
length;
//
顺序表长度
}SqList;
//建立顺序表//
SqList
InputSList()
{int
x;SqList
L;
L.length=0;
printf("\n请输入数据，结束输入-1!\n");
scanf("%d",&x);
while(x!=-1)
{
L.r[++L.length]=x;
if(L.length==MAXSIZE)
{
printf("\n顺序表已满!\n");
break;
}
scanf("%d",&x);
}
return
L;
}
//直接插入排序//
void
InsertionSort
(SqList
*L
)
{
//
对顺序表
L
作直接插入排序。
int
i,j;
SqList
*p=L;
for
(
i=2;
i<=p->length;
++i
)
if
(p->r[i]
<
p->r[i-1])
{
p->r[0]
=
p->r[i];
p->r[i]=p->r[i-1];
for
(
j=i-2;
p->r[0]
<
p->r[j];
--
j
)
p->r[j+1]
=
p->r[j];
//
记录后移
p->r[j+1]
=
p->r[0];
//
插入到正确位置
}
}
//冒泡排序//
void
BubbleSort(SqList
*L)
{
int
i,j,t;
SqList
*p=L;
for
(i=p->length;i>1;--i){
for
(j=1;j<i;++j)
if
(p->r[j+1]<p->r[j]){
t=p->r[j+1];
p->r[j+1]=p->r[j];
p->r[j]=t;
}
}
}
//简单选择排序//
void
SelectSort
(SqList
*L
)
{
SqList
*p=L;
int
i,
j,
k;
KeyType
temp;
for
(i=1;
i<p->length;
++i)
{
k=i;
for
(j=i+1;
j<=p->length;
j++)
if
(p->r[j]<p->r
[k])
k=j;
if
(k!=i)
{temp=p->r
[i];
p->r
[i]=p->r
[k];
p->r
[k]=temp;
}
}
}
void
display(SqList
*L)
{
SqList
*p;
p=L;
if
(p->length!=0)
{
while(p->length)
{
printf("%d
",p->r[p->length]);
p->length--;
}
}
printf("\n");
}
void
main()
{
SqList
L;
L=InputSList();
InsertionSort
(&L);
//
SelectSort
(&L)
;
//
BubbleSort(&L);
display(&L);
}