数据结构——顺序表

     线性表:   线性表就是数据排成像一条线一样的结构.每个现行表上的数据最多只有前和后两个方向.常见的线性表结构：数组，链表、队列、栈等。

顺序表则是线性表里的一个分支，表示的是用一组地址连续的储存单元依次储存线性表的数据元素，这种表示也称作线性表的顺序储存结构。

老师的代码：

1.typedef struct SequentialList 功能：创建长度为的顺序表 
2.SequentialListPtr sequentialListInit功能：初始化 
3.void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue)  功能：位置paraPosition处插入元素paraValue
4.int sequentialListDelete(SequentialListPtr paraListPtr, int paraPosition)功能：删除位置paraPosition处元素 
5.int locateElement(SequentialListPtr paraListPtr, int paraValue)功能：返回第一个等于paraValue的元素的位置
6.void outputList(SequentialListPtr paraList) 功能：遍历顺序表，并输出
7.void clearList(SequentialListPtr paraListPtr)功能：清空顺序表

8.int locateElement(SequentialListPtr paraListPtr, int paraValue) 功能：找到给出元素在数组中的位置

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

#define LIST_MAX_LENGTH 100

/**
  * The list contains only int values to kepp it as simple as possible
  */
typedef struct SequentialList{

	int actualLength;

	int data[LIST_MAX_LENGTH];//The maximum length 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 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 be a pointer to change the list.
 * @param paraValues An int array storing all elements.
 */
SequentialListPtr sequentialListInit(int paraData[], int paraLength) {
	SequentialListPtr resultPtr = (SequentialList*)malloc(sizeof(SequentialList));
	for (int i = 0; i < paraLength; i++)
	{
		resultPtr->data[i] = paraData[i];
	}//Of for i
		resultPtr->actualLength = paraLength;

		return resultPtr;
}//Of sequnetialListInit

/**
 * Insert an element into 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.
 * @param paraValue The value to be inserted.
 */

void sequentialListInsert(SequentialListPtr paraListPtr, int paraPosition, int paraValue) {
    // Step 1. Space check.
    if (paraListPtr->actualLength >= LIST_MAX_LENGTH) {
        printf("Cannot insert element: list full.\r\n");
        return;
    }//Of if

    // Step 2. Position check.
    if (paraPosition < 0) {
        printf("Cannot insert element: negative position unsupported.");
        return;
    }//Of if
    if (paraPosition > paraListPtr->actualLength) {
        printf("Cannot insert element: the position %d is bigger than the list length %d.\r\n", paraPosition, paraListPtr->actualLength);
        return;
    }//Of if

    // Step 3. Move the remaining part.
    for (int i = paraListPtr->actualLength; i > paraPosition; i--) {
        paraListPtr->data[i] = paraListPtr->data[i - 1];
    }//Of for i

    // Step 4. Insert.
    paraListPtr->data[paraPosition] = paraValue;

    // Step 5. Update the length.
    paraListPtr->actualLength++;
}// Of sequentialListInsert


/**
 * Test the insert function.
 */
void sequentialInsertTest() {
    int i;
    int tempArray[5] = { 3,5,2,7,4 };

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

    // Initiallize.
    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 beyoud the tail.
    printf("Now inser 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) {
    // Step 1. Position check.
    if (paraPosition < 0) {
        printf("Invalid position: %d.\r\n", paraPosition);
        return -1;
    }//Of if

    if (paraPosition >= paraListPtr->actualLength) {
        printf("Cannot delete element: the position %d is beyond the list length %d.\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }//Of if

    // Step 2. Move 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

    // Step 3. Update the length.
    paraListPtr->actualLength--;

    // Step 4. Return the value.
    return resultValue;
}// Of sequentialListDelete

/**
 * 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 The 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 paraPosition The given position.
 * @return The position of the value, or  -1 indicating not exists
 */
int getElement(SequentialListPtr paraListPtr, int paraPosition) {
    // Step 1. Position check.
    if (paraPosition < 0) {
        printf("Invalid position: %d.\r\n", paraPosition);
        return -1;
    }//Of if

    if (paraPosition >= paraListPtr->actualLength) {
        printf("Cannot delete element: the position %d is beyond the list length %d.\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }//Of if

    return paraListPtr->data[paraPosition];
}// Of locateElement

/**
 * Clear elements in the list.
 * @param paraListPtr The pointer to the list.
 * @return The position of the value, or  -1 indicating not exists
 */
void clearList(SequentialListPtr paraListPtr) {
    paraListPtr->actualLength = 0;
}// Of clearList

/**
 The entrance.
 */
void main() {
    sequentialInsertTest();
    sequentialDeleteTest();
}// Of main

自己实现的函数部分

int locateElement(SequentialListPtr paraListPtr, int paraValue) {
    for (int i = paraListPtr->actualLength - 1; i >= 0; i--) {
        if (paraListPtr->data[i] == paraValue) {
            return i;
        }
    }
 
    return -1;
}//找到给出数字在数组中的位置
 

int getElement(SequentialListPtr paraListPtr, int paraPosition) {
    
    if (paraPosition < 0) {
        printf("%d.\r\n", paraPosition);
        return -1;
    }//检查输入数字是否小于0
 
    if (paraPosition >= paraListPtr->actualLength) {
        printf(" %d.\r\n", paraPosition, paraListPtr->actualLength);
        return -1;
    }//检查输入数字是否超过数组大小
 
    return paraListPtr->data[paraPosition];
}//找出所给顺序表位置的数字
 

void clearList(SequentialListPtr paraListPtr) {
    (*paraListPtr).actualLength = 0;//直接令表长为0
}//清空顺序表
 

总结：对代码的开发还能有进一步精简和改善，顺序表相较链表也有优点，顺序表的内存空间连续，尾插、尾删效率较高，可以高效操作。对线性表的熟练掌握应是我们程序猿的基操。