#include <malloc.h>
#include <stdlib.h>
#define LIST_INIT_SIZE 10 // 线性表存储空间的初始分配量
#define LISTINCREMENT 2 // 线性表存储空间的分配增量
struct SqList
{
int *elem // 存储空间基址
int length // 当前长度
int listsize // 当前分配的存储容量(以sizeof(int)为单位)
}
void InitList(SqList &L)
{ // 操作结果：构造一个空的顺序线性表
L.elem = (int *)malloc(LIST_INIT_SIZE*sizeof(int))
if (!L.elem)
exit(0) // 存储分配失败
L.length = 0 // 空表长度为0
L.listsize = LIST_INIT_SIZE // 初始存储容量
}
int ListInsert(SqList &L, int i, int e)
{ // 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1
// 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1
int *newbase, *q, *p
if (i<1 || i>L.length + 1) // i值不合法
return 0
if (L.length >= L.listsize) // 当前存储空间已满,增加分配
{
if (!(newbase = (int *)realloc(L.elem, (L.listsize + LISTINCREMENT)*sizeof(int))))
exit(0) // 存储分配失败
L.elem = newbase // 新基址
L.listsize += LISTINCREMENT // 增加存储容量
}
q = L.elem + i - 1 // q为插入位置
for (p = L.elem + L.length - 1 p >= q --p) // 插入位置及之后的元素右移
*(p + 1) = *p
*q = e // 插入e
++L.length // 表长增1
return 1
}
void Print(SqList &L)
{
int i
for (i = 0 i<L.length i++)
printf("%d ", *(L.elem + i))
printf("\n")
}
// ————————————————————————————————————
// 函数①
void MergeList1(SqList La, SqList Lb, SqList &Lc)
{
int *pa, *pa_last, *pb, *pb_last, *pc
pa = La.elem
pb = Lb.elem
Lc.listsize = Lc.length = La.length + Lb.length//不用InitList()创建空表Lc
pc = Lc.elem = (int *)malloc(Lc.listsize*sizeof(int))
if (!Lc.elem) // 存储分配失败
exit(0)
pa_last = La.elem + La.length - 1
pb_last = Lb.elem + Lb.length - 1
while (pa <= pa_last&&pb <= pb_last) // 表La和表Lb均非空
{ // 归并
if (*pa < *pb)
*pc++ = *pa++
else if (*pa > *pb)
*pc++ = *pb++
else{
*pc++ = *pa++
pb++
Lc.length--
}
}
while (pa <= pa_last) // 表La非空且表Lb空
*pc++ = *pa++ // 插入La的剩余元素
while (pb <= pb_last) // 表Lb非空且表La空
*pc++ = *pb++ // 插入Lb的剩余元素
}
// ————————————————————————————————————
// 函数②
void MergeList2(SqList La, SqList &Lb, SqList &Lc)
{
int *pa, *pa_last, *pb, *pb_last, *pc
pa = La.elem
pb = Lb.elem
Lc.listsize = Lc.length = La.length + Lb.length//不用InitList()创建空表Lc
pc = Lc.elem = (int *)malloc(Lc.listsize*sizeof(int))
if (!Lc.elem) // 存储分配失败
exit(0)
pa_last = La.elem + La.length - 1
pb_last = Lb.elem + Lb.length - 1
while (pa <= pa_last&&pb <= pb_last) // 表La和表Lb均非空
{ // 归并
if (*pa <= *pb)
*pc++ = *pa++
else
*pc++ = *pb++
}
while (pa <= pa_last) // 表La非空且表Lb空
*pc++ = *pa++ // 插入La的剩余元素
while (pb <= pb_last) // 表Lb非空且表La空
*pc++ = *pb++ // 插入Lb的剩余元素
Lb.length = Lc.length
Lb = Lc
}
// ————————————————————————————————————
// 函数③
void Inverse(SqList &L){
int i, t
for (i = 0 i < L.length / 2 i++)
{
t = *(L.elem + i)
*(L.elem + i) = *(L.elem + L.length - i - 1)
*(L.elem + L.length - i - 1) = t
}
}
void main(){
SqList LA, LB, LC
int a[4] = { 3, 5, 8, 11 }, b[7] = { 2, 6, 8, 9, 11, 15, 20 }
int i
InitList(LA)
InitList(LB)
InitList(LC)
for (i = 0 i < 4 i++)
ListInsert(LA, i + 1, a[i])
for (i = 0 i < 7 i++)
ListInsert(LB, i + 1, b[i])
printf("LA=")
Print(LA)
printf("LB=")
Print(LB)
printf("\n")
MergeList1(LA, LB, LC)
printf("①LC=")
Print(LC)
printf("\n")
MergeList2(LA, LB, LC)
printf("②LB=")
Print(LB)
printf("\n")
printf("③LC=")
Inverse(LC)
Print(LC)
}
#include <stdio.h>#include <stdlib.h>
#define ElemType int
#define Status int
#define OVERFLOW -1
#define ERROR 0
#define OK 1
/* 线性表的动态分配顺序存储结构 */
#define LIST_INIT_SIZE 10 /* 线性表存储空间的初始分配量 */
#define LIST_INCREMENT 2 /* 线性表存储空间的分配增量 */
typedef struct {
ElemType *elem /* 存储空间基址 */
int length /* 当前长度 */
int listsize /* 当前分配的存储容量(以sizeof(ElemType)为单位) */
} SqList
/* 操作结果：构造一个空的顺序线性表L */
void InitList(SqList *L) {
L->elem=malloc(LIST_INIT_SIZE*sizeof(ElemType))
if(!L->elem)
exit(OVERFLOW) /* 存储分配失败 */
L->length=0 /* 空表长度为0 */
L->listsize=LIST_INIT_SIZE /* 初始存储容量 */
}
/* 初始条件：顺序线性表L已存在。操作结果：销毁顺序线性表L */
void DestroyList(SqList *L) {
free(L->elem)
L->elem=NULL
L->length=0
L->listsize=0
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L)+1 */
/* 操作结果：在L中第i个位置之前插入新的数据元素e，L的长度加1 */
Status ListInsert(SqList *L,int i,ElemType e) {
ElemType *newbase,*q,*p
if(i<1||i>L->length+1) /* i值不合法 */
return ERROR
if(L->length>=L->listsize) { /* 当前存储空间已满,增加分配 */
newbase=realloc(L->elem,(L->listsize+LIST_INCREMENT)*sizeof(ElemType))
if(!newbase)
exit(OVERFLOW) /* 存储分配失败 */
L->elem=newbase /* 新基址 */
L->listsize+=LIST_INCREMENT /* 增加存储容量 */
}
q=L->elem+i-1 /* q为插入位置 */
for(p=L->elem+L->length-1p>=q--p) /* 插入位置及之后的元素右移 */
*(p+1)=*p
*q=e /* 插入e */
++L->length /* 表长增1 */
return OK
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：删除L的第i个数据元素，并用e返回其值，L的长度减1 */
Status ListDelete(SqList *L,int i,ElemType *e) {
ElemType *p,*q
if(i<1||i>L->length) /* i值不合法 */
return ERROR
p=L->elem+i-1 /* p为被删除元素的位置 */
*e=*p /* 被删除元素的值赋给e */
q=L->elem+L->length-1 /* 表尾元素的位置 */
for(++pp<=q++p) /* 被删除元素之后的元素左移 */
*(p-1)=*p
L->length-- /* 表长减1 */
return OK
}
/* 初始条件：顺序线性表L已存在，1≤i≤ListLength(L) */
/* 操作结果：打印顺序线性表所有元素 */
void OutputList(SqList *L) {
ElemType *p
int i
p=L->elem /* p的初值为第1个元素的存储位置 */
for (i=1 i<=L->length i++, p++)
printf ("%d\t", *p)
putchar ('\n')
}
int main () {
SqList L /*定义顺序表*/
ElemType *p,e
int i
ElemType X=5 /*程序欲删除元素值为X的元素*/
InitList (&L) /*初始化顺序表*/
/*插入若干元素*/
ListInsert (&L,1,1)
ListInsert (&L,1,2)
ListInsert (&L,3,5)
ListInsert (&L,4,3)
ListInsert (&L,5,5)
ListInsert (&L,6,4)
printf ("初始顺序线性表内容为：\n")
OutputList (&L)
putchar ('\n')
/*删除元素值为x的元素*/
p=L.elem /* p的初值为第1个元素的存储位置 */
for (i=1 i<=L.length i++, p++) {
if (*p == X) {
ListDelete (&L,i,&e)
printf ("第%d个元素，其值为%d，已删除！\n", i, e)
}
}
putchar ('\n')
printf ("删除元素值为x的元素之后顺序线性表内容为：\n")
OutputList (&L)
putchar ('\n')
getch ()
return 0
}
运行结果
数组知道吧?数组这样定义的吧?
int a[10]
C可以这样赋值吧?
int *p
p=a
这个p就可以看成是一个基址
这个数组的其他元素,都是通过在这个地址的基础上加上不同的数值来访问的
高级语言可能都弱化了地址的概念,比较典型的代表的就是变量,当然变量在汇编语言里也很常用,但编译成机器语言的时候都(大概是都)是通过地址,也就是指针来存取变量的,所以学高级语言很容易在这样那样的问题上费解,学学汇编吧,很好玩的
======================
以后问问题的时候可不可以别加那个"高手进"?
都不好意思点进来
