用c語言實現順序表的查找數據元素操作

㈠ 數據結構實驗（c語言）： 順序表實驗

//線性表函數操作
#include <stdio.h>
#include <string.h>

#define MaxSize 30
#define Error 0
#define True 1

typedef char ElemType;

typedef struct
{
ElemType elem[MaxSize];

int length;
}SqList; /*順序表類型定義*/

void InitList(SqList * &L) /*初始化順序表L*/
{
L = (SqList *)malloc(sizeof(SqList));
L -> length = 0;
}

void DestroyList( SqList *L ) /*釋放順序表L*/
{
free(L);
}

int ListEmpty( SqList *L ) /*判斷順序表L是否為空表*/
{
return( L -> length == 0);
}

int ListLength( SqList *L ) /*返回順序表L的元素個數*/
{
return( L -> length);
}

void DispList( SqList *L ) /*輸出順序表L*/
{
int i;
if( ListEmpty(L))
return;
for( i = 0; i < L -> length; i++ )
printf("%c", L -> elem[i]);
printf("\n");
}

int GetElem( SqList *L, int i, ElemType &e) /*獲取順序表中的第i個元素*/
{
if( i < 1 || i > L -> elem[i])
return Error;
e = L -> elem[i - 1];
return True;
}

int LocateElem( SqList *L, ElemType e) /*在順序表中查找元素e*/
{
int i = 0;
while( i < L -> length && L -> elem[i] != e)
i++;
if(i >= L -> length)
return Error;
else
return i+1;
}

int ListInsert( SqList * &L, int i, ElemType e) /*在順序表L中第i個位置插入元素e*/
{
int j;
if( i < 1 || i > L -> length + 1)
return 0;
i--; /*將順序表位序轉化為elem下標*/
for( j = L -> length; j > i; j--) /*將elem[i]及後面元素後移一個位置*/
L -> elem[j] = L -> elem[j - 1];
L -> elem[i] = e;
L -> length++; /*順序表長度增1*/
return True;
}

int ListDelete( SqList * &L, int i, ElemType &e) /*順序表L中刪除第i個元素*/
{
int j;
if( i < 1 || i > L -> length)
return Error;
i--; /*將順序表位序轉化為elem下標*/
e = L -> elem[i];
for(j = i; j < L -> length - i; j++)
L -> elem[j] = L -> elem[j + 1];
L -> length--; /*順序表長度減1*/
return True;
}

void main()
{
SqList *L;
ElemType e;
printf("(1)初始化順序表L\n");
InitList(L);
printf("(2)依次採用尾插法插入a,b,c,d,e元素\n");
ListInsert(L, 1, 'a');
ListInsert(L, 2, 'b');
ListInsert(L, 3, 'c');
ListInsert(L, 4, 'd');
ListInsert(L, 5, 'e');
printf("(3)輸出順序表L:");
DispList(L);
printf("(4)順序表L長度 = %d\n", ListLength(L));
printf("(5)順序表L為%s\n", (ListEmpty(L) ?"空" :"非空"));
GetElem(L, 3, e);
printf("(6)順序表L的第3個元素 = %c\n", e);
printf("(7)元素a的位置 = %d\n", LocateElem(L,'a'));
printf("(8)在第4個元素位置上插入f元素\n");
ListInsert(L, 4, 'f');
printf("(9)輸出新的順序表L:");
DispList(L);
printf("(10)刪除L的第3個元素\n");
ListDelete(L, 3, e);
printf("(11)輸出新的順序表L:");
DispList(L);
printf("(12)釋放順序表L\n");
DestroyList(L);

}

㈡ 建立順序表，實現順序表的遍歷，在順序表中查找關鍵字為e的元素（c語言編寫）

樓主我大二 也剛上數據結構耶

這是我上實驗課的時候用鏈表寫的

還沒交老師看 功能還差一個 可能還bug

樓主你看看~~

/*1．編寫程序實現順序表的下列基本操作：
(1)初始化順序表La--模板已提供參考
(2)將La置為空表
(3)銷毀La
(4)在La中插入一個新的元素--模板已提供參考
(5)刪除La中的某一元素--模板已提供參考
(6)在La中查找某元素，若找到，則返回它在La中第一次出現的位置，否則返回0
(7)列印輸出La中的元素值--模板已提供參考*/

#include<iostream>
#include<cstdio>
#include<cstdlib>
usingnamespacestd;

template<typenametype>//定義元素
structlian
{
	typea;
	structlian*next;
};

template<typenametype>//定義表
classbiao
{
public:
	lian<type>*tou;//頭指針
	lian<type>*p;//尾部指針
	lian<type>*d;//隨機指針
	intn;//當前節數
	voidChuShiHua(typeM)//初始化
	{
		p=tou=(lian<type>*)malloc(sizeof(lian<type>));
		p->a=M;
		tou->next=NULL;
		n=1;
	}
	voidXiaoHui()//銷毀
	{
		inti;
		d=tou;
		for(i=1;i<=n;++i)
		{
			d=tou;
			tou=tou->next;
			free(d);
		}
		d=p=tou=NULL;
		n=0;
	}
	boolChaRu(typeM)//尾部元素插入成功返回true失敗返回false
	{
		p->next=(lian<type>*)malloc(sizeof(lian<type>));
		p->next->a=M;
		if(!p)
		{
			cout<<"插入失敗."<<endl;
			returnfalse;
		}
		++n;
		p=p->next;
		p->next=NULL;
		returntrue;
	}
	boolChaRu(typeM,intx)//隨機位置元素插入成功返回true失敗返回false
	{
		if(x>n)
		{
			cout<<"數據有誤,插入失敗."<<endl;
			returnfalse;
		}
		inti;
		lian<type>*cha=(lian<type>*)malloc(sizeof(lian<type>));
		if(!cha)
		{
			cout<<"插入失敗."<<endl;
			returnfalse;
		}
		cha->a=M;
		for(d=tou,i=1;i<x;++i)
			d=d->next;
		cha->next=d->next;
		d->next=cha;
		++n;
		returntrue;
	}
	voidShanChu(intx)//刪除元素不能刪除表頭
	{
		if(x>n||x==1)
		{
			cout<<"數據有誤,插入失敗."<<endl;
			return;
		}
		inti;
		lian<type>*del;
		for(d=tou,i=1;i<x-1;++i)
			d=d->next;
		del=d->next;
		d->next=del->next;
		free(del);
		del=NULL;
		--n;
	}
	intZhaoYuanShu(typea)//查找
	{
		inti;
		for(d=tou,i=1;i<=n;++i,d=d->next)
		{
			if(d->a==a)
				returni;
		}
		return0;
	}
	voidShuChu()//輸出
	{
		for(d=tou;d!=NULL;d=d->next)
		{
			cout<<d->a<<"";
		}
		cout<<endl;
	}
};

㈢ C語言中運用順序表中的數組如何查找指定元素，要求時間復雜度為O(1)

要求時間復雜度是O(1)，要麼是不含任何沖突的Hash演算法，要麼維護一個索引表其值包含主表的下標索引（其實這也是Hash的思維）

㈣ c語言中如何將順序表排序並實現二分法查找

voidInsertSort(sqR)

這個函數是按值傳遞參數的。換句話說，你的順序表在傳遞的時候被復制了一遍，然後這個函數收到的是一個副本，然後這個程序也許成功排序了這個副本，但是你原來的順序表並沒有改變。你可以考慮傳遞這個順序表的指針。比如這樣

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

調用的時候傳遞R的地址

InsertSort(&R);

㈤ 順序表和鏈表的基本操作，用C語言實現！

順序存儲的線性表的演算法
#include "stdio.h"
#include "stdlib.h"
#define Status int
#define OVERFLOW 0
#define TRUE 1
#define FALSE 0
#define OK 1
#define MAXSIZE 100
typedef int ElemType;
typedef struct list
{ElemType elem[MAXSIZE];
int length;
}SqList;
void InitList(SqList &L){
L.length=0;
}
/*建立順序表*/
void CreateList(SqList &L)
{
int i;
printf("input the length");
scanf("%d",&L.length);//輸入表長
for(i=1;i<=L.length;i++)
scanf("%d",&L.elem[i-1]);//輸入元素
}
//順序表的遍歷
void printdata(ElemType e){
printf("%4d",e);
}
void Traverse(SqList L,void (*visit)(ElemType e))
{ int i;
printf("The elements of the lists are:\n");
for(i=1;i<=L.length;i++){
if (i%10==0)printf("\n");//每行顯示10個元素
visit(L.elem[i-1]);//輸出表中元素
}
printf("\n");
}

//有序順序表L中插入元素e使序列仍有序
void Insert(SqList &L,ElemType e)
{int i,j;
if (L.length==MAXSIZE)exit(OVERFLOW);//表滿,不能插入
for(i=1;i<=L.length&&L.elem[i-1]<=e;i++);//向後查找
for(j=L.length;j>=i;j--)
L.elem[j]=L.elem[j-1];//元素後移
L.elem[i-1]=e;//插入e
L.length=L.length+1;//表長加1
}
//建立遞增有序的順序表
void CreateList_Sorted(SqList &L)
{int i,num;
ElemType e;
L.length=0;
printf("Create a sorted list,Input the length of the list\n");
scanf("%d",&num);
printf("Input the data %d numbers\n",num);
for(i=1;i<=num;i++){
scanf("%d",&e);
Insert(L,e);
}
}
/*Merge two sorted lists*/
void MergeList(SqList La,SqList Lb,SqList &Lc)
{int *pa,*pb,*pc;
if (La.length+Lb.length>MAXSIZE) exit(OVERFLOW);
else
{pa=La.elem;pb=Lb.elem;pc=Lc.elem;
while (pa<La.elem+La.length&&pb<Lb.elem+Lb.length)
*pc++=(*pa<=*pb)?*pa++:*pb++;/*公共部分合並*/
while (pa<La.elem+La.length) *pc++=*pa++;
/*R1表的剩餘部分放到R的後部*/
while (pb<Lb.elem+Lb.length) *pc++=*pb++;
/*R2表的剩餘部分放到R的後部*/
Lc.length=La.length+Lb.length;/*R表長*/
}
}
//判斷元素是否對稱，對稱返回TRUE 否則返回FALSE
Status Symmetric(SqList L)
{int low,high;
low=0;
high=L.length-1;
while(low<high)
if (L.elem[low]==L.elem[high]){low++;high--;}
else return(FALSE); return(TRUE); }
//順序表的主函數部分
//#include "seqlist.h"
void main()
{SqList L1,L2,L;
int select;
ElemType e;
do{printf("\n1 insert 2 merge");
printf("\n3 symmetric 0 exit \n");
printf("Please select(0--3)\n");
scanf("%d",&select);
switch(select){
case 1:
InitList(L);
CreateList_Sorted(L);
Traverse(L,printdata);
printf("\nInput the element of inserted\n");
scanf("%d",&e);
Insert(L,e);
Traverse(L,printdata);
break;
case 2:
InitList(L1);
CreateList_Sorted(L1);
Traverse(L1,printdata);
InitList(L2);
CreateList_Sorted(L2);
Traverse(L2,printdata);
InitList(L);
MergeList(L1,L2,L);
Traverse(L,printdata);
break;
case 3:
InitList(L);
CreateList(L);
Traverse(L,printdata);
if (Symmetric(L)) printf("Yes!\n"); else printf("Not\n");
break;
case 0:break;
default:printf("Error! Try again!\n");
}
}while(select);
}

/*單向鏈表的有關操作示例*/
/*類型定義及頭文件部分,文件名為sllink.h*/
#include <stdio.h>
#include <stdlib.h>
typedef int ElemType;//元素實際類型
typedef struct LNode{
ElemType data;
struct LNode *next;
}LNode,*LinkList; //定義結點、指針類型名
//頭插法建立無序鏈表
void CreateList(LinkList &L){
LinkList p;
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("頭插法建立鏈表，以0結束\n");
scanf("%d",&e);
while(e){
p=(LinkList)malloc(sizeof(LNode));
p->data=e;
p->next=L->next;
L->next=p;
scanf("%d",&e);
}
}
/*非遞減有序單向鏈表L插入元素e序列仍有序*/
void Insert_Sort(LinkList &L,ElemType e){
LinkList p,s;
s=(LinkList)malloc(sizeof(LNode));
s->data=e;
p=L;
while(p->next&&p->next->data<=e)
p=p->next;/*查找插入位置*/
s->next=p->next; /*插入語句*p結點後插入*s結點*/
p->next=s;
}
/*建立遞增有序的單向鏈表*/
void Create_Sort(LinkList &L){
ElemType e;
L=(LinkList)malloc(sizeof(LNode));
L->next=NULL;
printf("建立有序表，輸入任意個整型數據以0結束\n");
scanf("%d",&e);
while(e){
Insert_Sort(L,e);
scanf("%d",&e);
}
}
/*單向鏈表的遍歷*/
void Traverse(LinkList L){
LinkList p;
printf("遍歷鏈表");
for(p=L->next;p;p=p->next)
printf("%5d",p->data);
printf("\n");
}
/*在單向鏈表刪除元素e*/
void Delete(LinkList &L,ElemType e){
LinkList p,q;
p=L;
q=L->next;
while(q&& q->data!=e){//查找元素的刪除位置
p=q;
q=q->next;
}
if(!q) printf("\nnot deleted");/*未找到元素e*/
else {p->next=q->next;/*找到刪除*/
free(q);}
}
/*單向鏈表的逆置*/
void exch(LinkList &L){
LinkList p,s;
p=L->next;
L->next=NULL;
while(p){
s=p;
p=p->next;
s->next=L->next;
L->next=s;
}
}
/*兩個非遞減有序單向鏈表合並後仍為非遞減序列*/
void MergeIncrease(LinkList La,LinkList Lb,LinkList &Lc){
LinkList p,q,s,rear;
p=La->next;
q=Lb->next;
Lc=rear=La;
free(Lb);
while(p&&q){
if (p->data<q->data) {s=p;p=p->next; }
else {s=q;q=q->next; }
rear->next=s;/*較小元素插入表尾*/
rear=rear->next;
}
if (p) rear->next=p; else rear->next=q;
}

/*主函數部分,文件名為sllink.c*/
//#include "sllink.h"
void main(){
LinkList La,Lb,Lc;
ElemType e;
int select;
do{
printf(" 1 建立無序表，再刪除指定元素\n");
printf(" 2 建立遞增有序表，再逆置\n");
printf(" 3 建立兩個遞增有序表，將它們和並為一個仍遞增表\n");
printf(" 0 退出，請輸入選項(0-3)\n");
scanf("%d",&select);
switch(select){
case 0:
break;
case 1:
CreateList(La);
Traverse(La);
printf("輸入需刪除的元素\n");
scanf("%d",&e);
Delete(La,e);
Traverse(La);
break;
case 2:
Create_Sort(La);
Traverse(La);
exch(La);
printf("The list that is exchaged\n");
Traverse(La);
break;
case 3:
Create_Sort(La);Traverse(La);
Create_Sort(Lb);Traverse(Lb);
MergeIncrease(La,Lb,Lc);Traverse(Lc);
break;
default:
printf("輸入選項錯誤，請重新輸入！\n");
}

}while(select);
}
這些內容不知道能不能幫助到你。

㈥ c語言實現順序表

--順序表.h
#include<stdio.h>
#include<stdlib.h>
#include<malloc.h>
#define LIST_INIT_SIZE 100
#define LISTINCREMENT 10
#define TRUE 1
#define FLASE 0
typedef int Elemtype;
typedef int Status;

/*介面定義
Status InitList_Sq(SqList &L,int size,int inc);
void CreateList_Sq(SqList &L);
void print_Sq(SqList &L);
int Search_Sq(SqList L, Elemtype e);
Status DestroyList_Sq(SqList &L);
Status ClearList_Sq(SqList &L);
Status ListEmpty_Sq(SqList L);
int ListLength_Sq(SqList L);
Status GetElem_Sq(SqList L, int i, Elemtype &e);
Status PutElem_Sq(SqList &L, int i, Elemtype e);
Status Append_Sq(SqList &L, Elemtype e);
Status DeleteLast_Sq(SqList &L, Elemtype &e);
*/
--------------------
#include "順序表.h"

//定義順序表類型
typedef struct {
Elemtype *elem;
int length;
int listsize;
int increment;
}SqList;

//初始化順序表
Status InitList_Sq(SqList &L,int size,int inc) {

L.elem = (Elemtype *)malloc(size * sizeof(Elemtype));
L.length = 0;
L.listsize = size;
L.increment = inc;
return TRUE;
}

//創建順序表
Status CreateList_Sq(SqList &L) {
int i;
printf("請輸入你要創建的順序表元素個數：\n");
scanf_s("%d", &L.length);
if (L.length >= L.listsize) {
L.elem = (Elemtype *)realloc(L.elem, (L.listsize + L.increment) * sizeof(Elemtype));
}
if (!L.elem) {
return FLASE;
}
printf("請輸入你要創建的順序表：\n");
for (i = 0; i<L.length; i++) {
scanf_s("%d", &L.elem[i]);
}
}

//遍歷順序表
void print_Sq(SqList &L) {
int i;
for (i = 0; i<L.length; i++) {
printf("%4d", L.elem[i]);
}
}

//查找元素的位置
int Search_Sq(SqList L, Elemtype e) {
int i = 0;
while (L.elem[i] != e&&i<L.length) {
i++;
}
if (i>L.length)
return -1;
else
return i + 1;//因為C語言是從下標為0開始的，當i=0時表示第一個元素
}

//銷毀順序表
Status DestroyList_Sq(SqList &L) {
if (L.elem == NULL)
return -1;
else
free(L.elem);
printf("\n銷毀成功\n");
return TRUE;
}

//清空順序表
Status ClearList_Sq(SqList &L) {
if (L.elem == NULL)
exit(0);
int i;
Elemtype *p_elem = L.elem;
for (i = 0; i<L.length; i++) {
*L.elem = NULL;
L.elem++;
}
L.elem = p_elem;
}

//判斷順序表是否為空
Status ListEmpty_Sq(SqList L) {
int i;
Elemtype* p_elem = L.elem;
for (i = 0; i<L.length; i++) {
if (*L.elem != 0) {
L.elem = p_elem;
return FLASE;
}
L.elem++;
}
return TRUE;
}

//求順序表的長度
int ListLength_Sq(SqList L) {
return L.length;
}

//用e返回順序表L中第i個元素的值
Status GetElem_Sq(SqList L, int i, Elemtype &e) {
int j;
Elemtype* p_elem = L.elem;
if (i<1 || i>L.length)
return FLASE;
for (j = 1; j <= i; j++)
L.elem++;
e = *L.elem;
L.elem = p_elem;
return TRUE;
}

//將順序表L中第i個元素賦值為e
Status PutElem_Sq(SqList &L, int i, Elemtype e) {
L.elem[i - 1] = e;
return TRUE;
}

//在順序表L表尾添加元素e
Status Append_Sq(SqList &L, Elemtype e) {

L.elem[L.length] = e;
L.length++;
L.listsize += L.increment;
return TRUE;
}

//刪除順序表L表尾元素
Status DeleteLast_Sq(SqList &L, Elemtype &e) {
e = L.elem[L.length - 1];
L.length--;
return TRUE;
}

********************************************主函數.c*************************************************

#include <stdio.h>
#include <stdlib.h>
#include "順序表.h"
#include "源代碼.h"

//--------------------主函數入口--------------------

int main(){
SqList L;
int size, inc;
int e;
int a;
int length;
int i;
int temp;
int j=10;
int ee;
printf("\n--------------------順序表初始化------------------\n");
printf("請輸入順序表的長度size以及擴容量：\n");
scanf_s("%d %d", &size, &inc);
InitList_Sq(L, size, inc);
CreateList_Sq(L);

printf("\n--------------------判斷是否為空------------------\n");

if(ListEmpty_Sq(L)){
printf("該順序表為空\n");
}
else
printf("該順序表不為空\n");

printf("\n--------------------遍歷順序表--------------------\n");

printf("此時順序表為：\n");
print_Sq(L);

printf("\n--------------------查找元素----------------------\n");

printf("\n請輸入要查找的元素：\n");
scanf_s("%d",&e);
a = Search_Sq(L, e);
printf("%d為第%d位：\n",e,a);

printf("\n--------------------輸出長度----------------------\n");

length = ListLength_Sq(L);
printf("順序表的長度為%d\n",length);

printf("\n----------將順序表L中第i個元素賦值為temp----------\n");

printf("請輸入第i個元素的i值和temp值：\n");
scanf_s("%d %d",&i,&temp);
PutElem_Sq(L, i, temp);
printf("\n此時順序表為：\n");
print_Sq(L);

printf("\n---------------在順序表表尾添加元素---------------\n");

Append_Sq(L, j);
printf("\n此時順序表為：\n");
print_Sq(L);

printf("\n---------------在順序表表尾刪除元素---------------\n");

DeleteLast_Sq(L, ee);
printf("\n被刪除的元素為%d\n",ee);
printf("此時順序表為：\n");
print_Sq(L);

printf("\n-------------------清空順序表---------------------\n");

ClearList_Sq(L);
if(ListEmpty_Sq(L)){
printf("\n清空成功\n");
}

printf("\n------------------銷毀順序表----------------------\n");

DestroyList_Sq(L);
getchar();
getchar();
return 0;
}

㈦ c語言排序和查找

1）利用readData()函數從data1.txt中讀入不同規模的數據存入數組，
編寫基於數組的順序查找演算法，測試數據量為1萬、5萬、10萬、20萬、
30萬、40萬和50萬時的數據查詢時間。
演算法代碼如下：

1 int seqsearch(int a[],int n,int key)
2 {
3 int k=n-1;
4 while(k>=0&&a[k]!=key)
5 k--;
6 return (k);
7 }

2）利用readData()函數從data2.txt中讀入不同規模的有序數據存入數組，
編寫基於數組的二分查找演算法，測試數據量為1萬、5萬、10萬、20萬、30萬、
40萬和50萬時的數據查詢時間。
演算法代碼如下：

1 int binSearch(int a[],int n,int key)
2 {
3 int low=0;
4 int high=n-1;
5 int mid;
6 while(low<=high)
7 {
8 mid=(low+high)/2;
9 if(a[mid]==key) return mid;
10 if(a[mid]>key)
11 high=mid-1;
12 else
13 low=mid+1;
14 }
15 return -1;
16 }

3）請設計冒泡排序演算法函數void bubbleSort(int a[],int n)，對a[1]..a[n]進行升序排序。
並測試在不同數據規模下的排序效率。
演算法代碼如下：


1 void bubbleSort(int a[],int n)
2 {
3 int i=1,j,flag=1;
4 while(i<=n-1&&flag)
5 {
6 flag=0;
7 for(j=1;j<=n-1-i;j++)
8 if(a[j+1]<a[j])
9 {
10 a[0]=a[j];
11 a[j]=a[j+1];
12 a[j+1]=a[0];
13 flag=1;
14 }
15 i++;
16 }
17 }

㈧ C語言順序表的基本操作

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

typedefintDataType;//定義數據數據類型

typedefstruct{
	DataType*data;//data指向數據區的首個數據
	intlength;//數據長度
}SqList;

voidSort(SqList*L){
	inti,j,k;
	DataTypetmp;
	for(i=0;i<L->length-1;++i){
		k=i;
		for(j=i+1;j<L->length;++j)
			if(L->data[k]>L->data[j])
				k=j;
		if(k!=i){
			tmp=L->data[k];
			L->data[k]=L->data[i];
			L->data[i]=tmp;
		}
	}
}

SqList*CreateList(DataTypea[],intn){
	inti;
	SqList*L;
	L=(SqList*)malloc(sizeof(SqList));
	L->data=(DataType*)malloc(n*sizeof(DataType));
	L->length=n;
	for(i=0;i<n;++i)L->data[i]=a[i];
	Sort(L);
	returnL;
}

intInsertList(SqList*L,DataTypex){
	inti,j;
	for(i=0;i<L->length;i++){
		if(x<=L->data[i]){
			for(j=L->length;j>=i;j--)
				L->data[j+1]=L->data[j];//結點後移
			L->data[i]=x;
			L->length++;
			return1;
		}
	}
	L->data[L->length++]=x;
	return1;
}

intRemoveListElem(SqList*L,DataTyped){
	inti,j;
	for(i=0;i<L->length;++i){
		if(L->data[i]==d){
			for(j=i;j<L->length-1;++j)
				L->data[j]=L->data[j+1];
			L->length--;
			return1;
		}
	}
	return0;
}

SqList*AndList(SqList*A,SqList*B){/*A∩B*/
	inti,j,k=0;
	intlen=(A->length>B->length)?B->length:A->length;
	SqList*C=(SqList*)malloc(sizeof(SqList));
	C->length=len;
	C->data=(DataType*)malloc(len*sizeof(DataType));
	for(i=0;i<A->length;++i){
		for(j=0;j<B->length;++j){
			if(A->data[i]==B->data[j]){
				C->data[k++]=A->data[i];
				break;
			}
		}
	}
	C->length=k;
	returnC;
}

SqList*OrList(SqList*A,SqList*B){/*A∪B*/
	inti,j,flag;
	DataTypee;
	SqList*C=(SqList*)malloc(sizeof(SqList));
	C->length=A->length+B->length;
	C->data=(DataType*)malloc(C->length*sizeof(DataType));
	for(i=0;i<A->length;++i)C->data[i]=A->data[i];
	for(i=0;i<B->length;++i){
		e=B->data[i];
		flag=1;
		for(j=0;j<C->length;++j){
			if(e==C->data[j]){
				flag=0;
				break;
			}
		}
		if(flag)InsertList(C,e);
	}
	returnC;
}

voidPrintList(SqList*L){
	inti;
	for(i=0;i<L->length;++i)
		printf("%d",L->data[i]);
	printf("
");
}

voidFreeList(SqList*L){
	free(L->data);
	free(L);
}

voidmain(){
	DataTypex;
	DataTypearra[]={36,24,31,5,90,65,70,39,37};
	DataTypearrb[]={9,8,43,51,37,89,33,46,29,80,56};
	intalen=sizeof(arra)/sizeof(arra[0]);
	intblen=sizeof(arrb)/sizeof(arrb[0]);
	SqList*A=CreateList(arra,alen);
	printf("A線性表為:");
	PrintList(A);
	SqList*B=CreateList(arrb,blen);
	printf("B線性表為:");
	PrintList(B);
	SqList*C=AndList(A,B);
	SqList*D=OrList(A,B);
	printf("C=A∩B:");
	PrintList(C);
	printf("D=A∪B:");
	PrintList(D);

	printf("在D表中插入數據:");
	scanf("%d",&x);
	InsertList(D,x);
	printf("D表插入x後:");
	PrintList(D);
	
	printf("刪除D表中數據:");
	scanf("%d",&x);
	RemoveListElem(D,x);
	printf("刪除x後的D表為:");
	PrintList(D);
	FreeList(A);
	FreeList(B);
	FreeList(C);
	FreeList(D);
}

㈨ 數據結構 c語言版 ——順序表的查找、插入與刪除

#include<stdio.h>
#include<stdlib.h>
#define N 10 //順序表的最大容量
int length=0; //順序表的當前元素個數

#define TRUE 1
#define FALSE 0
#define OK 1
#define ERROR 0
#define INFEASIBLE -1
#define OVERFLOW -2
#define LIST_INIT_SIZE 100//線性表存儲的空間初始化分配量
#define LISTINCREAMENT 10 //線性表存儲空間的分配增量

typedef struct LNode//線性單鏈表存儲結構
{
int data;
struct LNode *next;
}LNode,*LinkList;

int CreatList_L(LinkList&L)//創建一個線性鏈表
{
L=(LinkList)malloc(sizeof(LNode));//分配一個空間給鏈表，作為頭結點

if(!L) exit(OVERFLOW);
L->next=NULL;
return OK;
}
int DestroyList_L(LinkList &L)//銷毀鏈表
{
if(L) free(L);
return OK;
}
int ListInsert_L(LinkList&L,int i,int e)//再練表的第i個元素前插入一個元素e
{
LinkList p=L;//p指針定位於i-1
LNode *s;
int j=0;
while(p&&j<i-1) {p=p->next;j++;}//定位
if(!p||j>i-1) return ERROR;//如果i<1或大於鏈表元素個數+1
s=(LNode*)malloc(sizeof(LNode));
if(!s) exit(OVERFLOW);
s->data=e; //完成插入操作
s->next=p->next;
p->next=s;
return OK;
}

int ListDelet_L(LinkList&L,int i,int&e)//刪除鏈表L中的第i個元素，並返回給e;
{
LinkList p=L;
LNode* q;
int j=0;
while(!p&&j<i-1) {p=p->next;j++;}//p指針定位於i-1；
if(!p->next||j>i-1) return ERROR;

e=p->next->data; //完成刪除操作
q=p->next;
p->next=p->next->next;
free(q);
return OK;

}

int ListTraverse_L(LinkList L,int n)//鏈表的遍歷
{
int i=0;
if(!L)return ERROR;
L=L->next;
while(L)
{
if(L->data==n)return i;
L=L->next;
i++;
}

return FALSE;
}

int InverseSingleList_L(LinkList &L)
{
if(!L->next||!L->next->next)//如果鏈表少於2個Node那麼鏈表不需要改變順序
return OK;
LNode *p,*q;
p=L->next; //第一次因為p是最後一個連接所以把p->next設為空
q=p->next;
p->next=NULL;
p=q;
while(p)
{
q=p->next; //用q去保留p後面一個Node;
p->next=L->next;
L->next=p;
p=q;
}
return OK;
}

int main()
{
int List[N];
LinkList L;

int ch,exit='N';
do
{
system("CLS");
printf("\t\t********************************************\n");
printf("\t\t* 1.創建一個順序表 .........(1) *\n");
printf("\t\t* 2.在順序表中查找元表.........(2) *\n");
printf("\t\t* 3.在順序表中插入元表.........(3) *\n");
printf("\t\t* 4.在順序表中刪除元表.........(4) *\n");
printf("\t\t* 5.退出 .........(5) *\n");
printf("\t\t********************************************\n");
printf("\n請選擇操作代碼：");
ch=getchar();

switch(ch)
{
case '1':
printf("\n請輸入十個元素");
CreatList_L(L);
for(length=0;length<N;length++)
{
scanf("%d",&List[length]);
getchar();
ListInsert_L(L,length+1,List[length]);
}
printf("\n創建成功！");
getchar();
break;
case '2':
scanf("%d",&List[0]);
if(ListTraverse_L(L,List[0]))printf("該元素存在該年表的第%d個位置",ListTraverse_L(L,List[0]));
else printf("不存在該元素");
getchar();
break;
case '3':
scanf("%d%d",&length,&List[0]);
ListInsert_L(L,length,List[0]);
system("pause");
break;
case '4':
scanf("%d",&length);
ListDelet_L(L,length,List[0]);
system("pause");
break;
case '5':
printf("\n您是否真的要退出程序(Y/N):");
getchar();
exit=getchar();
break;
default:
getchar();
printf("\n無效輸入，請重新選擇...:");
getchar();
break;

}

}while(exit!='y'&&exit!='Y');

}

㈩ 用c語言實現建立順序表 並查找最小的元素

//給你個完整的
#include <malloc.h>
#include<stdlib.h>
#include <stdio.h>
typedef struct Lnode
{int data;
struct Lnode *next;
}*Linklist,Lnode;
void CreatList(Lnode *L) /*建立鏈表函數*/
{ Lnode *p;
int value;
L->next=NULL;
while (1) /*當輸入非0數值時*/
{scanf( "%d",&value);
if (value==NULL)
return;
p=(Lnode *)malloc(sizeof(Lnode)); /*建立P鏈表*/
p->data=value;
p->next=L->next; /*把後輸入的插到前面*/
L->next=p;
}
}
void paixu(Lnode *L)
{
Linklist r,q,small;int temp;
for(r=L->next;r->next!=NULL;r=r->next)
{small=r;
for(q=r->next;q;q=q->next) /*找到鏈表中最小元素*/
if(q->data<small->data)
small=q;
if(small!=r)
{temp=r->data;
r->data=small->data; /*把最小的數值換到P指針所指的位置數值上（原P指針的next指向不變）*/
small->data=temp; /*把原先p指針所指位置的數值填入被置換出的最小元素位置*/
}
}
printf("正在對新鏈表進行排序……\n");
}
void PrintList(Lnode *L) /*列印鏈表函數*/
{
Lnode *p=L->next; /*帶頭節點，把指針置於第一個數*/
if(p==0)
{printf("鏈表為空");}
else
printf("鏈表為：");
{while(p)
{
printf("%d>>", p->data);
p=p->next;
}
}
printf("\n");
}
inter(Lnode *L,int i)
{
Lnode *k=L->next;
while(k)
{if (k->data==i)
return 1;
k=k->next;
}
return 0;
}
int ListInsert_L(Lnode *L, int i, int e)
{
Lnode *p=L->next;
Lnode *s;
int j=0;
while (p && j<i-1) {p=p->next; ++j;}
if (!p || j>i-1) return 0;
s=(Lnode *)malloc(sizeof(Lnode));
s->data=e;
s->next=p->next;
p->next=s;
return 1;
}
int ListDelete_L(Lnode *L,int i)
{
Lnode *p=L->next;
int j=0;
Lnode *q;
while (p->next && j<i-1) {p=p->next; ++j;} /*找出第i節點，並令p指向其前趨*/
if (!p->next || j>i-1) return 0;
q=p->next;
p->next=q->next;
free(q);
return 1;
}
main()
{
int sign,sign1,signa,signb,signc,i,x,ca,cb,cc;
int choice=1;
Lnode *A,*B,*C,*D,*E,*L,*p,*q,*n,*m;
A=(Lnode *)malloc(sizeof(Lnode));
B=(Lnode *)malloc(sizeof(Lnode));
C=(Lnode *)malloc(sizeof(Lnode));
D=(Lnode *)malloc(sizeof(Lnode));
E=(Lnode *)malloc(sizeof(Lnode));
printf("\t 《瀟的數據結構課程設計——單鏈表的級別操作》\n\n");
while (choice)
{
printf("\t 請選擇您想進行的操作（按任意鍵退出程序）:\n 1:對A鏈表操作 \n 2:對B鏈表操作 \n 3:兩鏈表運算 \n \n 您的選擇是：");
scanf("%d",&sign1);
if (sign1==1)
{L=A;
ca=1;
while (ca)
{printf("\t 請選擇對A鏈表進行的操作:\n 1:建立鏈表 \n 2:對鏈表排序 \n 3:在鏈表中插入元素 \n 4:在鏈表中刪除元素 \n 5:返回上一級菜單 \n 您的選擇是：");
scanf("%d",&signa);
switch(signa)
{
case 1:
printf("\n請輸入鏈表元素(輸入0結束)\n");
CreatList(A);
PrintList(A);
break;
case 2:
printf("對A鏈表進行排序，結果為：\n ");
paixu(A);
PrintList(A);
break;
case 3:
printf("請輸入想要插入的位置及插入的數值（以逗號分隔）: ");
scanf("%d,%d",&i,&x);
if (ListInsert_L(L,i,x)==1)
{printf("修改成功!目前A鏈表為：\n");
PrintList(L);}
else
printf("警告!您輸入的插入位置超過鏈表長度。 \n");
break;
case 4:
printf("請輸入想要刪除的元素位置: ");
scanf("%d",&i);
if (ListDelete_L(L,i)==1)
{printf("刪除元素成功!目前A鏈表為：\n");
PrintList(L);}
else
printf("警告!您輸入的刪除位置超過鏈表長度。 \n");
break;
case 5:
ca=0;
break;
default:
printf("警告!只能選擇1-5。 \n");
break;
}
}
}
else if (sign1==2)
{L=B;
cb=1;
while (cb)
{printf("\t 請選擇對B鏈表進行的操作:\n 1:建立鏈表 \n 2:對鏈表排序 \n 3:在鏈表中插入元素 \n 4:在鏈表中刪除元素 \n 5:返回上一級菜單 \n 您的選擇是：");
scanf("%d",&signb);
switch(signb)
{
case 1:
printf("\n請輸入鏈表元素(輸入0結束)\n");
CreatList(B);
PrintList(B);
break;
case 2:
printf("對B鏈表進行排序，結果為：\n ");
paixu(B);
PrintList(B);
break;
case 3:
printf("請輸入想要插入的位置及插入的數值（以逗號分隔）: ");
scanf("%d,%d",&i,&x);
if (ListInsert_L(L,i,x)==1)
{printf("修改成功!目前B鏈表為：\n");
PrintList(L);}
else
printf("警告!您輸入的插入位置超過鏈表長度。 \n");
break;
case 4:
printf("請輸入想要刪除的元素位置: ");
scanf("%d",&i);
if (ListDelete_L(L,i)==1)
{printf("刪除元素成功!目前B鏈表為：\n");
PrintList(L);}
else
printf("警告!您輸入的刪除位置超過鏈表長度。 \n");
break;
case 5:
cb=0;
break;
default:
printf("警告!只能選擇1-5。 \n");
break;
}
}
}

else if (sign1==3)
{cc=1;
while (cc)
{printf("\t 請選擇操作的名稱:\n 1:顯示當前的A、B鏈表 \n 2:進行差運算 \n 3:進行交運算 \n 4:進行並運算 \n 5:返回上一級菜單 \n 您的選擇是：");
scanf("%d",&signc);
switch(signc)
{
case 1:
printf(" \n 當前A");
PrintList(A);
printf(" \n 當前B");
PrintList(B);
break;
case 2:
p=B->next;
while(p)
{if (!inter(A,p->data))
{m=(Lnode *)malloc(sizeof(Lnode));
m->data=p->data;
m->next=C->next;
C->next=m;
}
p=p->next;
}
printf(" \n 進行差運算，結果為：\n");
PrintList(C);
C=(Lnode *)malloc(sizeof(Lnode)); /*必須再分配一次地址空間以用來把原鏈表清空，否則每次運行都會使鏈表元素增加*/
break;
case 3:
p=B->next;
while(p)
{if (inter(A,p->data))
{q=(Lnode *)malloc(sizeof(Lnode));
q->data=p->data;
q->next=D->next;
D->next=q;
}
p=p->next;
}
printf(" \n 進行交運算，結果為：\n");
PrintList(D);
D=(Lnode *)malloc(sizeof(Lnode));
break;
case 4:
*E=*A;
p=B->next;
while(p)
{if (!inter(E,p->data))
{n=(Lnode *)malloc(sizeof(Lnode));
n->data=p->data;
n->next=E->next;
E->next=n;
}
p=p->next;
}
printf(" \n 進行並運算，結果為：\n");
PrintList(E);
E=(Lnode *)malloc(sizeof(Lnode));
break;
case 5:
cc=0;
break;
default:
printf("警告!只能選擇1-5。 \n");
break;
}
}
}
else
{
printf("謝謝使用，請按任意鍵退出!\n");
break;
}
}

return 0;
}