表排序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);
}