사전 순서 테이블 구현

#' stdio.h' 포함

# "stdlib.h" 포함

# 상태 정의 int

# 오버플로우 0 정의

# 참 정의 1

# false 0 정의

# ok/kloc 정의-0/

# maxsize/kloc 정의-0/00

Typedef int ElemType

Typedef 구조 목록

{elem type elem [maxsize];

Int 길이;

} SqList

Voidinit 목록 (sqlist & L){

L. 길이 = 0;

}

/* 시퀀스 테이블 생성 */

Void createlist (sqlist & L)

{

Int I；;

Printf ("입력 길이");

Scanf("%d ",& 길이); //테이블 길이 입력

For (I =1; 나< = L. 길이; I++)

Scanf("%d ",& ampl.elem [I-1]); //입력 요소

}

//순서 테이블 순회

Void printdata(ElemType e){

Printf("%4d ",e);

}

Void Traverse(SQL list L, void(* visit)(element type e))

{int I；;

Printf ("목록의 요소는 다음과 같습니다. \ n");

For (I =1; 나< = L. 길이; I++){

If (I%10 = = 0) printf ("\ n"); //행당 10 개 요소를 표시합니다.

방문 (l.elem [I-1]); //출력 테이블의 요소

}

Printf ("\ n");

}

//요소 e 를 정렬된 시퀀스 테이블 l 에 삽입하여 시퀀스를 정렬된 상태로 유지합니다.

빈 삽입 (SqList & ampl, ElemType e)

{int I, j;

If (L.length==MAXSIZE)exit (넘침); //테이블이 꽉 차서 삽입할 수 없습니다.

For (I =1; 나<= 길이와 길이. & ampl.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 create list _ sorted (sqlist & L)

{int I, num

Elem type e；;

L. 길이 = 0;

Printf ("정렬 목록을 만들고 목록 길이를 입력하십시오. \ n");

Scanf("%d ",& ampnum);

Printf ("입력 데이터 %d 자리 숫자 \n", num);

For (I =1; 나<= numi++){

Scanf("%d ",& ampe);

삽입 (l, e);

}

}

/* 두 개의 정렬 목록 병합 */

Void MergeList(SqList La, SqList Lb, SqList & ampLc)

{int *pa, *pb, * PC

If (la.length+lb.length > MAXSIZE) 종료 (오버플로);

기타

{pa = la.elempb = lb.elempc = lc.elem

대신 (pa< 길이와 길이. & amppb & lt 파운드 요소+포인트 길이)

* p c++= (* pa < =*pb)? * pa++:* Pb++; /* 공개 * * * 부분 통합 */

(pa & ltla.elem+la.length) * p c++= * pa++;

/*R 1 테이블의 나머지 부분은 r 뒤에 있습니다 */

While(Pb & lt；; Lb.elem+lb.length) * p c++= * p b++;

/*R2 테이블의 나머지 부분은 r 뒤에 있습니다 */

Lc.length = la.length+lb.length; /*R 테이블 길이 */

}

}

//요소가 대칭인지 여부를 결정하고 대칭은 TRUE 또는 FALSE 를 반환합니다.

상태 대칭 (SqList L)

{int 낮음, 높음;

낮음 = 0;

높음 = l.length-1;

While(low & lt；; 높음)

If (l.elem [low] = = l.elem [high]) {lo w++; 높음-; }

Else 반환 (false); 반환 (참); }

//시퀀스 테이블의 주 함수 섹션

//# 에는 "seqlist.h" 가 포함되어 있습니다

Void main ()

{L2 의 sqlist l1;

Int select

Elem type e；;

Do {printf ("\ n1insert2merge");

Printf("\n3 대칭 0 종료 \ n ");

Printf ("선택 (0-3) \ n");

Scanf("%d ",& 선택);

스위치 (선택) {

사례 1:

Init 목록 (l);

Createlist _ sorted (l);

순회 (l, print data);

Printf(" \ n 삽입된 요소 입력 \ n ");

Scanf("%d ",& ampe);

삽입 (l, e);

순회 (l, print data);

깨뜨리다

사례 2:

Initlist (l1);

Createlist _ sorted (l1);

순회 (L 1, printdata);

Init 목록 (L2);

Createlist _ sorted (L2);

와이어 (L2, 플롯 데이터);

Init 목록 (l);

목록 병합 (L 1, L2, l);

순회 (l, print data);

깨뜨리다

사례 3:

Init 목록 (l);

목록 만들기 (l);

순회 (l, print data);

If (symmetric (l)) printf ("예! \ n "); Elseprintf ("not \ n");

깨뜨리다

사례 0: 깨진;

기본값: printf ("오류! 다시 해봐! \ n ");

}

}while (선택);

}

/* 단방향 연결된 목록 관련 작업의 예 */

/* 유형 정의 및 헤더 파일 (파일 이름 sllink.h*/

# include & ltstdio.h & gt

# include & ltstdlib.h & gt

Typedef int ElemType// 요소의 실제 유형입니다

Typedef 구조 LNode{

요소 유형 데이터

Struct LNode * next

}LNode, * LinkList// 노드 및 포인터 유형 이름 정의.

//순서가 잘못된 연결된 목록의 플러그 방법 설정

Void CreateList (링크 목록 & ampL){

연결된 목록 p;

Elem type e；;

L = (linklist) malloc (sizeof (lnode));

L-> Next = NULL

Printf ("헤드 삽입법은 0 으로 끝나는 연결된 목록을 만듭니다. \ n");

Scanf("%d ",& ampe);

While(e){

P = (linklist) malloc (sizeof (lnode));

P->; 데이터 = e；;

P->; Next = L-& gt；; 다음으로,

L-> Next = p；;

Scanf("%d ",& ampe);

}

}

/* 비내림차순 단방향 연결된 목록 l 삽입 요소 e 시퀀스는 여전히 순서대로 */

Void Insert_Sort (링크 목록 & ampl, ElemType e){

연결된 목록 p, s;

S = (linklist) malloc (sizeof (lnode));

S-> 데이터 = e；;

P = L；;

While (p->; Next & amp & ampp->; 다음-> 데이터 & lt=e)

P = p-& gt；; 다음으로, /* 삽입 위치 찾기 */

S-> Next = p-& gt；; 다음으로, /* Insert 문 *p 노드 다음에 *s 노드 */

P->; Next = s；;

}

/* 오름차순 단방향 연결된 목록 만들기 */

Void Create_Sort (링크 목록 & ampL){

Elem type e；;

L = (linklist) malloc (sizeof (lnode));

L-> Next = NULL

Printf ("순서 테이블을 작성하고 임의의 정수 데이터를 입력하여 0 으로 끝남 \ n");

Scanf("%d ",& ampe);

While(e){

Insert_Sort(L, e);

Scanf("%d ",& ampe);

}

}

/* 단방향 연결된 목록 순회 */

잘못된 트래버스 (연결된 목록 L){

연결된 목록 p;

Printf ("연결된 목록 통과");

For (p = l-> 다음으로, P; P = p-& gt；; 다음)

Printf("%5d ",p-> 데이터);

Printf ("\ n");

}

/* 요소 삭제 e*/

유효하지 않은 삭제 (연결된 목록 & ampl, ElemType e){

연결된 목록 p, q;

P = L；;

Q = L-& gt；; 다음으로,

그리고 (q& & ampq->; 데이터! =e){// 요소의 삭제 위치를 찾습니다.

P = q；;

Q = q-& gt；; 다음으로,

}

만약 (! Q)printf(" \ n 삭제되지 않음 "); /* 요소 e*/

Else {p-& gt；; Next = q-& gt；; 다음으로, /* 찾은 삭제 */

무료 (q); }

}

/* 단방향 연결된 목록의 반전 */

잘못된 교환 (연결된 목록 및 ampl) {

연결된 목록 p, s;

P = L-& gt；; 다음으로,

L-> Next = NULL

While(p){

S = p；;

P = p-& gt；; 다음으로,

S-> Next = L-& gt；; 다음으로,

L-> Next = s；;

}

}

/* 두 개의 비감산 단방향 연결된 목록이 병합된 후에도 여전히 비감산 시퀀스 */

연결된 목록 La, 연결된 목록 Lb, 연결된 목록 & ampLc){

연결된 목록 p, q, s, 뒤;

P = La-& gt；; 다음으로,

Q=Lb- > 다음;

Lc = 후면 = La

무료 (파운드);

그리고 (p & amp& amp 질문) {

만약 (p->; 데이터<q->; 데이터) {s = p; P = p-& gt；; 다음으로, }

Else {s = q；; Q = q-& gt；; 다음으로, }

후면-> Next = s；; /* 작은 요소 삽입 바닥글 */

후면 = 후면-> 다음으로,

}

If (p) rear-> Next = p；; Else rear-& gt；; Next = q；;

}

/* 주 함수 섹션, 파일 이름은 sllink.c*/

//# 에는 "sllink.h" 가 포함되어 있습니다

Void main(){

연결된 목록 La, Lb, LC;

Elem type e；;

Int select

을 (를) 하다

Printf(" 1 순서가 지정되지 않은 테이블 생성 및 지정된 요소 삭제 \ n ");

Printf(" 2. 증분 순서 테이블을 생성하고 \ n ");

Printf(" 3) 는 두 개의 증분 순서 테이블을 생성하여 계속 증가하는 하나의 테이블로 결합합니다. \ n ");

Printf(" 0 종료, 옵션 입력 (0-3) \ n ");

Scanf("%d ",& 선택);

스위치 (선택) {

시나리오 0:

깨뜨리다

사례 1:

목록 만들기 (la);

순회 (라);

Printf ("삭제할 요소 입력 \ n");

Scanf("%d ",& ampe);

삭제 (La, e);

순회 (라);

깨뜨리다

사례 2:

Create _ sort (la);

순회 (라);

엑치 (la);

Printf ("교환 목록 \ n");

순회 (라);

깨뜨리다

사례 3:

Create _ sort (la); 순회 (라);

Create _ sort (lb); 트래버스 (파운드);

MergeIncrease(La, Lb, LC) ： 순회 (LC);

깨뜨리다

기본값:

Printf ("입력 옵션이 잘못되었습니다. 다시 입력하십시오! \ n ");

}

}while (선택);

}

이 내용이 너에게 도움이 될지 모르겠다.