数据结构第二次课作业

收获：问题思考和代码的简单化，直接化，以及更加注意代码的规范性

1.代码

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

#define LIST_MAX_LENGTH 10

/**
 *Linear list 0f integers.The key is data.
 */
typedef struct SequentialList
{
	int actualLength;
	int data[LIST_MAX_LENGTH];//the maximum is fixed.
}*SequentialListPtr;

/* Output the list */
void outputList(SequentialListPtr paraList)
{
	for(int i=0;i<paraList->actualLength;i++)
	{
		printf("%d ",paraList->data[i]);
	}//of for i
	printf("\r\n");
}//of outputList\

/* output the memory for the list. */
void outputMemory(SequentialListPtr paraListPtr)
{
	printf("The address of the structure:%ld\r\n",paraListPtr);
	printf("The address of the actualLength:%ld\r\n",&paraListPtr->actualLength);
	printf("The address of data:%ld\r\n",&paraListPtr->data);
	printf("The address of actual data:%ld\r\n",&paraListPtr->data[0]);
	printf("The address of second data:%ld\r\n",&paraListPtr->data[1]);
	
}//of outputMemory

/*
 *Initialize a sequential list.No error checking for this function.
 *@param paraListPtr The pointer to the list.It must to be a pointer to change the list
 *@param paraValues An int array storing all elements.
 */
SequentialListPtr sequentialListInit(int paraData[], int paraLength)
{
	SequentialListPtr resultPtr=(SequentialListPtr)malloc(sizeof(struct SequentialList));
	for(int i=0;i<paraLength;i++)
	{
		resultPtr->data[i]=paraData[i];
	}//of for i
	resultPtr->actualLength=paraLength;
	
	return resultPtr; 
}//of SequentialListInit

/**
 *Insert an element into asequential linear list.
 *@param paraListPtr The pointer to the list.It must be a pointer to change the list.
 @param paraPotion The position,e.g.,0 stands for inserting at the first position.
 @param paraValue Tne value to be inserted.
 */

void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue)
{
	//step1. Space check.
	if(paraListPtr->actualLength>=LIST_MAX_LENGTH)
	{
		printf("can't insert element:list is full.\r\n'");
		return;
	}//of if
	
	//step2 Position check.
	if(paraPosition<0)
	{
		printf("can't insert element:negative position unsupported.\r\n'");
		return;
	}//of if
	if(paraPosition>paraListPtr->actualLength)
	{
		printf("can't inseret element:the position %d is bigger than the list length %d\r\n",paraPosition,paraListPtr->actualLength);
		return;
	}//of if;
	
	//step3 Moving the remaining part.
	for(int i=paraListPtr->actualLength;i>paraPosition;i--)
	{
		paraListPtr->data[i]=paraListPtr->data[i-1];
	}//of for i
	
	//step4 insert.
	paraListPtr->data[paraPosition]=paraValue;
	
	//step5 Update the length.
	paraListPtr->actualLength++;
}//of sequentialListInsert
/* Test the insert function */
void sequentialInsertTest()
{
	int i;
	int tempArray[5]={3,5,2,7,4};
	
	printf("---sequentialInsertTest begings.---\r\n");
	
	//Initialize
	SequentialListPtr tempList = sequentialListInit(tempArray,5);
	printf("After initialization, the list is: ");
	outputList(tempList);
	
	//Insert to the first.
	printf("Now insert to the first, the list is: ");
	sequentialListInsert(tempList,0,8);
	outputList(tempList);
	
	//Insert to the last.
	printf("Now insert to the last, the list is: ");
	sequentialListInsert(tempList,6,9);
	outputList(tempList);
	
	// Insert beyond the tail.
    printf("Now insert beyond the tail. \r\n");
	sequentialListInsert(tempList, 8, 9);
    printf("The list is:");
	outputList(tempList);

	// Insert to position 3.
	for (i = 0; i < 5; i ++) {
		printf("Inserting %d.\r\n", (i + 10));
		sequentialListInsert(tempList, 0, (i + 10));
		outputList(tempList);
	}//Of for i

    printf("---- sequentialInsertTest ends. ----\r\n");
}// Of sequentialInsertTest

/**
 * Delete an element from a sequential linear list.
 * @param paraListPtr The pointer to the list. It must be a pointer to change the list.
 * @param paraPosition The position, e.g.,0 stands for inserting at the first position.
 * @return The deleted value.
 */
 int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition)
 {
 	//step1 Position check.
 	if(paraPosition<0)
 	{
 		printf("Invalid position:%d\r\n",paraPosition);
 		return -1;
	 }//of if
	 
	if(paraPosition>paraListPtr->actualLength)
	{
		printf("can't delete element:the position %d is beyondthe list length %d\r\n",paraPosition,paraListPtr->actualLength);
		return-1;
	}//of if
	
	//step2 MOving the remaining part.
	int resultValue=paraListPtr->data[paraPosition];
	for(int i=paraPosition;i<paraListPtr->actualLength;i++)
	{
		paraListPtr->data[i]=paraListPtr->data[i+1];
	}//of for i
	
	//step3 update the length.
	paraListPtr->actualLength--;
	
	//step4 return the length.
	return resultValue;
  } //of msequentailListDelete
/* test the delete function. */
void sequentialDeleteTest() {
	int tempArray[5] = {3, 5, 2, 7, 4};

    printf("---- sequentialDeleteTest begins. ----\r\n");

	// Initialize.
    SequentialListPtr tempList = sequentialListInit(tempArray, 5);
    printf("After initialization, the list is: ");
	outputList(tempList);

	// Delete the first.
    printf("Now delete the first, the list is: ");
	sequentialListDelete(tempList, 0);
	outputList(tempList);

	// Delete to the last.
    printf("Now delete the last, the list is: ");
	sequentialListDelete(tempList, 3);
	outputList(tempList);

	// Delete the second.
    printf("Now delete the second, the list is: ");
	sequentialListDelete(tempList, 1);
	outputList(tempList);

	// Delete the second.
    printf("Now delete the 5th, the list is: ");
	sequentialListDelete(tempList, 5);
	outputList(tempList);

	// Delete the second.
    printf("Now delete the (-6)th, the list is: ");
	sequentialListDelete(tempList, -6);
	outputList(tempList);

    printf("---- sequentialDeleteTest ends. ----\r\n");

	outputMemory(tempList);
}// Of sequentialDeleteTest
/**
 *Locate an element in the list.
 *@param paraListPtr the pointer to the list.
 *@param paraValue the indicated value.
 *@return tne position of the value ,or-1 indicating not exists
 */
int locateElement(SequentialListPtr paraListPtr, int paraValue)
{
	for(int i=0;i<paraListPtr->actualLength;i++)
	{
		if(paraListPtr->data[i]==paraValue)
		{
			return i;
		}//of if
	}//of for i
	return -1;
}//of locateElement

/**
 *Get an element in the list.
 *@param paralIstPtr the pointer to the list.
 *@param paraPOsiton the given position.
 *@return the positon of the value, or -1 indicating not exists.
 */
int getElement(SequentialListPtr paraListPtr, int paraPosition)
{
	//step1 positon check.
	if(paraPosition<0)
	{
		printf("Invalid position:%d\r\n",paraPosition);
		return -1;
	}//of if
	if(paraPosition>paraListPtr->actualLength)
	{
		printf("can't get element:the position %d is beyond the list length %d\r\n",paraPosition,paraListPtr);
		return -1;
	}//of if
	
	return paraListPtr->data[paraPosition];
}//of getElement

/**
 *clear elements in the list.
 *@param paraListPtr the pointer to the list.
 *@return the position of the value,or -1 not indicating exists.
 */

void clearList(SequentialListPtr paraListPtr)
{
	paraListPtr->actualLength=0;
}//of clearList
/* the entrance. */
int main()
{
	sequentialInsertTest();
	sequentialDeleteTest();
	return 0;
}//of main

2.运行结果